In the latest JFM/FYFD video, we tackle some of the less pleasant aspects of summer weather: stopping invasive insects, understanding how plants dispense poison, and looking at the physics behind jellyfish stings. And if you’ve missed any of our previous videos, we’ve got you covered. (Image and video credit: T. Crawford and N. Sharp)

Although you may not recognize the name, you’ve probably seen Kalliroscope (top image), a pearlescent fluid that creates beautiful flow patterns when swirled. This rheoscopic fluid was invented in the mid-1960s by artist Paul Matisse and, over the following decades, became a staple of flow visualization techniques. Kalliroscope contained a suspension of crystalline guanine. Since the crystals were asymmetric, they would orient themselves depending on the flow and, from there, scatter light, creating the beautiful pearlescent effect seen above.

Unfortunately for researchers, the production of guanine crystals was expensive and difficult. The cosmetics industry was their main consumer and over time, they moved toward mica and other cheaper mineral alternatives. The company that produced Kalliroscope gave up production in 2014, leaving researchers scrambling for a suitable alternative.

One contender for a new standard rheoscopic fluid is based on shaving cream. By diluting shaving cream 20:1 with water, researchers are able to extract stearic acid crystals, which form an admirable alternative to Kalliroscope (middle collage). Like Kalliroscope, the resulting fluid is pearlescent and reveals flow features well (bottom two images). Stearic acid crystals are also closer in density to water than guanine, so the fluid remains in suspension far better than Kalliroscope. Plus, the best shaving cream is cheap and widely available, meaning that this is a DIY project just about anyone can do! (Image credits: Kalliroscope - P. Matisse; other images - D. Borrero-Echeverry et al.; research credit: D. Borrero-Echeverry et al.)

Granular mixtures with particles of different sizes will often segregate themselves when flowing. In this half-filled rotating drum large red particles and smaller white ones create a stable petal-like pattern. As the drum turns, an avalanche of small particles flows down, forming each white petal. When the avalanche hits the drum wall, a second wave – one of the larger, red particles – flows uphill toward the center of the drum. If the uphill wave has enough time to reach the center of the drum before the next avalanche of smaller particles, then the petal pattern will be stable. Otherwise, the small particles will tend to fall between the larger ones, disturbing the pattern. (Image and research credit: I. Zuriguel et al., source; via reprint in J. Gray)

Inkjet printing and other methods for directing and depositing tiny droplets rely on the force of gravity to overcome the internal forces that hold a liquid together. But that requires using a liquid with finely tuned surface tension and viscosity properties. If your fluid is too viscous, gravity simply cannot provide consistent, small droplets. So researchers are turning instead to sound waves. 

Using an acoustic resonator, scientists are able to generate forces up to 100 times stronger than gravity, allowing them to precisely and repeatably form and deposit micro- and nano-sized droplets of a variety of liquids. In the images above, they’re printing tiny drops of honey, some of which they’ve placed on an Oreo cookie for scale. The researchers hope the technique will be especially useful in pharmaceutical manufacturing, where it could precisely dispense even highly viscous and non-Newtonian fluids. (Image and research credit: D. Foresti et al.; via Smithsonian Mag; submitted by Kam-Yung Soh)

Schlieren photography has an almost magical feeling to it because it enables us to see the invisible – like shock waves and the tiny currents of heat that rise from our skin. But it can also reveal new perspectives on things that aren’t invisible. Here we see soap bubbles viewed through the lens of a schlieren set-up. Schlieren is sensitive to small changes in density, so instead of appearing in their usual rainbow iridescence, the bubbles look glass-like and filled with tiny currents and bubbles. What we’re seeing are some of the many tiny flow variations across the surface of a soap bubble. They’re driven by a combination of forces – gravity, temperature, and surface tension variations, to name a few. Seen in video, you can really appreciate just how dynamic a thin soap film is! (Image credit and submission: L. Gledhill, video version, more stills)

There is a constant drama playing out overhead, though most of us do not take the time to watch. Fortunately, a few, like Blaž Šter, do and make timelapse videos that allow us to enjoy hours of atmospheric drama in only a few minutes. This timelapse shows a cloudy and rainy mid-July day in Slovenia, where an unstable atmosphere leads to turbulent and dramatic clouds. In an unstable atmosphere, it’s easier for vertical motion to take place between altitudes. For example, a parcel of warm air displaced upward will continue to rise because it will be lighter and more buoyant than the surrounding air. This is key to the strong convection that can generate thunderstorms.
(Image and video credit: B. Šter, source)

It turns out that Computational Fluid Dynamics (CFD) has a key role to play in determining the behavior of long extinct creatures. In a previous, post we described a CFD study of parvancorina, and now Pernille Troelsen at Liverpool John Moore University is using CFD for insights into how long-necked plesiosaurs might have swum and hunted.

CFD Water Flow Simulation over an Idealized Plesiosaur: Streamline VectorsIllustration only, not part of the study

read more

Fossilized imprints of Parvancorina from over 500 million years ago have puzzled paleontologists for decades. What makes it difficult to infer their behavior is that Parvancorina have none of the familiar features we might expect of animals, e.g., limbs, mouth. In an attempt to shed some light on how Parvancorina might have interacted with their environment researchers have enlisted the help of Computational Fluid Dynamics (CFD).

CFD Water Flow Simulation over a Parvancorina: Forward directionIllustration only, not part of the study

read more

One of nature's smallest aerodynamic specialists - insects - have provided a clue to more efficient and robust wind turbine design.

Dragonfly: Yellow-winged DarterLicense: CC BY-SA 2.5, André Karwath

read more

The recent attempt to break the 2 hour marathon came very close at 2:00:24, with various aids that would be deemed illegal under current IAAF rules. The bold and obvious aerodynamic aid appeared to be a Tesla fitted with an oversized digital clock leading the runners by a few meters.

2 Hour Marathon Attempt

read more

The Giro d'Italia 2017 is in full swing, so how about an extensive aerodynamic study of various cycling tuck positions? You got it, from members of the same team that brought us the study of pursuit vehicles reducing the drag on cyclists.

Chris Froome TuckStage 8, Pau/Bagnères-de-Luchon, Tour de France, 2016

read more

Early on in the dash to develop ever faster racecars in the 1970s, aerodynamics, and specifically downforce, proved a revelation. Following on quickly from the initial passive downforce initiatives were active aerodynamic solutions. Only providing downforce when needed (i.e., cornering and braking) then reverting to a low drag configuration was an ideal protocol, but short lived due to rule changes in most motor sports (including Formula 1), which banned active aerodynamics. A recent exception to the rule is the highly regulated Drag Reduction System now used in F1. However, road-legal cars are not governed by such regulations and so we have the gloriously unregulated Lamborghini Huracán Performante.

Active Aerodynamics on the Lamborghini Huracán Performante

read more

Here is an extremely simple simulation to set up that has a surprisingly beautiful output. In this post, we will simulation the classic Rayleigh–Bénard convection (see Wikipedia) in 3D using the buoyant solver, buoyantBoussinesqPimpleFoam.

buoyantBoussinesqPimpleFoam is a solver for buoyant, turbulent, incompressible flows. The incompressible part of the solver comes from the fact that it uses the Boussinesq approximation for buoyancy which is only suitable for flows with small density changes (aka incompressible). A good source for the equations in this solver is this blog post.

Simulation Set-up

The basic set-up for this case is simple: a hot bottom surface, a cold top surface, either cyclic or zero-gradient sides, and some initial conditions.

For this example, I used the properties of water, I set the bottom plate at 373 K (don’t ask me why… I know it’s close to boiling point of water), and the top plate at 273 K. For this case, we will not use any turbulent modeling and will simply use a laminar model (this simply means there is only molecular viscosity, there are no simplifications applied to the equations).

Geometry and Mesh

The geometry is shown below. As the geometry is so simple… I will not go over the blockMesh set up. The mesh discretization that I used was simplegrading (i.e. no inflation), with 200x200x50 cells.

Constant

For this case, we will simulate water. The transportProperties file should look like:

transportModel Newtonian;

// Laminar viscosity
nu [0 2 -1 0 0 0 0] 1e-06;

// Thermal expansion coefficient
beta [0 0 0 -1 0 0 0] 0.000214;

// Reference temperature
TRef [0 0 0 1 0 0 0] 300;

// Laminar Prandtl number
Pr [0 0 0 0 0 0 0] 7.56;

// Turbulent Prandtl number (not used)
Prt [0 0 0 0 0 0 0] 0.7;

I don’t typically delete unused entries from dictionaries. This makes using previous simulations as templates much easier. Therefore note that the turbulent Prandtl number is in the dictionary but it is not used.

Selecting Reference Temperature TRef for buoyantBoussinesqPimpleFoam. To answer this recall that when the Boussinesq buoyancy approximation is used, the solver does not solve for the density. It solves the relative density using the linear function:

Therefore, I think it makes sense that we should choose a temperature for that is somewhere in the range of the simulation. Thus I chose Tref=300. Somewhere in the middle!

And the turbulenceProperties file is:

simulationType laminar;

RAS
{
 RASModel laminar;

turbulence off;

printCoeffs off;
}

The g file tells the solver the acceleration due to gravity, as well as the direction:

dimensions [0 1 -2 0 0 0 0];
value (0 -9.81 0);

Boundary Conditions

In the “zero” folder, we need the following files: p, p_rgh, T, U, and alphat (this file needs to be present… however it is not used given the laminar simulationType.

T:

dimensions [0 0 0 1 0 0 0];

internalField uniform 273;

boundaryField
{
 floor
 {
 type fixedValue;
 value uniform 373;
 }
 ceiling
 {
 type fixedValue;
 value uniform 273;
 }
 fixedWalls
 {
 type zeroGradient;
 }
}

p_rgh:

dimensions [0 2 -2 0 0 0 0];

internalField uniform 0;

boundaryField
{
floor
{
type fixedFluxPressure;
rho rhok;
value uniform 0;
}

ceiling
{
type fixedFluxPressure;
rho rhok;
value uniform 0;
}

fixedWalls
{
type fixedFluxPressure;
rho rhok;
value uniform 0;
}
}

p:

dimensions [0 2 -2 0 0 0 0];

internalField uniform 0;

boundaryField
{
 floor
 {
 type calculated;
 value $internalField;
 }

ceiling
 {
 type calculated;
 value $internalField;
 }

fixedWalls
 {
 type calculated;
 value $internalField;
 }
}

U:

dimensions [0 1 -1 0 0 0 0];

internalField uniform (0 0 0);

boundaryField
{
 floor
 {
 type noSlip;
 }

ceiling
 {
 type noSlip;
 }

fixedWalls
 {
 type noSlip;
 }
}

Simulation Results

The results (as always) are the best part. But especially for this case since they are so nice to look at! I have made a couple animations of temperature fields and contours. Enjoy.

Conclusion

This case demonstrated the simple set up of a case using buoyantBoussinesqPimpleFoam. The case (Rayleigh-Bénard convection) was simulated in 3D on a fine grid.

Comments and questions are welcome! Keep in mind I set this case up very quickly.

This post is a simple demonstration of the timeVaryingFixedUniformValue boundary condition. This boundary condition allows a Dirichlet-type boundary condition to be varied in time. To demonstrate, we will modify the oscillating cylinder case.

Set-Up

Instead of using the oscillating boundary condition for point displacement. We will have the cylinder do two things:

• Move in a circular motion
• Move in a sinusoidal decay motion

The basics of this boundary condition are extremely simple. Keep in mind that although (here) we are modifying the pointDisplacement boundary condition for the cylinder, the basics of this BC would be the same if you were doing a time varying boundary condition for say pressure or velocity.

In the pointDisplacement file:

 cylinder
 {
 type timeVaryingUniformFixedValue;
 fileName "prescribedMotion";
 outOfBounds clamp;
 }

fileName points to the file where the time varying boundary condition is defined. Here we used a file called prescribedMotion however you can name it whatever you want. The outOfBounds variable dictates what the simulation should do if the simulation time progresses outside of the time domain defined in the file.

The additional file containing the desired motion prescribedMotion is formatted in the following way:

(
( 0 (0 0 0))
( 0.005 (-0.0000308418795848531 0.00392682932795517 0))
( 0.01 (-0.0001233599085671 0.00785268976953207 0))
( 0.015 (-0.000277531259507496 0.0117766126774107 0))
( 0.02 (-0.00049331789293211 0.0156976298823283 0))
...
( 9.99 (-0.0001233599085671 -0.00785268976953189 0))
( 9.995 (-0.0000308418795848531 -0.00392682932795479 0))
( 10 (0 -3.06161699786838E-016 0))
)

The first column is the time in seconds, and the vector defines the point displacement. In the present tutorial, these points were calculated in libreOffice and then exported into the text file.  I arbitrarily made up the motions purely for the sake of making this blog post.

The circular motion was defined as:

and 

Decaying sinusoidal motion was:

The rest of the set-up is identical to the set-up in the oscillating cylinder example. The solver pimpleDyMFoam is then run.

Results

Circular Motion

Sinusoidal Decay

Conclusions

This post demonstrated how a more complicated motion can be prescribed by using a little math and the timeVaryingUniformFixedValue boundary condition. Always like to hear questions and comments! Has anybody else done something like this?

The equations used to describe steady 1D isentropic flow are derived from conservation of mass, momentum, and energy, as well as an equation of state (typically the ideal gas law).

These equations are typically described as ratios between the local static properties (p, T, ) and their stagnation property as a function of Mach number and the ratio of specific heats, . Recall that Mach number is the ratio between the velocity and the speed of sound, a.

These ratios are given here:

Temperature:

Pressure:

Density:

In addition to the relationships between static and stagnation properties, 1D nozzle flow offers an equation regarding the choked cross-sectional flow area (recall that the flow is choked when M=1.)

Some excellent references for these equations are:

• Gas Dynamics Vol. I – Zucrow and Hoffman – 1976
• Gas Dynamics – John and Keith – 2nd Ed. – 2006

Establishing grid convergence is a necessity in any numerical study. It is essential to verify that the equations are being solved correctly and that the solution is insensitive to the grid resolution. Some great background and details can be found from NASA:

https://www.grc.nasa.gov/WWW/wind/valid/tutorial/spatconv.html

First, here is a summary the equations and steps discussed here (in case you don’t want to read the whole example):

1. Complete at least 3 simulations (Coarse, medium, fine) with a constant refinement ratio, r, between them (in our example we use r=2)
2. Choose a parameter indicative of grid convergence. In most cases, this should be the parameter you are studying. ie if you are studying drag, you would use drag.
3. Calculate the order of convergence, p, using:
   • 
4. Perform a Richardson extrapolation to predict the value at h=0
   • 
5. Calculate grid convergence index (GCI) for the medium and fine refinement levels
   • 
6. Ensure that grids are in the asymptotic range of convergence by checking:
   • 

So what is a grid convergence study? Well, the gist of it is that you refine the mesh several times and compare the solutions to estimate the error from discretization. There are several strategies to do this. However, I have always been a fan of the following method: Create a very fine grid and simulate the flow problem. Then reduce the grid density twice, creating a medium grid, and coarse grid.

There are several strategies to do this. However, I have always been a fan of the following method: Create a very fine grid and simulate the flow problem. Then reduce the grid density twice, creating a medium grid, and coarse grid. To keep the process simple, the ratio of refinement should be the same for each step. ie. if you reduce the grid spacing by 2 in each direction between the fine and medium grid, you should reduce it again by 2 between the medium and coarse grid. In the current example, I generated three grids for the cavity problem with a refinement ratio of 2:

• Fine grid: 80 cells in each direction – (6400 cells)
• Medium grid: 40 cells in each direction – (1600 cells)
• Coarse grid: 20 cells in each direction – (400 cells)

Velocity contour plots are shown in the following figures:

We can see from the figures that the quality of the simulation improves as the grid is refined. However, the point of a grid convergence study is to quantify this improvement and to provide insight into the actual quality of the fine grid.

The accuracy of the fine grid is then examined by calculating the effective order of convergence, performing a Richardson extrapolation, and calculating the grid convergence index. As well, (as stated in the article from NASA), it is helpful to ensure that you are in the asymptotic range of convergence.

What are we examining?

It is very important at the start of a CFD study to know what you are going to do with the result. This is because different parameters will converge differently. For example, if you are studying a higher order parameter such as local wall friction, your grid requirements will probably be more strict than if you are studying an integral (and hence lower order) parameter such as coefficient of drag. You only need to ensure that the property or parameter that you are studying is grid independent. For example, if you were studying the pressure increase across a shockwave, you would not check that wall friction somewhere else in the simulation was converged (unless you were studying wall friction as well).  If you want to be able to analyze any property in a simulation, both high and low order, then you should do a very rigorous grid convergence study of primitive, integrated and derived variables.

In our test case lets pretend that in our research or engineering project that we are interested in the centerline pressure and velocity. In particular, let’s say we are interested in the profiles of these variables along the centerline as well as their peak values. The centerline profiles of velocity and pressure are shown in the following figures:

Calculate the effective order of convergence

From our simulations, we have generated the following data for minimum pressure along the centerline, and maximum velocity along the centerline:

The order of convergence, p, is calculated with the following equation:

where r is the ratio of refinement, and f1 to f3 are the results from each grid level.

Using the data we found, p = 1.84 for the minimum pressure and p=1.81 for the maximum velocity.

Perform Richardson extrapolation of the results

Once we have an effective order, p, we can do a Richardson extrapolation. This is an estimate of the true value of the parameter we are examining based on our order of convergence. The extrapolation can be performed with the following equation:

recall that r is the refinement ratio and is which in this case is 2.

Using this equation we get the Richardson extrapolated results:

• at h=0  -> -0.029941
• at h=o  -> 0.2954332

The results are plotted here:

Calculate the Grid Convergence Index (GCI)

Grid convergence index is a standardized way to report grid convergence quality. It is calculated at refinement steps. Thus we will calculate a GCI for steps from grids 3 to 2, and from 2 to 1.

The equation to compute grid convergence index is:

where e is the error between the two grids and is an optional (but always recommended) safety factor.

Now we can calculate the grid convergence indices for the minimum pressure and maximum velocity.

Minimum pressure

Max velocity

Check that we are in the asymptotic range of convergence

It is also necessary to check that we are examing grid converegence within the asymptotic range of convergence. If we are not in the asymtotic range this means that we are not asymptotically approaching a converged answer and thus our solution is definitely not grid indipendent.

With three grids, this can be checked with the following relationship:

If we are in the asymptotic range then the left-hand side of the above equation should be approximately equal to 1.

In our example we get:

Minimum Pressure

Minimum Velocity

Applying Richardson extrapolation to a range of data

Alternatively to choosing a single value like minimum pressure or maximum velocity. Richardson extrapolation can be applied to a range of data. For example, we can use the equation for Richardson extrapolation to estimate the entire profile of pressure and velocity along the centerline at h=0.

This is shown here:

Conclusions and Additional References

In this post, we used the cavity tutorial from OpenFOAM to do a simple grid convergence study. We established an order of convergence, performed Richardson extrapolation, calculated grid convergence indices (GCI) and checked for the asymptotic range of convergence.

As I said before, the NASA resource is very helpful and covers a similar example:

• NASA – Examining Spatial (Grid) Convergence
  https://www.grc.nasa.gov/WWW/wind/valid/tutorial/spatconv.html

As well the papers by Roache are excellent reading for anybody doing numerical analysis in fluids:

• Roache, 1994:  “A method for uniform reporting of grid refinement studies”, Journal of Fluids Engineering
  https://www3.nd.edu/~coast/jjwteach/www/www/60130/CourseLectureNotes/Roache_1994.pdf
• Roache,  1997: “Quantification of uncertainty in computational fluid dynamics”, Annual Review Fluid Mechanics
  http://ftp.demec.ufpr.br/CFD/bibliografia/erros_numericos/Roache_1997.pdf

The Ahmed body is a geometric shape first proposed by Ahmed and Ramm in 1984. The shape provides a model to study geometric effects on the wakes of ground vehicles (like cars).

Image highlights:

In this post, I will use simpleFoam to simulate the Ahmed body at a Reynolds number of 10^6 using the k-omega SST turbulence model. The geometry was meshed using cfMesh which I will briefly discuss as well. Here is a breakdown of this post:

1. Geometry Definition
2. Meshing with cfMesh
3. Boundary Conditions
4. Results

The files for this case can be downloaded here:

Download Case Files

Note: I ran this case on my computer with 6 Intel – i7 (3.2 GHz) cores and 32 Gb of RAM. Throughout the simulation about 20-ish gigs of RAM were used.

Geometry Definition

STL Creation

The meshing utility cfMesh is similar to snappyHexMesh in that it depends on a geometry file of some type (.stl etc) to create the mesh. But it is different in that the entire domain must be part of the definition.

The ahmed body geometry can be found: http://www.cfd-online.com/Wiki/File:Ahmed.gif

For this simulation, I generated the geometry using SolidWorks. But this wasn’t for any particular reason other than that it was quick since I am familiar with it.

Preparation for Meshing

Once you have an STL file, you could go straight ahead to meshing it with cfMesh. However, some simple preparations to the STL geometry can improve the quality of the mesh created, and make setting up the case easier.

In particular, when you create the STL file in SolidWorks (or your 3D modeller of choice)  it contains no information about the boundaries and patches. As well, cfMesh works best if the geometry is defined using a .fms or .ftr file format.

Use surfaceFeatureEdge utility to extract edge information and create a .ftr file. Firstly let’s extract edge and face information from our STL file. We also define an angle. This angle tells cfMesh that any angle change large than this (in our case I chose 20 degrees) is a feature edge that must be matched.

surfaceFeatureEdge volume.stl volume.ftr -angle 20

After we run this, the new file volume.ftr contains a bunch of face and patch information. 13 surfaces with feature edges were extracted. The first 6 (volume_0 to volume_5) are the boundaries of the simulation (inlet, outlet, ground, front, back, and top).

mergeSurfacePatches volume.ftr ahmed -patchNames '(volume_6 volume_7 volume_8 volume_9 volume_10 volume_11 volume_12)'

After running this command, volume.ftr now contains 7 patches. We are now ready to move on to setting up cfMesh.

Meshing with cfMesh

Set up meshDict file in the system folder

Similar to snappyHexMesh and blockMesh, cfMesh using a dictionary file to control its parameters; meshDict. In this dictionary file we will be modifying a few parameters.

Tell cfMesh what file is to be meshed:

surfaceFile "volume_transformed.ftr";

Set the default grid size:

maxCellSize 0.2;

Set up refinement zones:

We want to set up two refinement zones; a larger one to capture most of the flow further away from the body (including the far wake), and a smaller more refined one to capture the near wake and the flow very close to the Ahmed body.

objectRefinements
{
 box1
 {
    cellSize 25e-3;
    type box;
    centre (2.4 0 6.5);
    lengthX 1;
    lengthY 1;
    lengthZ 3.5;
 }

box2
 {
    cellSize 5e-3;
    type box;
    centre (2.4 0 7);
    lengthX 0.5;
    lengthY 1;
    lengthZ 2;
 }

}

Set up boundaries to be renamed:

renameBoundary
{
 newPatchNames
 {
 volume_0
 {
 newName ground;
 type wall;
 }
 volume_1
 {
 newName back;
 type wall;
 }
 volume_2
 {
 newName inlet;
 type patch;
 }
 volume_3
 {
 newName front;
 type wall;
 }
 volume_4
 {
 newName outlet;
 type wall;
 }
 volume_5
 {
 newName top;
 type patch;
 }
 ahmed
 {
 newName ahmed;
 type wall;
 }
}

Set up boundary layering:

We require boundary layer on both the Ahmed body, as well as the volume_0 patch. Recall that the Ahmed body is surface mounted!

boundaryLayers
{
 patchBoundaryLayers
 {
 ahmed
 {
 nLayers 10;
 thicknessRatio 1.1;
 maxFirstLayerThickness 5e-3;
 }
 volume_0 
 {
 nLayers 10;
 thicknessRatio 1.05;
 maxFirstLayerThickness 10e-3;
 }

 }
}

Run cfMesh

We want to create a hex-dominant grid. This means that the 3D grid will consist primarily of hex cells. To achieve this we will use the cartesianMesh solver from cfMesh.

The results are shown below. The final mesh consisted of approximately 16.9 million cells. The majority of the cells were hexahedra (approximately 99%).

Boundary Conditions for the Solver

For this case, we are going to run a steady-state RANS simulation using the kwSST model and the solver simpleFOAM. This is simply to demonstrate the running of the solver.

The boundary conditions used are summarized in the following table:

As you can see I have used wall functions for the wall boundary conditions. This is due to the very small cell requirements that would be required to resolve the boundary layer on the ground, as well as on the Ahmed body which is at a Reynolds number of one million.

Simulation Results

The simulation took about a day and a half on 6 cores. Throughout the simulation, about 20 gb of RAM was used.

Cross-Section:

Streamlines and pressure on surface:

Vorticity surface in the near-wake

Conclusions

In this post, we meshed and simulated a surface-mounted Ahmed body at a Reynolds number of one million. We meshed it using the open-source meshing add-on cfMesh. We then solved it as a steady-state RANS simulation using the kwSST turbulence model, and the simpleFOAM solver.

The results gave some nice figures and a qualitatively correct result! And it was pretty fun. cfMesh was extremely easy to use and required much less user input than its OpenCFD counterpart snappyHexMesh.

Some references:

For more information on the Ahmed body:

http://www.cfd-online.com/Wiki/Ahmed_body

Some papers studying the Ahmed body:

-See the reference on the above CFD Online page!

As usual please comment and let me know what you think!

Cheers,

curiosityFluids

In this post I am going to simulate an oscillating cylinder in a cross-flow… just for fun… and to provide an additional tutorial case for those wishing to use some of the dynamic meshing features of OpenFOAM.

The case I am going to simulate is a cylinder in a Reynolds number 200 cross-flow (U=2 m/s, D=1 m, nu = 0.01 m^2/s), oscillating at a rate of 0.2 hz.

Tutorial Files

The tutorial files for this case can be downloaded from here:

Download Tutorial Files

Please let me know if the download does not work or if there is a problem running the tutorial files. Note: I ran this case in parallel on a relatively fast 6-core computer. It will take a long time if you try to run it as single core.

Mesh Generation

For this simulation, I built a simple two dimensional O-grid around the cylinder which joined to a series of blocks making a rectangular domain. I built this using the native OpenFOAM meshing utility blockMesh (which I like a lot).

If you are wondering about the blockMesh set up… I intend to a blockMesh tutorial post… not that it’s all that necessary since the OpenFOAM manual covers it pretty well.

Case Set-up

dynamicMeshDict

When running a dynamic mesh case a solver runs as part of the solution and solves for the new grid at each timestep. Several are available in OpenFOAM and I am not really trying to do a full post on that right now. So I’ll just tell you that in this case I decided to use the displacementLaplacian solver.

Along with the solver one must define the coefficients that go with the solver. For most of the solvers this means setting the diffusivity for the Laplace solver. Since I am relatively new to these types of solutions I did what we all do… and turned to the great CFD online forum! A discussion in this post (http://www.cfd-online.com/Forums/openfoam-meshing/97299-diffusivity-dynamicmeshdict.htm) made me think that a good starting point would be the inverseDistance model for the mesh diffusivity.

In the end my dynamicMeshDict (which belongs in the constant folder) looked like:

dynamicFvMesh dynamicMotionSolverFvMesh;

motionSolverLibs ( "libfvMotionSolvers.so" );

solver displacementLaplacian;


displacementLaplacianCoeffs
{
      diffusivity inverseDistance 1(cylinder);
}

The solver produces the grid movements through time as the simulation is performed. Here is what the mesh looks like while it is moving! I added the stationary mesh and the moving mesh. Click on them to get a clearer picture

Boundary Conditions

The set up for this case is simple. An inlet boundary (on the far left) where I specified the incoming velocity and pressure (both are uniform fixedValue). The top and bottom boundaries are slip boundaries (but could also be freestream depending on your preferred set-up style).

The cylinder itself requires some special treatment because of the moving mesh. It must obey the no-slip condition right? So do we set it as uniform (0 0 0) ? No! The cylinder is moving! Luckily there is a handy boundary condition for this in the U file:

 cylinder
 {
      type movingWallVelocity;
      value uniform (0 0 0);
 }

For a typical simulation using pimpleFoam a p and U file would be all that are required. However, since we are doing a moving mesh simulation there is another parameter that must be solved for and requires boundary conditions… pointDisplacement.

For the pointDisplacement boundary conditions, we know that all of the outer edges should NOT move. Therefore they are all fixed with a type of fixedValue and  a value of uniform (0 0 0).

The cylinder however is moving and requires a definition. In this simulation we are simulating and oscillating cylinder. Since we are using the displacement solver the type is oscillatingDisplacement. We input and omega (rad/s) and an amplitude (m) in the following way:

 cylinder
 {
 type oscillatingDisplacement;
 omega 1.256; 
 amplitude (0 0.5 0); // Max piston stroke
 value uniform (0 0 0);
 }

Results

Yay! Now its time to look at the results. Well since I am not doing this for any particular scientific study… let’s look at some pretty pictures!

Here is an animation of vorticity:

Looks pretty nice! I personally have a big nerd love for vortex shedding…. I don’t know why.

Obviously if you intend to do any scientific or engineering work with this type of problem you would need to think very carefully about the grid resolution, diffusivity model, Reynolds number, oscillation frequency  etc. All of these were arbitrarily selected here to facilitate the blog post and to provide a nice tutorial example!

Conclusion

In this post I briefly covered the set-up of this type of dynamic meshing problem. The main difference for running a dynamic mesh case is that you require a dynamic mesh solver (you must specify in the dynamicMeshDict), and you also require boundary conditions for that solver.

Let me know if there are any problems with this blog post or with the tutorial files provided.

• Built-in automatic grid generation
• Built-in 3D compressible Euler Solver for fast aerodynamics analysis.
• Built-in 3D laminar Navier-Stokes solver
• Built-in 3D Reynolds Averaged Navier-Stokes (RANS) solver
• Multi-core flow solver processing on your Windows laptop or desktop using OpenMP
• Inputs STL files for processing
• Built-in wing/hydrofoil geometry creation tool
• Enables stability derivative computation using quasi-steady rigid body rotation
• Up to 100 actuator disc (RANS solver only) for simulating jets and prop wash
• Reports the lift, drag and moment coefficients
• Reports the lift, drag and moment magnitudes
• Plots surface pressure, velocity, Mach number and temperatures
• Produces 2-d plots of Cp and other quantities along constant coordinates line along the structure

• Ability to handle complex geometries, and ease of mesh generation
• Robustness for a wide variety of flow problems
• Scalability on supercomputers

(a) hpMusic 3rd Order, 9.6M DOFs

(b) Commercial Solver, 2nd Order, 28.7M DOFs

Figure 1. Comparison of Q-criterion and Schlieren  

I certainly believe high-order solvers are ready for industrial LES. In fact, the commercial version of our high-order solver, hoMusic (pronounced hi-o-music), is announced by hoCFD LLC (disclaimer: I am the company founder). Give it a try for your problems, and you may be surprised. Academic and trial uses are completely free. Just visit hocfd.com to download the solver. A GUI has been developed to simplify problem setup. Your thoughts and comments are highly welcome.

Happy 2018!     

• Leicester won the Premier League in England defying odds of 5000 to 1
• Cubs won World Series after 108 years waiting

A Tank outside my taxi

A beautiful night in Zurich

The trip back to the US was complicated by the fact that the FAA banned all direct flight from Turkey. I was lucky enough to find a new flight, with a stop in Zurich...

In 2016, I lost a very good friend, and CFD pioneer, Professor Jaw-Yen Yang. He suffered a horrific injury from tennis in early 2015. Many of his friends and colleagues gathered in Taipei on December 3-5 2016 to remember him.

This is a CFD blog after all, and so it is important to show at least one CFD picture. In a validation simulation [1] with our high-order solver, hpMusic, we achieved remarkable agreement with experimental heat transfer for a high-pressure turbine configuration. Here is a flow picture.

Computational Schlieren and iso-surfaces of Q-criterion

To close, I wish all of you a very happy 2017!

1. Laskowski GM, Kopriva J, Michelassi V, Shankaran S, Paliath U, Bhaskaran R, Wang Q, Talnikar C, Wang ZJ, Jia F. Future directions of high fidelity CFD for aerothermal turbomachinery research, analysis and design, AIAA-2016-3322.

Additive manufacturing makes designing a lattice structure for a bracket possible. However, does it have a chance of success? Simulation can tell you.

Traditional prototype techniques take weeks and cost a considerable amount of a product development budget.

It’s true that additive manufacturing has reduced the time and cost to build prototypes. However, the near-instant simulation capabilities of ANSYS Discovery Live can speed up prototyping labs even more.

“Traditional simulation tools are hard to use, take a long time to produce results and are too expensive to be used on a regular basis,” says Tejas Rao, manager of ANSYS’ Discovery Live Technical Team.

“Discovery Live, however, offers instantaneous real-time simulation in an extremely easy-to-use multiphysics interface,” Rao adds. “It also includes integrated geometry manipulation. This means you can do simulation on your own in seconds.”

So how can Discovery Live help a prototyping lab?

Imagine your design team sends you five designs to print. Printing all five is a waste. Instead, import the designs into Discovery Live. In seconds, you can narrow down which designs are worthy of prototyping.

Tip: Test Lattice Structures in Simulation before Additive Manufacturing

Simulation of this lattice part gives engineers an idea how it will perform before printing and prototyping it.

Additive manufacturing makes it possible to drastically reduce a product’s weight by creating unique shapes and forms.

Optimizing these designs through lattice structures — and subsequent testing of their performance — is an important step that is often done by trial and error.

Assessing a lattice’s performance using traditional simulation takes a long time to set up and solve. Additionally, spending time printing models with lattice structures without having an idea of the design’s performance and likelihood of success could be a waste of time.

Alternatively, simulating a model containing a lattice using Discovery live will quickly give you an idea of how it will perform. “The goal here isn’t the highest accuracy possible,” says Rao. “The goal here is to understand the basic flow field.”

Understanding that flow field will help the prototyping lab assess the likelihood of success for a design before they print the prototype. They can then concentrate on printing the lattices they know have a chance of success.

Watch ANSYS Discovery Live for Additive Manufacturing Applications to learn more ways to accelerate your prototyping using simulation software and PNY’s NVIDIA graphics processing units (GPU).

The post Near-instant Simulations Speed Up Prototyping and Additive Manufacturing Labs appeared first on ANSYS.

HUD informs drivers of their speed, the speed limit, next turn and more — without forcing them to move their eyes off the road.

Any fan of Iron Man knows the power of an effective head-up display (HUD). But you don’t need to be fighting Thanos to benefit from a HUD.

In fact, HUDs can become a significant enabler of advanced driver assistance systems (ADAS) in the automotive industry.

An effective HUD can inform a driver without forcing them to move their eyes off the road. It can show:

• Car speed.
• The road’s speed limit.
• The next turn.
• Traffic.
• Lane suggestions.

For engineers, the challenge is to design a display that doesn’t force the driver to change focus. As a result, the information must remain legible under all road conditions. Simulation can help engineers design HUDs for any condition.

Simulation Optimizes a HUD’s Housing for a Crisp Image

HUDs can become large. The larger they are the more light can sneak in and affect the perceived quality of the image.

Engineers achieve an optimal projected distance for the display by mounting a considerably large device on the dashboard.

The problem is that the larger the device, the greater the unwanted light that manages to creep into the optics.

This unwanted light tends to scatter and cause light artifacts that render the HUD image fuzzy. This fuzzy image could affect the perceived quality of the HUD device.

To address this issue, HUD housings, glare shields and light traps are used to reject these stray beams of light. Optimizing these stray light rejection methods using trial-and-error would likely become too costly. ANSYS SPEOS software can be used to assess these traps and shields during early product development.

HUD housing comparison using classic black plastic (left) and ultrablack coating (right).

As an example, simulation results show that using a classic black plastic housing could still create a fuzzy HUD image.

However, simulation shows that using an ultrablack coating creates a much crisper image.

There are many other factors that can affect the image of a HUD. To learn more, read ANSYS SPEOS Capabilities: HUD and Analysis.

Or, watch the webinar Take the lead on the HUD revolution: windshield as a key optical during its Sept. 27, 10 a.m. (CEST) or 5 p.m. (CEST) timeslot.

The post Simulation Compares How HUD Housings Affect Image Quality appeared first on ANSYS.

Parameter studies in Discovery Live automates design point creation. The geometry and simulations are then automatically generated in real-time.

Real-time design analysis in ANSYS Discovery Live is now more automated. Previously, you needed to manually change each parameter to see a new simulation result.

When you had multiple parameters to adjust or were curious about all possible permutations, the process of manually iterating through the parameters could be time-prohibitive.

This is where Discovery Live’s parameter study feature comes into play. It allows you to rapidly explore numerous design possibilities by automatically cycling though geometric or simulation parameters.

Setting up a Parameter Study in Discovery Live

The parameter study’s interactive chart plots every design point in real time.

The new feature includes a menu that lets you decide which parameters to adjust and how you want to adjust them.

This menu lets you set each parameter’s:

• Minimum value.
• Maximum value.
• Step size between each iterated value.

You can then select a target output to study based on the changing parameters.

The software will then create a 3D representation of each iterated design, instantly solve the simulation for each iteration and plot the targeted output in an interactive chart. This allows you to determine which variables and values have the greatest effect on the desired outcome.

Interactive charts can quickly reveal trends in the data.

The interactive chart can also help you better understand the trade-offs between design goals and the input parameters.

For instance, say you are designing a heat sink. You will need to decide how to make a trade-off between costs and increasing the heat sink’s surface area and resultant material consumption.

Solving problems — like this heat sink example — requires data to adequately analyze all design variations.

Using parameter studies, you can gather that data to determine which variables have the greatest impact on your design goals. This information is critical to finding an optimal design.

To learn how to set up a parameter study in Discovery Live, attend the webinar: ANSYS 19.2: Discovery Live Update.

The post How to Automate Parameter Changes in ANSYS Discovery Live appeared first on ANSYS.

Engineers are under pressure to optimize designs during ever-shrinking development cycles. In response, computer-aided engineering (CAE) tools — like the latest enhancements in the ANSYS 19.2 release — now facilitate faster and easier-to-use workflows.

New ANSYS Fluent Task-based Workflow with Mosaic-enabled Meshing

A Mosaic mesh of an F1 wing connects hexahedral elements in the bulk and isotropic elements in the boundary, using polyhedral elements.

Engineers using ANSYS Fluent can now create more accurate computational fluid dynamics (CFD) simulations.

Fluent’s single-window, task-based workflow for watertight geometries dramatically reduces the time to set up and run CFD simulations.

This new workflow incorporates best practices to help prevent engineers from second-guessing themselves as they set up complex CFD models.

For instance, the workflow guides the engineer through the simulation process and best practices. It does this by reducing the engineer’s options to those that are relevant at each point in the process. Engineers will see only the turbulence models, meshing options and inputs that are relevant to the task at hand.

CFD engineers should also take note of new Mosaic meshing in ANSYS 19.2. This technology automatically combines any boundary layer mesh with high-quality polyhedral meshes for fast and accurate flow resolution.

In a benchmark study, the Mosaic mesh had fewer cells, required one-third the memory and delivered a solution two-times faster than a polyhedral mesh of similar accuracy.

ANSYS 19.2 Reduces Time to Market for Designers

A parameter study that is optimizing biker separation to reduce drag.

ANSYS Discovery Live has also seen a significant workflow improvement thanks to 19.2’s real-time parameter studies.

While Discovery Live has always been lightning fast with its simulations, all parameter changes were made manually. These manual parameter inputs slowed down development.

Now, design engineers can automate the exploration of their products’ design space using parameter studies. With this information, they can quickly assess the trends and trade-offs between design goals.

ANSYS 19.2 also advances the workflow for physics-aware meshing in ANSYS Discovery AIM. This improvement identifies high-stress concentrations faster than before.

Safety Assessment Workflows for Autonomous Vehicle Development

VREXPERIENCE gives engineers the ability to validate autonomous vehicles and ADAS features in a customizable virtual environment over millions of miles.

The release offers a series of tools and workflow improvements for to ensure the safety of advanced driver-assistance systems (ADAS) and autonomous vehicles.

For instance, the recent acquisition of OPTIS now brings ANSYS VRXPERIENCE into our portfolio.

With this tool, engineers can validate automotive safety features in a virtual world.

VREXPERIENCE offers engineers an expedient way to test safety features for autonomous vehicles over millions of virtual miles. These virtual drives can be customized to various roads, environments, weather, traffic and pedestrian conditions.

The release also introduces ANSYS SPEOS, a tool that will help engineers set up optical simulations. It empowers engineers to test the optical performance of LiDAR, lights and cameras within a system.

This means that engineers can use SPEOS and VREXPERIENCE to assess the optical sensors of their autonomous vehicles within a simulated world.

Workflow improvements to ANSYS medini analyze will also expediate the development of autonomous vehicles. These enhancements will help semiconductor companies ensure the safety of ADAS and autonomous systems to meet ISO 26262 Standards. These upgrades also streamline functional safety analyses, so semiconductor companies can get to market in half the time. Engineers using medini analyze will also be able to export a required safety analysis.

Exporting a safety analysis that is adapted to a system using medini analyze

ANSYS 19.2 also includes additions to the ANSYS SCADE Suite’s embedded software design workflows. These tools will make it faster to develop and verify safety-critical embedded code. This is key for any engineer designing a complete safety system for ADAS or autonomous vehicles.

In addition, the release streamlines SCADE’s connectivity to both Simulink and Jama software.

Workflow Upgrades for Multiphysics Simulations Increase Speed and Usability

Another speed boost is available for engineers working on two-way coupled simulations.

ANSYS 19.2 introduces System Coupling 2.0, which improves data mapping and co-simulations. These upgrades will better leverage the speed of high-performance computing (HPC).

The release also enhances text-driven workflows that control multiphysics simulations. This will make it easier for engineers to start and restart a simulation that assesses the interactions between a fluid and a structure.

Structural Workflows for Design Optimization

Turbine designed using inverse analysis

ANSYS 19.2 offers workflows to help optimize structural designs.

One example is the inverse analysis. This tool helps engineers determine the unloaded shape of a component so that, when loaded, they get the shape they expected.

Engineers can also take advantage of a new material design feature. This tool allows engineers to create detailed models of materials and calculate equivalent properties for larger-scale simulations.

Additive manufacturing (AM) experts will benefit from ANSYS 19.2’s new physics-driven lattice optimization function. Additional loading options and manufacturing constraints for topology optimization are also included in the release.

Faster Electronic Design Workflows

Finally, the release offers workflow enhancements to the electromagnetic suite. The suite now includes advancements to its multichannel radar system simulations. This upgrade comes in the form of a lightweight geometry modeler that hastens meshing and simulation processing.

Other electromagnetic improvements in 19.2 include:

• New capabilities in ANSYS Icepack to compute the thermal impact of multiple electromagnetic loss connections.
• A stackup wizard in ANSYS SIwave that allows for easy definition and exploration of printed circuit board (PCB) stackup layers and impedances.

To learn how to maximize your workflows, find out all that’s new in ANSYS 19.2.

The post ANSYS 19.2 Speeds Your Time to Market with New CAE Workflows appeared first on ANSYS.

Streamline simulations from ANSYS Fluent simulate the aerodynamic loads on composite wings.

Composite materials have a significant history with the aerospace industry due to their light weight and substantial strength.

However, you will still see a lot of metal wings flying around.

Metal wings have a limited service life — often as short as six to eight years — due to corrosion and fatigue.

And, during this period, the wings will require regular maintenance.

When the wing inevitably needs to be replaced, the cost can be so large that many airliners will scrap the whole vehicle.

Aero Composites aims to replace many of these metal wings with composite counterparts.

“The ANSYS Startup Program has helped us to design and optimize lightweight composite wings that increase payload capacity, while reducing weight and improving the overall stiffness of our aircraft,” says Dan Retief, chief engineer at Aero Composites. “Since composite parts do not suffer from corrosion, the aircraft will also requires less maintenance.

“After just 12 months in the ANSYS Startup Program, we can deliver an increase of 14 percent in payload capacity in our designs — by weight reduction — compared with all-metal aircraft,” adds Retief. “In the future, we expect to be able to deliver an increase of up to 36 percent.”

How Aero Composites Optimized Its Aircraft Designs

Composite PrepPost shows the fiber direction (green arrows) on a rib flange.

Aero Composites’ workflow starts in Creo Parametric 3D modeling software.

The geometry is then brought into ANSYS Workbench — via Discovery SpaceClaim to check for part connectivity.

Aero Composites defines all the laminate details of the composites using ANSYS Mechanical and Composite PrepPost.

Next, Aero Composites uses ANSYS Fluent to calculate the pressure distributions. They also apply these loads to static structural simulation within Mechanical.

Finally, Aero Composites uses Workbench to set up a parametric study to assess different load cases, speeds, angles of attack and environmental conditions.

“Simulations have delivered many significant insights – especially in furthering our understanding of out-of-plane loads,” says Retief. “They helped us avoid delamination and increase the service life of key components.”

Simulations Help Aero Composites Certify their Aerospace Designs

Simulations have proven Aero Composites designs can increase payload capacity by 14 percent.

“If we were only conducting physical tests, the cost of failure to our small startup business would be enormous,” says Retief.

Currently, Aero Composites is using its simulations to achieve certification with the Civil Aviation Authority.

These simulations will support the company’s required due diligence for proving that its designs can handle all the required load cases before moved onto physical tests.

“After correlating our simulations to this physical data, we can then certify new designs based almost entirely on simulation,” explains Retief. “With a qualified simulation model, it becomes possible to make modifications to our certified designs and certify those changes using simulations alone.”

As each physical test could cost upward of $200K, simulation will save Aero Composites a lot of money.

To learn about how simulation can save your startup costs on physical testing, check out the ANSYS Startup Program.

The post Simulations Prove Composites Can Increase an Aircraft’s Payloads and Service Life appeared first on ANSYS.

A class within Western New England University is learning how to use simulation software.

Engineering colleges need to get on the simulation bandwagon.

Simulation is a necessity for the automotive, aerospace, consumer goods, electronics, industrial and even health care industries.

So, why do so many engineering colleges not teach the basics of finite element analysis (FEA) or computational fluid dynamics (CFD) software?

I cannot stress enough the importance of learning and understanding simulation tools based on my experience as a recent mechanical engineering grad.

When facing the industrial job market, I can use the simulation skills I picked up from ANSYS to stand out among thousands of applicants. I hope engineering colleges understand the importance of bringing simulation into the curriculum. Students need to generate an industry ready talent for these tools.

How Students Can Learn Simulation in an Engineering College

Deformation of a wall mounting bracket.

It doesn’t take much to get engineering college students interested in simulation.

Perhaps an exercise as simple as calculating the deformation of a wall mounting bracket by hand and then again through simulation?

Once these students see the power and speed of simulation it could pique their interest.

This can only be done when professors take the time within their lectures to seed the idea that simulation can solve problems. This could trigger students to probe into the meaning of those colorful pictures — it can help them explore simulation resources and work on it as a new skill.

From here, the engineering student just needs to choose a simulation software. I chose ANSYS. ANSYS gave me — and any other students — the ability to:

• Access any ANSYS Student product as a free download.
• Learn how to use those products form hands-on tutorials, webinars and case studies.
• Look up detailed information within the help of documentation or technical support.
• Talk to peers in the ANSYS student community forum.

Effectively, students have access to similar or equivalent resources to those they’d be introduced to on the job. However, instead of learning these lessons during a three-month employment probation, they are learning it in the safety of their engineering college.

ANSYS played a vital part in educating me about the simulation industry and shifted my focus toward FEA and CFD. I suggest students start with a self-paced online course like A Hands-on Introduction to Engineering Simulations. It is sponsored by ANSYS and taught by Dr. Rajesh Bhaskaran from Cornell University.

How Simulation Gives Engineering College Students a Leg-up in Industry

The simulation tools I used improved my studies, capstone projects and early career.

For example, while enrolled in an engineering college, I helped an athletic firm improve the strength and durability of a patented lacrosse stick. I then worked with FloDesign Sonics to develop ultrasonic cell therapy devices to concentrate, wash and separate distinct types of cells.

Generally speaking, most engineering  capstone projects can benefit from insight of simulation in the verification and validation stages. Familiarity with simulation can help engineering college students gain an edge over their peers because they’ll have a mathematical and visual understanding of simulation. This understanding can add value to their project and curriculum vitae (CV).

Any academics or students at an engineering college looking to follow my lead should access ANSYS’ Free Student Software Downloads.

The post Engineering Colleges Need Simulation in the Classroom appeared first on ANSYS.

As a general purpose CFD solver, CONVERGE is robust out of the box. Autonomous meshing technology built into the solver eliminates the meshing bottleneck that has traditionally bogged down CFD workflows. Despite this advantage, however, performing computational fluid dynamics analyses is still a complex task. Challenges in pre-processing and post-processing can slow your workflow. To streamline the simulation process, CONVERGE CFD software includes a wide array of tools, utilities, and documentation as well as support from highly trained engineers with every license.

Pre-Processing

• Although you do not have to create a volume mesh, your surface geometry must be watertight and meet several quality standards related to triangulation and normal vector orientation. CONVERGE Studio includes several native surface repair tools to quickly detect, show, and resolve these issues. With an additional license for the Polygonica toolkit, you can leverage powerful surface repair capabilities from within CONVERGE Studio.
• For engine simulations, a popular acceleration technique is to use a sector (an axisymmetric geometry representing a portion of the model) instead of the full geometry. In CONVERGE, the make_surface utility allows you to quickly create a properly prepared sector geometry based on the piston bowl profile and just a few more geometry inputs. CONVERGE Studio includes a graphical version of this tool.
• With any CFD software, the multitude of input parameters to control the complex physical models can be overwhelming. In CONVERGE CFD, we provide several checks to help you validate your case setup configuration before beginning a simulation. In CONVERGE, run the check_inputs utility to write information about missing or improperly configured parameters to the terminal. In CONVERGE Studio, you can use the Validate buttons throughout the application to validate input parameters incrementally as you configure the case. Additionally, the Final Validation tool examines the geometry and case setup parameters and provides suggestions for anything that may need to be revised.
• A staple of the CONVERGE feature set is the ease with which you can simulate complex moving geometries. One requirement is that boundaries cannot intersect during the simulation. There are several ways to verify that your setup meets this requirement. Running CONVERGE in no hydrodynamic solver mode does not solve the spray, combustion, and transport equations. Instead, this type of simulation checks surface motion and grid creation. In CONVERGE Studio, use the Animation tab of the View Options dock to preview boundary motion and check for triangle intersections at each step of the motion. 
• Many complex engine, pump, compressor, and other machinery simulations employ the sealing feature to prevent flow between regions at various times during a simulation. To test your seal setup, run the CONVERGE sealing test utility by supplying the check-sealing argument after your CONVERGE executable. This command uses a simplified test with only a single level of cells and most options (including AMR, embedding, sources, mapping, events, etc.) automatically turned off.
• Full multi-cylinder simulations provide accurate predictions for fluid-solid heat transfer, intake and exhaust flow, and other important engine design parameters. Setting up the multiple cylinder geometries and timing can be a frustrating exercise in bookkeeping. The Multi-cylinder wizard in CONVERGE Studio makes this process painless. The wizard is a step-by-step tool that guides you through the process of configuring cylinder phase lag, copying geometry components for additional cylinders, and setting up timing of events such as spark ignition. After your configuration is complete, the wizard provides a quick reference sheet that catalogs the salient details for each cylinder. 
• Because surface triangles cannot intersect during a CONVERGE simulation, valves (e.g., intake and exhaust valves in an IC engine) must be set to a minimum lift value very close to the valve seats but not technically closed. CONVERGE Studio includes a tool to automatically and quickly move the valves to this position based on profiles of intake and exhaust valve motion.
• In compressor simulations, the working fluid is often far from an ideal gas. In addition to multiple equation of state models in CONVERGE, you can directly supply custom fluid properties for the working fluid. CONVERGE reads properties such as viscosity, conductivity, and compressibility as a function of temperature from supplied tabular data, obviating the need to link CONVERGE with a third-party properties library.
• As CONVERGE is a very robust tool, you can use it for many different types of simulations: compressible or incompressible flow, multiphase flow, transient or steady-state, moving geometry, non-Newtonian fluids, and much more. Each of these regimes and scenarios requires you to configure relevant parameters. CONVERGE Studio includes a full suite of example cases across a range of these regimes including IC engines, compressors, gas turbines, and more. It is as simple as clicking File > Load Example Case to open an example case with Convergent Science-recommended default parameters for the given simulation type. You can use the example cases as starting points for your own simulations or run them as-is while you learn to use CONVERGE. 

Post-Processing

• The geometry triangulation for a CONVERGE simulation may differ from that for a finite element analysis (FEA) simulation because the FEA geometry may have higher resolution in areas most relevant to the heat transfer analysis. CONVERGE includes an HTC mapper utility that maps near-wall heat transfer data from the CONVERGE simulation output to the triangulation of the FEA surface. That way, you can iterate between the two simulation approaches to understand and optimize designs.
• CONVERGE Studio includes a powerful Line Plotting module to create two-dimensional plots. In addition to providing a high level of plot customization, the module is designed to plot some of the two-dimensional *.out files unique to CONVERGE. Also, you can use the Line Plotting module to monitor simulation properties such as mass flow rate convergence in a steady-state simulation. 
• One of the post-processing tools available in CONVERGE Studio is the Engine performance calculator. This tool automatically calculates engine work and other relevant engine design parameters for 360 degree or 720 degree ranges from CONVERGE output and the engine parameters in your case setup. The results are collated in a table so that you can easily export them to a spreadsheet.

Documentation

• Several case setup tutorial video series on the Convergent Science YouTube channel provide step-by-step walkthroughs of full case setups. Refer to these for information on surface preparation, case setup, simulation, and post-processing of some basic CONVERGE example cases.
• On our CFD Online support forum, you can interact with other CONVERGE CFD users and our knowledgeable and approachable support team for assistance.

Performing CFD analyses can be difficult due to the number of unknowns, uncertainty of boundary conditions, and complexity of flows. CONVERGE CFD helps you by removing the necessity of meshing and giving you auxiliary tools to simplify your workflow.

In the last five years, “machine learning” has become a veritable buzzword. From applications as diverse as traffic forecasting and the virtual assistant on your smartphone to genome sequencing, researchers employ machine learning across a broad array of fields to improve predictions based on big datasets.

Beyond adding convenience to everyday life, machine learning can contribute to technology development as well. In a recent collaboration between Argonne National Laboratory, Aramco, and Convergent Science, Moiz et al. applied machine learning techniques to automotive engine research, enhancing computational fluid dynamics (CFD) studies performed in CONVERGE CFD [1]. Machine learning leverages existing datasets to optimize and predict new designs that have improved performance, higher efficiency, and reduced emissions. In light of market competition and increasingly strict emissions requirements, the union of machine learning and engine CFD is a promising development.

Machine Learning Overview

At a very basic level, machine learning means leveraging data to make accurate predictions. An example of this that we encounter every day is targeted advertising. Marketers use machine learning to take information about our demographics and interests and provide relevant product recommendations. More often than not, these recommendations are startlingly accurate.

The first step in developing a machine learning model is for scientists to collect large datasets. Next, the machine learning model applies computational statistics to the data, detecting relationships between inputs and outputs. This process is known as training the model. To evaluate the accuracy of the model, scientists often supply to the model a test dataset that was not included in the training dataset and examine the accuracy of the predictions. The more accurate the algorithm, the lower the risk of inaccurate predictions. Many machine learning algorithms exist (decision tree, support vector machines, neural networks, etc.), some of which have been in development for decades.

CFD Applications

A popular optimization technique for engine designers is the genetic algorithm (GA). CONVERGE includes such a tool, CONGO, which takes a “survival of the fittest approach” to optimize a design. That is, the method pits individuals (designs) against each other in a population with a set of user-defined parameters that vary. Each individual includes characteristics of the various parameters to optimize, such as combustion phasing, combustion shape design, etc. The goal of a GA study is to optimize a result such as indicated specific fuel consumption, while staying within certain constraints such as emissions or peak cylinder pressure.

By definition, a genetic algorithm study needs to run for many successive generations. One of the primary drawbacks of this technique is that the generations can run for a long time, sometimes in the range of months. This is because most engine CFD simulations require between a day and a week for individual results. Engine researchers often require a faster solution than a GA optimization of CFD. To address this, Moiz et al. combined machine learning with genetic algorithm optimization to quickly develop gasoline compression ignition (GCI) engine designs. The engine analyzed in the work uses a low-octane gasoline fuel in partially premixed compression ignition.

First, scientists ran a large (2048 individual CONVERGE simulations) space-filling design of experiments (DoE) to create a training data set. Since the DoE can be defined all at once, the simulations ran concurrently. With the advent of large HPC clusters like the Mira supercomputer at Argonne National Laboratory, the entire DoE of CFD simulations ran in a few days. The authors also investigated using smaller subsets of the training dataset to see if a less expensive DoE would be sufficient. They found that the learning curves were promising down to a DoE with sample size of 300.

An emerging combustion technology like GCI has ample room for optimization to maximize efficiency and minimize emissions, and computational studies are ideal for this task. In the current work, the authors employed a machine learning genetic algorithm approach to reduce the design cycle for optimizing a GCI engine and overcoming the above-mentioned obstacles. The general procedure is as follows:

1. Ran over two thousand high-fidelity CFD simulations in CONVERGE to create a large dataset on which to train the machine learning model,
2. Trained and tested the machine learning model on the CFD data,
3. Used the machine learning algorithm as an emulator of the design space for optimization to optimize the engine designs.

The machine learning (ML) GA procedure poses a speed advantage over a traditional GA optimization. First, engineers can run the initial CFD simulations in parallel, generating seed data very quickly. Second, the ML GA emulator can evaluate an individual design in a few seconds in comparison with a high-fidelity CFD simulation, which can take around 12 hours on 128 processors.

In a GA optimization with CFD results as the objective function, sequentially running the CFD simulations is a bottleneck in the process. The ML GA approach, however, reduces the time significantly, allowing a full optimization in approximately a day. An additional benefit of this technique is that engineers can use the initial space-filling DoE datasets for future design space interrogation or uncertainty analyses.

Machine learning is a powerful tool which is now becoming ubiquitous in software applications. It is only natural that, when combined with CFD, ML GA methods help designers more rapidly optimize engine efficiency and performance.

References

[1] Moiz, A., Pal, P., Probst, D., Pei, Y., Zhang, Y., Som, S., and Kodavasal, J., “A Machine Learning-Genetic Algorithm (ML-GA) Approach for Rapid Optimization Using High-Performance Computing,” SAE Paper 2018-01-0190, 2018. DOI:10.4271/2018-01-0190

Computational fluid dynamics tools such as CONVERGE CFD offer the ability to analyze and optimize compressors without the difficulty and expense (both time and money) of generating and testing physical prototypes.

With CONVERGE, several core technologies make your compressor simulation workflow easier, faster, and more accurate.

AMR Strategy

A staple of the robust feature set in CONVERGE is Adaptive Mesh Refinement (AMR). This feature refines and coarsens the mesh on the fly in response to criteria you specify before starting the simulation. AMR helps maintain resolution in the tight gaps between the moving parts in a compressor. In this way, you can trust CONVERGE to automatically capture relevant flow features.

For compressor simulations, AMR is particularly applicable for resolving flow structures around valves. As there are tight clearances in these small gaps, CONVERGE increases mesh resolution automatically in response to large gradients in velocity, temperature, and other quantities of interest.

Additionally, you can modify the sub-grid scale (SGS) parameter for fine-grain control of the AMR algorithm sensitivity. As shown in the video below, AMR allows you to accurately resolve the jets of fluid traveling through the valve in a reciprocating compressor.

A grid convergence study further demonstrates the advantages of AMR. In this study, we successively refine the grid until quantities of interest reach a converged value (in this example, and as shown in Figures 1 and 2 below, for discharge valve lift and cylinder pressure). One way to perform a grid convergence study is to reduce the size of the base grid (and thus increase the cell count) for successive runs. A better option is to modify the AMR embedding scale and CONVERGE will create finer grids in the vicinity of high gradients, reaching a converged solution faster and with fewer total cells. Table 1 below compares cell count and wall clock time for the base grid and AMR grid refinement studies shown in Figures 1 and 2. Both the finest base grid and the finest AMR level result in a converged solution, but the simulation with AMR takes less time and uses fewer total cells than the simulation with the finest base grid.

Figures 1 and 2: Discharge valve lift and cylinder pressure compared between refined base grid and increased AMR embed scale

Reed Valve Deformation (FSI)

To further increase the accuracy of compressor calculations, CONVERGE includes fluid-structure interaction (FSI) modeling. This capability allows you to model the interactions between the bulk flow and reed valves (e.g., in reciprocating compressors). This way, you can accurately resolve the physical behavior within the compressor machinery to predict failure points.

The reciprocating compressor shown in the video above employs the 1D clamped beam model in CONVERGE to predict the fluid-structure interaction. Notice how the valve deforms realistically in response to the flow through the valve.

Custom Fluid Properties

In many cases, the working fluid within compressor machinery is far from an ideal gas. In CONVERGE, you can select from several different equation of state models to accurately represent the physical properties of your working fluid. Beyond the ideal gas law, CONVERGE includes cubic models such as Redlich-Kwong and Peng-Robinson to suit your application.

Also, you can directly supply custom fluid properties for the working fluid. Instead of linking CONVERGE with a third-party properties library, you can provide tabular data files that contain the fluid properties. These custom properties include viscosity, conductivity, compressibility, and more as a function of temperature.

For many applications, such as with air as the working fluid, the ideal gas law is an appropriate choice for the equation of state (as shown in Figures 3 – 6 below).

Figures 3 to 6: Examples in which the ideal gas law works well for air

Figures 7 – 10 below compare various fluid properties of supercritical CO2 calculated via several different methods. In these examples, the tabular fluid properties match very closely with NIST data. The Peng-Robinson equation of state model provides the next-best match.

Figures 7 to 10: Comparisons of various EOS and tabular data to NIST data

CONVERGE offers several technologies that address the difficulties of compressor CFD while making your workflow easier and more accurate. Want to learn more about integrating CONVERGE into into your simulation workflow? Get in touch with us here.

You may have seen the press release: starting May 31, a version of the Tecplot 360 flow visualization software will be packaged with CONVERGE. No corporate details here–this is an engineer’s viewpoint. I am a longtime Tecplot user, having worked extensively with nearly every version since 2008 R1. I’m not a trainer, so I won’t try to teach you how to use Tecplot (if you’d like to see a CONVERGE-focused introduction to Tecplot 360, Tecplot Product Manager Scott Fowler gave a webinar earlier this year). Rather, I’ll tell you what I like about it as a CFD research engineer, and what you might like too. The brief version: Tecplot for CONVERGE is a user-friendly tool that works well and makes sense.

To me, the most important characteristic of any tool is usability. If I can’t figure out how to make it work, it’s of no use to me. My introduction to Tecplot involved no formal training and no user guide (although I’m sure there was one available). I was working off of nothing except for my fellow graduate students and a willingness to experiment. It turned out that this was enough!

Tecplot’s user interface is approachable and unintimidating. The workflow is logical and smooth. Some software packages give the impression that they were designed by a GUI team with no engineering knowledge; some packages look like they were written by engineers with no clue about interface design. Tecplot bridges that gap. The answer to “How do I…” is usually logical and straightforward, and Tecplot feels like it was designed from the ground up by a team that had extensive experience with CFD.

Let me give you an example. Suppose I’m loading a complex 3D flowfield. When I first load that dataset, I don’t know exactly how I want to visualize it. I will probably pan, zoom, and rotate through a wide variety of views, trying to figure out the best perspective from which to visualize my flow. As with many packages, in Tecplot I can do this with just the mouse, without resorting to menu buttons to change modes. The difference is, once I find a view I like, Tecplot gives me precise control over the camera location and direction. If I alter the view and don’t like the change, I can revert the view setup. If I want to compare several different datasets, I don’t have to fiddle around with the mouse controls to get approximately the perspective I want. I can copy the center of rotation and spherical angles and get precisely the right view, with a minimum of fuss. As my understanding of my dataset grows from general familiarity to exacting detail, Tecplot offers me increasingly exacting controls.

I like Tecplot’s approach to data and file structuring. In my workflow, all data at a certain simulation time is written to a single <casename>_<filenumber>_<time>.plt file. Because of this one-to-one relationship, I can see at a glance how many datasets I have available for my case (rather than having different files for different variables). When I load my .plt file, data are structured by zone. Each zone might have different variables (e.g., a fluid zone versus a parcel zone), and I can display them differently. I can extract sub-zones (e.g., a slice from a fluid zone) and display those separately. If I loaded multiple data files, I can animate zones over time. If I write out a new .plt file, I can write specific zones to that file. This is especially helpful for, say, preserving interesting cross-sections of a very large volumetric dataset.

Importantly, Tecplot for CONVERGE retains nearly the entire feature set of a stand-alone Tecplot 360 installation. It is not limited in cell count, processor count, plot details, data alteration, or most other functional details. The chief restriction is in file formatting. Tecplot for CONVERGE is limited to output files that have been converted using a new post_convert executable. This post_convert will be released with Tecplot for CONVERGE and will be included with all future CONVERGE Studio and CONVERGE solver packages. Make sure to select the “Tecplot for CONVERGE or Tecplot 360” option in post_convert when converting output files. If you opt to purchase a full Tecplot 360 license, of course it is able to read these specially formatted files.

Tecplot offers powerful data alteration and calculation tools, as well as a robust scripting capability. Once you tell Tecplot which variable names correspond to which state variables, Tecplot can calculate on demand many derived quantities commonly used in CFD. No more trying to remember the functional form of the Q-criterion, because it’s built in. If the quantity you need is not included in this hundred-odd set, you can directly specify whatever calculation you wish to perform. Further, all of this can be scripted in a macro. You can record macros through the GUI (which journals all of the actions you’ve performed) and play them back, or you can write a plaintext macro directly.

Finally, Tecplot makes attractive images and animations! Much like the viewport commands, Tecplot adopts sensible defaults but gives you exacting control when you want it. I can add, adjust, and remove control points on the contour plot color map, banded or continuous, and drop in contour lines at specific values. I can plot spray parcels by various shapes and in various colors and sizes (including by spray variable values). Tecplot’s flexibility allows me to make a plot in twenty seconds that looks pretty good, spend twenty minutes making it look exactly right, or anywhere in between.

I love Tecplot, and I am very happy that Convergent Science is partnering with the Tecplot team. Not every engineer prefers the same tool, of course. CONVERGE will continue to support a wide range of flow visualization and analysis packages through the post_convert utility. But no matter your present visualization tool of choice, I encourage you to take Tecplot for CONVERGE out for a spin. I think you’ll like what you see.

A lot of things happened in 2008. There was a financial crisis. China hosted the Olympics. Barack Obama won the US presidency. Sarah Palin could even see Russia from her house! But something else was brewing in the Midwestern college town of Madison, Wisconsin. In 2008, Keith Richards, Eric Pomraning, and I realized that we had written a CFD code that could change the simulation world. Not only that, but it was finally ready to be shared with the public. We had spent the last seven years developing this software and now had to figure out how to market it, sell it, support it, and document it, all while running a business. A business that had focused on consulting services since its inception in 1997. How were we going to pull this off? Especially at a time when our biggest client base, the US automotive industry, was facing its own crisis, including bankruptcies and government bailouts. I’ll come back to that in a minute, but first, a bit more history on the CFD code that turns ten this year.

Many of you know that CONVERGE started out as MOSES (named by David Schmidt, one of the original founders of our company). But did you know that this stood for Modular Open Source Engine Simulation? That’s right, open source. CONVERGE was originally written with the intent of replacing KIVA, the software that we (and many others) had used in our graduate studies. We accomplished a lot with KIVA, and it taught us a lot about reacting flow CFD. However, there was one big problem with it and, frankly, all CFD codes at the time: the mesh. The mesh quality was often low and the resolution coarse, both of which significantly degraded the accuracy of CFD simulations. Moreover, for anything but a simple, stationary geometry, mesh creation was incredibly painful. In fact, much of the consulting we did in the early years was based around KIVA mesh generation. Keith had written a tool called G-Smooth, which allowed us to make full, complicated engine meshes for KIVA faster than anyone else—in one week. Are you kidding? An entire week of engineering time to make a mesh was considered fast? We knew something needed to change.

In 2001 we sent the US government a proposal called The MOSES Project: A Modular, Open Source Engine Simulation Code for Parallel Computation of Complex Geometries. Their response was something along the lines of “this sounds like a great idea; please come back when industry is interested.” In their defense, this was unsolicited, they weren’t asking for MOSES, and “never make a mesh again” probably sounded pretty far-fetched to the reviewers. This was the first of many times when it would have been easy to throw in the towel.

Instead, we went to industry, specifically to a large engine manufacturer (Engine Maker X). It wasn’t easy to convince them, but they too were frustrated with the time required for making meshes as well as the accuracy implications of using a poor quality mesh. A few key people at Engine Maker X believed in us enough to secure funding to help with early development. So in late 2001 we went to work—Keith and Eric developed the core solver while I kept up the consulting side of things to keep the lights on. A couple of years later, I joined them full-time on code development and started implementing the spray and combustion models. I’ll never forget the month of April 2004. The first version of MOSES was due on May 1, and like any good researchers, we pulled an all-nighter—that lasted the whole month! This month-long all-nighter was required because we’d scrapped our original approach when we realized that an immersed boundary method wasn’t going to work for our purposes. Yet another time when throwing in the towel would have been easy, but I’m so glad we didn’t.

Fast forward to 2008 and a lot of changes were about to drop. Our company, Convergent Thinking, LLC changed its name to Convergent Science, Inc. We also changed the name of our software from MOSES to CONVERGE (fun fact: believe it or not, we discovered there was another CFD code called MOSES!). We were entering the automotive CFD market at one of the worst times in history for that industry. But we quickly learned that the financial crisis was motivating companies to make changes. Companies needed to tighten their belts and find the most efficient and accurate simulation tools possible—enter CONVERGE.

Sales of CONVERGE unofficially started where else but at the SAE World Congress in 2008. Daniel Lee, who was one of the original founders of our company, had left to pursue a career at Fluent (and later ANSYS) after graduating from UW-Madison in 1998. Ten years later, he had honed his CFD sales chops and was ready to come back to Convergent Science. Good timing, as Eric, Keith, and I had no experience selling software. So the four of us met at SAE, ready to take on the big players in the engine industry. No booth, no brochures, just Dan’s little sales notebook and phrases like “imagine a car without gas” (trying to make an analogy with “imagine a CFD code where the user doesn’t have to make a mesh”). These days gasless cars are a little easier to imagine, but our analogy sounded good at the time!

Selling any software is difficult, but selling CFD software can be next to impossible when you’re dealing with companies that have an established workflow and years of experience with a legacy code. We heard a lot of “no” before hearing “yes.” We were told many times early on that we were, hands down, the best CFD code, but there was concern that our company was too small. Eventually, though, we convinced automotive engineers, and later engineers from a host of other industries, that we were (and still are!) a company dedicated to continued innovation and superlative customer service.

We’re also experts in our application fields. There really is something to all of the firsts that we’ve introduced to the community (autonomous meshing, direct detailed chemistry for combustion, grid-convergent Lagrangian spray modeling, cyclic variability with URANS, etc.), many of which were originally quite controversial. I like to tell students that if they’re not working on something at least somewhat disruptive in their research, it’s probably not that novel. Boy were we controversial with CONVERGE—many of the entrenched CFD best practices were based on software and hardware limitations rather than fundamental scientific concepts, and we challenged these practices with new ideas based on first principles. These innovations have no doubt succeeded in helping move the needle from postdiction to prediction over the last ten years, and these innovations have helped propel CONVERGE’s continued growth.

In 2018, ten years after we started selling CONVERGE, we have around 100 team members in our offices across the globe. Approximately 95% of engine makers in the US use CONVERGE, and around 85% of engine makers worldwide use CONVERGE. We’re taking our predictive CFD approach to new markets, and we’re once again changing the game with CONVERGE 3.0, which will be released later this year. CONVERGE has taken on a life of its own, with a large user community that includes engineers in industry, national labs, and universities. We have annual user conferences in both the US and in Europe (don’t miss our US event in Madison in September, celebrating CONVERGE’s ten-year anniversary!). Indeed, the quotation from Robert Fritz that I added to CONVERGE’s main.c subroutine many years ago has, in fact, come true: “At first, I am giving energy to the creation, but later the creation seems to be giving energy to me.” Happy tenth birthday, CONVERGE, may you continue to empower CFD users to never make a mesh again for years to come.

In 2017 Convergent Science saw tremendous growth and success in many areas. We now have nearly 100 employees (almost double the 2014 headcount), new clients are using CONVERGE CFD to investigate pumps and compressors, and our customer base using CONVERGE for aftertreatment and gas turbine design continues to grow. We’ve done all this while also increasing our majority share of the global internal combustion (IC) engine simulation market.

Our dedication to accurate and grid-convergent simulations ensures that CONVERGE offers cutting-edge CFD solutions for a wide variety of complex flow problems. Our teams dedicated to IC engines, gas turbines and aftertreatment, and new applications such as compressors and pumps ensure that CONVERGE can meet the unique challenges of each industry.

Continued Authority at SAE, DOE Merit Review, and ASME ICEF

The Society of Automotive Engineers World Congress Experience (SAE WCX17) once again reinforced the prevalence of CONVERGE in innovative IC engine design. In April, more than 35 papers demonstrated results achieved with CONVERGE, including publications from Aramco Research Center, Argonne National Laboratory, GE Global Research Center, Groupe Renault, IFP Energies nouvelles, King Abdullah University of Science and Technology, Oak Ridge National Laboratory, and University of Perugia.

In June, CONVERGE’s utility for innovative, energy-saving research was affirmed at the annual DOE Merit Review. Seventeen programs reviewed by the U.S. Department of Energy referenced partnerships with Convergent Science and work with CONVERGE. Topics ranged from clean combustion in light-duty engines to knock prediction to soot modeling with gas kinetics and surface chemistry.

Seattle played host to this year’s ASME Internal Combustion Engine Fall Technical Conference (ICEF 2017), where 25 papers featured results from CONVERGE. Topics of CONVERGE papers at ICEF included pressure oscillations in numerical simulations of IC engines, gasoline compression ignition calibration, selective catalytic reduction of NOX with detailed surface chemistry, and cycle-to-cycle variation prediction with LES turbulence modeling. Many of our most influential collaborators, including Argonne National Laboratory, GE Global Research Center, and Oak Ridge National Laboratory, presented their topics at this engaging conference in October. Two of Convergent Science’s most experienced support engineers, Shawn Givler and Sameera Wijeyakulasuriya, gave a popular workshop at ICEF that introduced engineers, students, and experimentalists to some of CONVERGE’s powerful tools for modeling heavy-duty engines.

Gas Turbine Relight with GE and Honeywell

Engineers from both GE Aviation and Honeywell Aerospace were interested in CONVERGE’s ability to predict high altitude ignition and relight in gas turbines. This phenomenon has been notoriously difficult to simulate due to the long meshing times associated with complex geometries and the need for accurate, detailed combustion modeling. But Scott Drennan’s Gas Turbine team was up to the task.

GE Aviation engineers gave Scott’s team a diverse range of operation conditions, and Scott’s team proved that CONVERGE can indeed accurately predict relight (or a failure to relight) across the varying conditions. GE Aviation engineers are now testing CONVERGE on fundamental and practical combustor designs for further validation, development of best practices, and optimization.

Honeywell Aerospace successfully used CONVERGE to model relight in their five-sector combustor geometry, and they noted that CONVERGE’s autonomous meshing capabilities help make CFD a viable option to assess all facets of gas turbine design.

CONVERGE-ing in Europe

We hosted our first European user conference in Vienna in early March. This inaugural European CONVERGE experience was a big hit with European clients as well as super-users from the United States who traveled to Vienna to share and learn with their counterparts across the pond. Networking sessions included a tour of a castle and a traditional evening at a Viennese tavern. Attendees from many institutions—including GE, Groupe PSA, IFP Energies nouvelles, Politecnico di Torino, Renault, University of Rome Tor Vergara, and Volvo Cars—helped make this inaugural event a memorable one.

Motor City Hosts Fourth Annual U.S. User Conference

Since so many automotive OEMs are based in Detroit, the Motor City was the perfect location for our fourth annual North American user conference. Two hundred fifteen people registered for this conference, making it the largest CONVERGE conference to date. Users from 42 companies, 19 universities, and six national laboratories experienced two days of informative presentations. Many also participated in some of the introductory and advanced CONVERGE training sessions that were offered. Social events included a Ford Rouge Factory Tour and a dinner social at The Dearborn Inn.

IDAJ’s Continued Success in Asia

IDAJ, our distributor in Asian markets—mainly Japan, China, and Korea—has continued to provide encouraging growth in sales, promotion, and support of CONVERGE users on the other side of the globe. In November, Daniel Lee, Eric Pomraning, and Yunliang Wang gave users an overview of the current status and future developments of CONVERGE at the IDAJ ICSC 2017 Conferences in Yokohama, Japan; Seoul, South Korea; and Shanghai, China. IDAJ continues to host regular CONVERGE training sessions and has expanded the CONVERGE user base in the automotive OEM market, non-engine markets, and academia.

Assorted Consortia

Convergent Science is proud to be a member of the High-Efficiency Dilute Gasoline Engine (HEDGE-IV) Consortium launched by Southwest Research Institute. This consortium gives Convergent Science the opportunity to work with some of the brightest minds in the engine world who are working together to produce cost-effective solutions to engine efficiency-related challenges.

Our Computational Chemistry Consortium (C3) was formed to bring together industry, academic, and government partners to refine existing computational chemistry tools. C3 is now in full swing, with a major global automotive OEM leading the way. With more than twenty years of experience developing comprehensive chemistry models to help predict real fuel behavior, Professor Henry Curran is well-positioned as Chief Technical Advisor of this consortium. Professor Curran and I are guiding C3 in its efforts to develop new models, tools, and mechanisms to lead the advancement of combustion and emissions modeling for the entire scientific community.

Convergent Science: India

A great opportunity presented itself when CEI (formerly our distributor in India) closed its office in Pune: Ashish Joshi, former CEI India manager, master of all things EnSight, and CONVERGE super-user and distributor, agreed to be the leader of our newly formed CS India office. Ashish is now helping to sell CONVERGE and support users in India and southeast Asia. According to Ashish, a distinct possibility for huge growth in the engine design market in India exists because by 2020 engine manufacturers will be held to a much stricter Euro VI-level emissions standard. This is an exciting time to have a solid foothold in the Indian engine design market.

Convergent Science Turns 20

Founded in December 1997 by a group of University of Wisconsin-Madison graduate students, Convergent Science (originally Convergent Thinking) made its debut as an engine CFD consulting group. Twenty years later, CONVERGE is now the global leader in IC engine CFD simulation and is continuing to grow in this market and in others.

2018 and Beyond

In 2018, we are looking forward to continuing to expand CONVERGE’s presence in the European, Asian, and Indian automotive markets. Equally exciting is our ongoing expansion into the compressor and pump industries, which are primed to implement accurate transient CFD. Finally, 2018 is a special year because it marks CONVERGE’s 10th anniversary as a commercially available CFD code (keep your eye out for a blog post commemorating this event in just a few months!). We look forward to bringing continued innovation and superlative customer service to all of our clients. Want to join us? Check out our website to find out how CONVERGE can help you solve the hard problems.

NIARs Director of Virtual Engineering Laboratory Dr. Gerardo Olivares, discusses the importance of CFD for aviation research.

NIAR’s Research Engineer, Harsh Shah discusses their Tailless Drone project and how FloEFD allowed them to perform many design iterations in a short space of time helping them to stick to the aggressive time schedule.

Introduction to STAR-CCM+ multiphysics simulation, geometry processing, meshing, solver settings, post processing, and other aspects of the simulation workflow. 

Device security: when ‘how’ becomes just as important as ‘what’ Improve EV Battery Pack Designs With CAD-Embedded Thermal Simulation Updated UVM Cookbook Supports IEEE 1800.2 Standard And Emulation When Bugs Escape Smart Cities’ Head Start On The Mobility Future Device security: when ‘how’ becomes just as important as ‘what’ Embedded.com Embedded

How can we leverage virtual prototyping as the best practice for designing reliable transformers?

Watch this web seminar to find out!

Evaluating EDA Functional Safety in the AV Era Why Parallelization Is So Hard Living on the (IoT) Edge A Faster, More Cost-Effective Way to Model High-Performance Motors Mailboxes: utility services and data structures Evaluating EDA Functional Safety in the AV Era EE Times ICs destined for automotive applications must meet strict functional safety and reliability standards such as ISO 26262. To

BELLEVUE, WA (Aug. 16, 2018): As part of its ongoing growth and expansion, Tecplot, Inc. (Tecplot) is excited to announce the acquisition of their distributor in Europe and Western Asia, Genias Graphics GmbH & Co. KG (Genias). Tecplot customers in that region will now have direct support and access to the full extent of product knowledge that Tecplot offers.

“This acquisition reinforces our commitment to our European and Western Asian customers, giving them the best support and service possible.” says Tom Chan, President of Tecplot. “We are now in a position to directly communicate with more than 90% of our customers, ensuring their voice is heard when we make important product decisions.”

 
At the helm of European operations will be Lothar Lippert, who has been promoted to Regional Manager. Lothar has years of leadership experience, a depth of knowledge and experience with Tecplot products, and has served as the Manager of Business Development at Genias. During his time at Genias, Lothar has developed close relationships with clients in the region.

“I am honored to have the opportunity to lead Tecplot’s European operations.” said Lothar “I am excited to start my new role and to continue to foster and deepen relationships with clients new and old. This acquisition opens up new opportunities for growth by giving our clients close and direct access to all solutions and services that Tecplot has to offer.”

About Tecplot, Inc.

An operating company of Toronto-based Constellation Software, Inc. (CSI), Tecplot is the leading independent developer of visualization and analysis software for engineers and scientists. CSI is a public company listed on the Toronto Stock Exchange (TSX:CSU). CSI acquires, manages and builds software businesses that provide mission-critical solutions in specific vertical markets.

Tecplot visualization and analysis software allows customers using desktop computers and laptops to quickly analyze and understand information hidden in complex data, and communicate their results to others via professional images and animations. The company’s products are used by more than 47,000 technical professionals around the world.

Contact:

Margaret Connelly
Marketing Manager, Tecplot, Inc.
pr@tecplot.com
(425) 653-1200

Bursting the Bubble on Traditional History Matching

Try Tecplot RS for Free

The big problem with traditional history match workflows is that they are cumbersome. Doing a well by well analysis is time consuming, and it can be difficult to get a holistic view of your reservoir.

A better way is to examine the history match spatially – that is in one view.

I want to show you a method that ties the production and historical data to the grid solution, giving you a deeper understanding of what is happening with the history match.

Stay with me here as I walk you through a real-world problem set using our solution, Tecplot RS.

History Match Dataset

Those of you who have seen me in person or on customer visits know this dataset all too well!
I am using the Eclipse SPE_EX simulation deck which includes:

• A grid solution
• A unified restart (dynamic variables)
• Initialization file (static variables)
• A unified summary file (XY production data)

In this particular dataset, the unified summary file includes the historical data, which I will use during the analysis. This workflow is applicable for any simulation source, not just Eclipse.

Bubble Pie Settings dialog

Download the simulation deck (SPE_EX.zip) to follow along

Bubble Pie Chart Setup

To spatially understand the accuracy of my history match, I’m going to use Bubble Pie Charts, a feature in Tecplot RS.

After I load data my data, I will activate the Bubble Pie Charts by checking the “Bubbles” checkbox, and set them up. For this particular dataset, I output the h variables in the unified summary file. I want to set up the bubbles to compare the simulated water production total with the historical totals. The production data from the unified summary file is populated into the Bubble Pie Settings dialog.

Settings walk-through:

• Assign WPT and WPTH for Bubble Pie Segments
• Assign WPTH Pie Segment color as pink
• Change bubble size to dynamic, and size each bubble by the size of the bottom hole pressure at each time step
• Size bubbles appropriately to match the data

Download a Free Trial of Tecplot RS

Interpreting the Results

At this particular time step (Jan 1, 1971), the view shows the proportional magnitude of WPT vs. WPTH at each well. If pink is dominating the bubble, the well is underproducing at that particular time step. If blue is dominating, then it is overproducing. The relative size of the bubble represents the magnitude of the bottom hole pressure. I am able to quickly understand which wells are over or underproducing while animating my grid solution through time.

Proportional Magnitude of WPT vs. WPTH at Each Well

Tying in the Raw Results

I can understand this even more by taking advantage of the Quick XY functionality in Tecplot RS. Already, I have a spatial view that helps me accurately understand my history match. Using Quick XY, I can also understand the raw data – well by well – and link together quantitative and qualitative results.

Quick XY

Delta Bubbles

In case I haven’t output the h variables in my results, or if I’m viewing results from a completely different simulator, I can still take full advantage of this workflow. This is an alternative setup from the one mentioned earlier in this post.

I can load in my grid solution, production data, and auxiliary historical data into Tecplot RS from any source. I’m going to Activate the Show Deltas checkbox and select my auxiliary history data from the Delta File dropdown.

Now I’m viewing the same data (SPE_EX simulation deck) but in a slightly different way. In this view, blue Bubbles indicate overproduction, white Bubbles indicate underproduction. The size of these bubbles reflect the normalized difference between the historical and simulated water production at each time step.

Delta Bubbles

Modify Grid Properties On-the-Fly

Bring the workflow full-circle by making necessary grid property modifications on-the-fly. In this case, the area in green is severely underproducing in water. I can use the Property Modifier tool in Tecplot RS to make the appropriate modifications to specified regions. I will choose to increase the permeability by 2000 in this region.

Modify Grid Properties

Output File

The resulting output file can then be used as an include file in your next simulation run. In this example, I have output only the multipliers. I could have chosen to output the entire array. The user has the option of outputting in different simulation types. See the video tutorial on Modifying Grid Properties.

Rinse and Repeat

Once you have run your next simulation, you can walk through this workflow again to analyze the accuracy of your history match.

Jim Gilman walks through these workflows in his Webinar History Match Efficiency with Tecplot RS.

And here is a 6-minute video tutorial on History Match Workflows.

 
Try Tecplot RS for Free

Tecplot for Converge Images, left to right: Isovolume, Stream Ribbons, Interior Isosurface, Slice Mesh at Spark Plug.
Request a quote for the full version of Tecplot 360.

Earlier this year, we held a Webinar with Convergent Science on post processing CONVERGE data with Tecplot 360. These are the questions that came out of that Webinar (plus a few more we have been asked). Our goal is to answer the question… How can you quickly post-process CONVERGE output?

What is Tecplot for CONVERGE?

Tecplot for CONVERGE is a nearly full version of Tecplot 360. A complimentary copy is included with every CONVERGE license. For more information, see Tecplot for CONVERGE.

How do I get Tecplot for CONVERGE?

Convergent Science distributes and licenses Tecplot for CONVERGE. To obtain a Tecplot for CONVERGE license, contact Convergent Science.

How do I get the full version of Tecplot 360?

We have special pricing available for CONVERGE users. Call us at 425-653-1200 or 1-800-763-7005, email sales@tecplot.com, or request a quote.

What is the memory requirement per million cells of CONVERGE?

Memory consumption depends on your data file format, how many variables you’re viewing in the plot, and the plot elements you have.

Tecplot 360 avoids loading variables that are not used for plotting or calculations. It will also unload data when it is no longer needed. This helps increase speed and reduce the memory foot print.

For a concrete example, a 12 million cell Gas Turbine result from CONVERGE consumes ~2.5Gb of RAM when displaying the outer boundary and displaying one slice through the data.

How do I load CONVERGE files into Tecplot 360?

CONVERGE creates post*.out files. These files must be converted to Tecplot format using the post_convert utility. You can then load them directly into Tecplot 360.

Convergent Science intends to release an update to CONVERGE which will export CGNS files directly. CGNS files can be loaded directly into Tecplot 360. This will eliminate the need to run post_convert.

Is it possible to overlay two contour or scatterplots from different times on the same plot?

This is possible by using two separate frames. Each frame in Tecplot 360 can display only a single time value. By using two frames and turning off the frame background you can overlay two frames to achieve this effect.

Can Tecplot automatically find the min/max values of a particular time to create contours?

When defining contour levels, Tecplot 360 defaults to using the contour values from the first, last, and middle time steps.

To find the true min/max values of a variable through all time, use Tecplot 360’s Python API, PyTecplot. A simple PyTecplot command will return this value.

This command will return the min/max values of the Pressure variable over all time:

tecplot.active_frame().dataset.variable("Pressure").minmax()

You can also use this macro: ContourVarMinMax.mcr

Does Tecplot have keyframe animation?

Yes. This is available in the Animate menu. Key Frame animation allows you to set up multiple view positions and it will perform a linear interpolation between the view positions.

How do I load CONVERGE output files?

A CONVERGE output file loader will be available in Tecplot for CONVERGE in summer 2018. If you have a fully licensed version of Tecplot 360 you can use the General Text Loader.

Does Tecplot 360 load all time steps at once?

Well, yes and no. Tecplot 360 will scan through all of the files to understand how many time steps there are and what the time values are.

On initial load Tecplot 360 will only load the surface zones for the first time step.

As you advance through time, Tecplot 360 will load the data needed to generate the plot at each time step. This data is cached in RAM as long as possible.

Tecplot 360 will unload unused data as the RAM limit on your machine is reached.

How is the rendering performance of Tecplot 360? Can it also use multiple threads to render?

The rendering performance is highly dependent on your graphics card. We have found that the engineering-grade graphics cards, in particular Nvidia Quadro cards, give very good performance.

Tecplot 360 will use multiple threads for data processing, such as variable calculations. It also uses multiple threads for generation of objects like slices, iso-surfaces, and streamtraces.

For animations, can you save individual frames to images?

This capability is not built in to Tecplot 360 but can easily be done with a Tecplot macro. To step through time and export to individual images, use this macro: export_over_time_to_images.mcr

CONVERGE licenses to include complimentary Tecplot 360 license, creating powerful and seamless CFD and visualization.

BELLEVUE, WASHINGTON – May 31, 2018 – Tecplot is pleased to announce the formation of a new partnership with Convergent Science. As of June 1, each CONVERGE license will include a complimentary Tecplot license, giving CONVERGE users access to Tecplot 360’s powerful CFD visualization and analysis tools.

CONVERGE results in Tecplot 360 showing interior isosurface. See Tecplot for CONVERGE.

“We are very excited to be partnering with Convergent Science, a global leader in CFD,” says Tom Chan, President of Tecplot, Inc. “They have a great team and we look forward to working with Convergent Science to help their user base seamlessly use Tecplot 360 to better comprehend and communicate their CFD results.”

About Tecplot, Inc.

An operating company of Toronto-based Constellation Software, Inc. (CSI), Tecplot is the leading independent developer of visualization and analysis software for engineers and scientists. CSI is a public company listed on the Toronto Stock Exchange (TSX:CSU). CSI acquires, manages and builds software businesses that provide mission-critical solutions in specific vertical markets.

Tecplot visualization and analysis software allows customers using desktop computers and laptops to quickly analyze and understand information hidden in complex data, and communicate their results to others via professional images and animations. The company’s products are used by more than 47,000 technical professionals around the world.

Contact:
Margaret Connelly
Marketing Manager, Tecplot, Inc.
pr@tecplot.com
(425) 653-1200

About Convergent Science

Founded in 1997 in Madison, Wisconsin, Convergent Science is a global leader in computational fluid dynamics (CFD) software. Its customers include leading automotive and commercial vehicle manufacturers, tier one suppliers, and professional motorsport teams.

Its flagship product, CONVERGE, is an innovative CFD software with truly autonomous meshing capabilities that eliminate the grid generation bottleneck from the simulation process. CONVERGE is revolutionizing the CFD industry and shifting the paradigm toward predictive CFD.

Contact:
Tiffany Cook
Media & Partner Relations, Convergent Science
tiffany.cook@convergecfd.com
(830) 625-5005

Sizing Particles (Parcels) by Variable.

Video Script

In this example, we are using a CONVERGE data set with parcel information. We have previously colored the parcels by values of the film flag.

Sizing the parcels by a variable such as mass or number of particles can be done quite easily.

In the Zone Style dialog, select the zone that represents our parcels, here titled Particle. Right-click on Scatter Size and click Select variable… and select the variable to size by, in this case we’ll use dp_mass. Then, right-click again and select By: dp_mass.

The particles do not change size in this case because the scatter Symbol Shape is set to Point. We want to pick a scatter Symbol Shape that will represent size, so we choose Sphere. Now you can see different sizes. Tecplot 360 calculates a default size for the parcels. If you want to adjust the size of the parcels, right-click on Scatter Size and click Select variable… again. Here we can adjust the size particles multiplier.

That is how you change scatter symbols as associated with a size variable.

Thanks for watching!

Isolating Particles with Value Blanking

Video Script

The film flag is an integer with values from zero to five, which represent the different parcel properties. Shown here are the meanings for each film_flag integer value.

Film Flag Integer Values

Let’s open the Value Blanking dialog. Select the film flag variable, dp_film_flag.

We will first look at parcels that are in the wall film only. To do this, we remove all the values that are not equal to one. One being parcels that are in the wall film.

Then we toggle on Active and Include value blanking.

Now we see only the parcels that are in the wall film.

Next, we want to look at only the rebounded particles, which have a film flag value of two. We can do this by simply changing the value in the value blanking dialog to ‘2’. 

If you want an easier way to do this, you can use the Quick Macro Panel.

Seen here in the Quick Macro Panel we simply double-click on Show specific parcels, and enter the value for the parcels we want to display. This quick macro has a nice prompt to allow you to specify what you want to see and will adjust the Value Blanking settings for you.

Let’s take a closer look at the quick macro command, Show specific parcels. You can view and edit macros in any plain text editor.

We use a macro command, called PromptForTextString. This allows you to be prompted to enter text values. Zero for parcels not in a wall film, one for in a wall film, and so on.

 
Macro Command PromptForTextString

$!MacroFunction NAME = "Show specific parcels"
ShowInMacroPanel = TRUE
$!PromptForTextString |film_flag_value|
INSTRUCTIONS = "Enter the parcel type to display:\n0 = Parcel is not in wall film\n1 = Parcel is in wall film\n2 = Rebounded parcels\n3 = Splashed parcels\n4 = Separated parcels\n5 = Stripped parcels"

Below this are the constraints that we’ve set up, which you saw earlier in the Value Blanking dialog.

$!Blanking Value{Constraint 1 {Include = Yes}}
$!Blanking Value{Constraint 1 {VarA = 'dp_film_flag'}}
$!Blanking Value{Constraint 1 {RelOp = NotEqualTo}}
$!Blanking Value{Constraint 1 {ValueCutoff = |film_flag_value|}}
$!Blanking Value{ValueBlankCellMode = PrimaryValue}
$!Blanking Value{Include = Yes}
$!EndMacroFunction

And that is how you can easily isolate particles based on the film flag.

Thank you for watching!

The post Siemens to acquire Lightwork Design appeared first on Schnitger Corporation.

The post Totally OT: #MVGasFire appeared first on Schnitger Corporation.

The post Altair: Bells, clouds, platforms and units bring simulation to the masses appeared first on Schnitger Corporation.

The post #SIAC18 showed that Siemens is more than the sum of its parts appeared first on Schnitger Corporation.

The post Quickie: Nemetschek acquires MCS Solutions for building ops appeared first on Schnitger Corporation.

The post Siemens and Bentley further cement relationship — no acquisition appeared first on Schnitger Corporation.