The current record for stone-skipping is about 88 skips. For most of us, that’s an unimaginably high number, but according to physicists, human throwers may top out around 300 or 350 skips. In the video above and the accompanying article, Wired reporter Robbie Gonzalez explores both the technique of a world-record-holding skip and the physics that enable it. 

The perfect skip requires many ingredients: a large, flat rock with good edges; a strong throw to spin the rock and hold it steady at the right angle of attack; and a good first contact with the right entry angle and force to set up the skips’ trajectory. The video is long, but it’s well worth a full watch. It gives you an inside look both at a master skipper and at the experts of skipping science. (Video and image credit: Wired; see also: Splash Lab, C. Clanet et al.; submitted by Kam-Yung Soh)

ETA: Wired’s embed code is acting up, so if you can’t see the stone skipping video here, just go to the article directly.

Heads up for those going to the APS DFD meeting! You can catch my talk Monday, Nov. 19th at 5:10PM in Room B206. I’ll be talking about how to use narrative devices to tell scientific stories. I’ll be around for the whole meeting, so feel free to come say hi!

View this post on Instagram

A post shared by MuzMuzTV (@muzmuztv) on Jul 30, 2018 at 8:50am PDT

Not everything that flows is a fluid. And when viewed from above traffic, crowds, and even herds of sheep flow in patterns like those of a fluid. In particular, these conglomerations move like compressible fluids – ones that allow substantial changes in density as they flow. From above, each sheep is just a few pixels of white, but you can see which areas of the herd have the highest density by how white an area looks. The highest density regions also tend to be the slowest moving – not surprising in a crowd.

Now watch the gates. They act like choke points in the flow and, to some extent, like a nozzle in supersonic flow. As the sheep approach the gate, they’re in a dense, slow moving clump, but as they pass through it, the sheep speed up and spread out. This is exactly what happens in a supersonic nozzle. On the upstream end, flow in the nozzle is subsonic and dense. But once the flow hits the speed of sound at the narrowest point in the nozzle, the opening on the downstream side allows the flow to spread out and speed up past Mach 1.  (Video credit: MuzMuzTV*; submitted by Trent D.)

*Editor’s Note: I do my best to credit the original producers of any media featured on FYFD, but this is especially difficult with viral videos as there can be many copies, all of which are uncredited. I’ve made my best guess on this one, but if this is your video, please let me know so that I can credit you properly. Thanks!

The latest FYFD/JFM video is out, and it’s all about the interactions between structures and flows! We learn about plesiosaur-inspired underwater robots, how turbulence affects air-water interfaces, and how adding a tail can help hide an object in a flow. If you missed one of the previous episodes in this series, you can find them all here. (Image and video credit: T. Crawford and N. Sharp)

Nectar-drinking species of hummingbirds and bats are both excellent at hovering – one of the toughest aerodynamic feats – but they each have their own ways of doing it. Hummingbirds (bottom) use a nearly horizontal stroke pattern that’s quite symmetric on both the up- and downstroke. To keep generating lift in the upstroke, they twist their wings strongly midway through the stroke. So although hummingbirds get most of their lift from the downstroke, they get quite a bit from the upstroke as well.

Bats, on the other hand, use an asymmetric wingbeat pattern when hovering. Bats flap in a diagonal stroke pattern, using a high angle of attack in the downstroke and an even higher one during the upstroke. They also retract their wings partially during the upstroke. This flapping pattern gives them weak lift during the upstroke, which they compensate for with a stronger downstroke. Compared to non-hovering bat species, nectar-drinking bats do get more lift during the upstroke, but they’re nowhere near as good as the hummingbirds. The bats compensate by having much larger wings compared to their body size. Bigger wings mean more lift.

In the end, the two types of hovering cost roughly the same amount of power per gram of body weight. That’s great news for engineers designing the next generation of flapping robots because it suggests two very different, but equally power-efficient methods for hovering. (Image credit: Lentink Lab/Science News, source; research credit: R. Ingersoll et al.; via Science News; submitted by Kam Yung-Soh) 

With some help from Physics Girl and her friends, Grant Sanderson at 3Blue1Brown has a nice video introduction to turbulence, complete with neat homemade laser-sheet illuminations of turbulent flows. Grant explains some of the basics of what turbulence is (and isn’t) and gives viewers a look at the equations that govern flow – as befits a mathematics channel! 

There’s also an introduction to Kolmogorov’s theorem, which, to date, has been one of the most successful theoretical approaches to understanding turbulence. It describes how energy is passed from large eddies in the flow to smaller ones, and it’s been tested extensively in the nearly 80 years since its first appearance. Just how well the theory holds, and what situations it breaks down in, are still topics of active research and debate. (Video and image credit: G. Sanderson/3Blue1Brown; submitted by Maria-Isabel C.)

As someone who has played with her share of vortex cannons, I can assure you that messing around with smoke generators and vortex rings is a lot of fun. And in this video, Dianna gives things a little twist: she makes the vortex cannon’s mouth a square instead of a circle.

Now, that doesn’t create a square vortex ring. (Vortex rings don’t really do 90-degree corners.) But it does make the vortex ring all neat and wobbly. Whenever you have two vortices near one another (or, in this case, two parts of a vortex line near one another), they interact. As Dianna shows with hurricanes, depending on the direction of rotation and their relative strength, nearby vortices can orbit one another or travel together in straight lines – or they can cause more complicated interactions, like in the case of the square-launched rings.  

I think there may also be some interesting effects here from vortex stretching, but that’s a topic for another day! (Video and image credit: D. Cowern/Physics Girl; see also: LIBLAB; submitted by Maria-Isabel C.)

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.

Illini EV Concept Team Photo at Shell Eco Marathon 2018

Weight is the enemy of all teams that design electric cars for the Shell Eco Marathon.

Reducing the weight of electric cars improves the vehicle’s acceleration and power efficiency. These performance improvements make all the difference come race day.

However, if the car’s weight is reduced too much, it could lead to safety concerns.

Illini EV Concept (Illini) is a Shell Eco Marathon team out of the University of Illinois. Team members use ANSYS academic research software to optimize the chassis of their electric car without compromising safety.

Where to Start When Reducing the Weight of Electric Cars?

Front bump composite failure under a load of 2000N.

The first hurdle of the Shell Eco Marathon is an initial efficiency contest. Only the best teams from this efficiency assessment even make it into the race.

Therefore, Illini concentrates on reducing the most weight in the shortest amount of time to ensure it makes it to the starting line.

Illini notes that its focus is on reducing the weight of its electric car’s chassis.

“The chassis is by far the heaviest component of our car, so ANSYS was used extensively to help design our first carbon fiber monocoque chassis,” says Richard Mauge, body and chassis leader for Illini.

“Several loading conditions were tested to ensure the chassis was stiff enough and the carbon fiber did not fail using the composite failure tool,” he adds.

Competition regulations ensure the safety of all team members. These regulations state that each team must prove that their car is safe under various conditions. Simulation is a great tool to prove a design is within safety tolerances.

“One of these tests included ensuring the bulkhead could withstand a 700 N load in all directions, per competition regulations,” says Mauge. If the teams’ electric car designs can’t survive this simulation come race day, then their cars are not racing.

Iterate and Optimize the Design of Electronic Cars with Simulation

Front bump deformation under a load of 2000N.

Simulations can do more than prove a design is safe. They can also help to optimize designs.

Illini uses what it learns from simulation to optimize the geometry of its electric car’s chassis.

The team found that its new designs have a torsional rigidity increase around 100 percent. This is after a 15 percent decrease in weight compared to last year’s model.

“Simulations ensure that the chassis is safe enough for our driver. It also proved that the chassis is lighter and stiffer than ever before. ANSYS composite analysis gave us the confidence to move forward with our radical chassis redesign,” notes Mauge.

The story optimization story continues from Illini. It plans to explore easier and more cost-effective ways to manufacture carbon fiber parts. For instance, the team wants to replace the core of its parts with foam and increase the number of bonded pieces.

If team members just go with their gut on these hunches, they could find themselves scratching their heads when something goes wrong. However, with simulations, the team makes better informed decisions about its redesigns and manufacturing process.

To get started with simulation, try our free student download. For student teams that need to solve in-depth problems, check out our software sponsorship program.

The post How to Increase the Acceleration and Efficiency of Electric Cars for the Shell Eco Marathon appeared first on ANSYS.

This engine intake simulation was post-processed using EnSight Enterprise. This allowed for the processing of a large data set to be shared among servers.

Simulation data sets have a funny habit of ballooning as engineers move through the development cycle. At some point, post-processing these data sets on a single machine becomes impractical.

Engineers can speed up post-processing by spatially or temporally decomposing large data sets so they can be post-processed across numerous servers.

The idea is to utilize the idle compute nodes you used to run the solver in parallel to now run the post-processing in parallel.

In ANSYS 19.2 Ensight Enterprise you can spatially or temporally decompose data sets. Ensignt Enterprise is an updated version of EnSight HPC.

Post-Processing Using Spatial Decomposition

EnSight is a client/server architecture. The client program takes care of the graphical user interface (GUI) and rendering operations, while the server program loads the data, creates parts, extracts features and calculates results.

If your model is too large to post-process on a single machine, you can utilize the spatial decomposed parallel operation to assign each spatial partition to its own EnSight Server. A good server-to-model ratio is one server for every 50 million elements.

Each EnSight Server can be located on a separate compute node on any compute resource you’d like. This allows engineers to utilize the memory and processing power of heterogeneous high-performance computing (HPC) resources for data set post-processing.

The engineers effectively split the large data set up into pieces with each piece assigned to its own compute resource. This dramatically increases the data set sizes you can load and process.

Once you have loaded the model into EnSight Enterprise, there are no additional changes to your workflow, experience or operations.

Post-Processing Using Temporal Decomposition

Keep in mind that this decomposition concept can also be applied to transient data sets. In this case, the dataset is split up temporally rather than spatially. In this scenario, each server receives its own set of time steps.

A turbulence simulation created using EnSight Enterprise post-processing

EnSight Enterprise offers performance gains when the server operations outweigh the communication and rendering time of each time step. Since it’s hard to predict network communication or rendering workloads, you can’t easily create a guiding principle for the server-to-model ratio.

However, you might want to use a few servers when your model has more than 10 million elements and over a hundred time steps. This will help keep the processing load of each server to a moderate level.

How EnSight Speeds Up the Post-Processing of Large Simulation Data Sets

Another good tip to ensure you are post-processed optimally within EnSight Enterprise. Engineers achieve the best performance gains by pre-decomposing the data and locating it locally to the compute resources they anticipate using. Ideally, this data should be in EnSight Case format.

To learn more, check out Ensight or register for the webinar Analyze, Visualize and Communicate Your Simulation Data with ANSYS EnSight.

The post Post-Processing Large Simulation Data Sets Quickly Over Multiple Servers appeared first on ANSYS.

Your design team will make informed decisions about the products they create when they bring detailed simulations up front in the development cycle.

The 19.2 release of ANSYS Discovery AIM facilitates the need of early simulations.

It does this by streamlining templates for physics-aware meshing and rapid results.

High-Fidelity Simulation Through Physics-Aware Meshing

Discovery AIM user interface with a solution fidelity slide bar (top left), area of interest marking tool (left, middle), manual mesh controls (bottom, center) and a switch to turn the mesh display on and off (right, top).

Analysts have likely told your design team about the importance of a quality mesh to achieve accurate simulation results.

Creating high quality meshes takes time and specialized training. Your design team doesn’t likely have the time or patience to learn this art.

To account for this, Discovery AIM automatically incorporates physics-aware meshing behind the scenes. In fact, your design team doesn’t even need to see the mesh creation process to complete the simulation.

This workflow employs several meshing best practices analysts typically use. The tool even accounts for areas that require mesh refinements based on the physics being assessed.

For instance, areas with a sliding contact gain a finer mesh so the sliding behavior can be accurately simulated. Additionally, areas near the walls of fluid-solid interfaces are also refined to ensure this interaction is properly captured. Physics-aware meshing ensures small features and areas of interests won’t get lost in your design team’s simulation.

The simplified meshing workflow also lets your design team choose their desired solution fidelity. This input will help the software balance the time the solver takes to compute results with the accuracy of the results.

Though physics-aware meshing can create the mesh under the hood of the simulation process, it still has tools allowing user-control of the mesh. This way, if your design team chooses to dig into the meshing details — or an analyst decides to step in — they can finely tune the mesh.

Capabilities like this further empower designers as techniques and knowledge traditionally known only by analysts are automated in an easy-to-use fashion.

Gain Rapid Results in Important Areas You Might Miss

The 19.2 release of Discovery AIM has seen improvements with its ability to enable your design team to explore simulation results.

Many analysts will know instinctively where to focus their post-processing, but without this experience, designers may miss areas of interest.

Discovery AIM enables the designer to interactively explore and identify these critical results. These initial results are rapidly displayed as contours, streamlines or field flow lines.

Field flow and streamlines for an electromagnetics simulation

Once your design team finds locations of interest within the results, they can create higher fidelity results to examine those area of interest in further detail. Designers can then save the results and revisit them when comparing design points or after changing simulation inputs.

To learn more about other changes to Discovery AIM — like the ability to directly access fluid results — watch the Discovery AIM 19.2 release recorded webinar or take it for a test drive.

The post Discovery AIM Offers Design Teams Rapid Results and Physics-Aware Meshing appeared first on ANSYS.

Traditional chemotherapy can often be blocked by a tumor’s stroma.

There are few illnesses as crafty as pancreatic cancer. It spreads like weeds and resists chemotherapy.

Pancreatic cancer is often asymptomatic, has a low survival rate and is often misdiagnosed as diabetes. And, this violent killer is almost always inoperable.

The pancreatic tumor’s resistance to chemotherapy comes from a shield of supporting connective tissue, or stroma, which it builds around itself.

Current treatments attempt to overcome this defense by increasing the dosage of intravenously administered chemotherapy. Sadly, this rarely works, and the high dosage is exceptionally hard on patients.

Nonetheless, doctors need a way to shrink these tumors so that they can surgically remove them without risking the numerous organs and vasculature around the pancreas.

“We say if you can’t get the drugs to the tumor from the blood, why not get it through the stroma directly?” asks William Daunch, CTO at Advanced Chemotherapy Technologies (ACT), an ANSYS Startup Program member. “We are developing a medical device that implants directly onto the pancreas. It passes drugs through the organ, across the stroma to the tumor using iontophoresis.”

By treating the tumor directly, doctors can theoretically shrink the tumor to an operable size with a smaller dose of chemotherapy. This should significantly reduce the effects of the drugs on the rest of the patient’s body.

How to Treat Pancreatic Cancer with a Little Electrochemistry

Simplified diagram of the iontophoresis used by ACT’s chemotherapy medical device.

Most of the drugs used to treat pancreatic cancer are charged. This means they are affected by electromotive forces.

ACT has created a medical device that takes advantage of the medication’s charge to beat the stroma’s defenses using electrochemistry and iontophoresis.

The device contains a reservoir with an electrode. The reservoir connects to tubes that connect to an infusion pump. This setup ensures that the reservoir is continuously filled. If the reservoir is full, the dosage doesn’t change.

The tubes and wires are all connected into a port that is surgically implanted into the patient’s abdomen.

A diagram of ACT’s chemotherapy medical device.

The circuit is completed by a metal panel on the back of the patient.

“When the infusion pump runs, and electricity is applied, the electromotive forces push the medication into the stroma’s tissue without a needle. The medication can pass up to 10 to 15 mm into the stroma’s tissue in about an hour. This is enough to get through the stroma and into the tumor,” says Daunch.

“Lab tests show that the medical device was highly effective in treating human pancreatic cancer cells within mice,” added Daunch. “With conventional infusion therapy, the tumors grew 700 percent and with the device working on natural diffusion alone the tumors grew 200 percent. However, when running the device with iontophoresis, the tumor shrank 40 percent. This could turn an inoperable tumor into an operable one.” Subsequent testing of a scaled-up device in canines demonstrated depth of penetration and the low systemic toxicity required for a human device.

Daunch notes that the Food and Drug Administration (FDA) took notice of these results. ACT’s next steps are to develop a human clinical device and move onto to human safety trials.

Simulation Optimized the Fluid Dynamics in the Pancreatic Cancer Chemotherapy Implant

Before these promising tests, ACT faced a few design challenges when coming up with their chemotherapy implant.

For example, “There was some electrolysis on the electrode in the reservoir. This created bubbles that would change the electrode’s impedance,” explains Daunch. “We needed a mechanism to sweep the bubbles from the surface.”

An added challenge is that ACT never knows exactly where doctors will place the device on the pancreas. As a result, the mechanism to sweep the bubbles needs to work from any orientation.

Simulations help ACT design their medical device so bubbles do not collect on the electrode.

“We used ANSYS Fluent and ANSYS Discovery Live to iterate a series of designs,” says Daunch. “Our design team modeled and validated our work very quickly. We also noticed that the bubbles didn’t need to leave the reservoir, just the electrode.”

“If we place the electrode on a protrusion in a bowl-shaped reservoir the bubbles move aside into a trough,” explains Daunch. “The fast fluid flow in the center of the electrode and the slower flow around it would push the bubbles off the electrode and keep them off until the bubbles floated to the top.”

As a result, the natural fluid flow within the redesigned reservoir was able to ensure the bubbles didn’t affect the electrode’s impedance.

To learn how your startup can use computational fluid dynamics (CFD) software to address your design challenges, please visit the ANSYS Startup Program.

The post Simulation Optimizes a Chemotherapy Implant to Treat Pancreatic Cancer appeared first on ANSYS.

The demand for wireless communications with high data transfer rates is growing.

Consumers want wireless 4K video streams, virtual reality, cloud backups and docking. However, it’s a challenge to offer these data transfer hogs wirelessly.

Peraso aims to overcome this challenge with their W120 WiGig chipset. This device offers multigigabit data transfers, is as small as a thumb-drive and plugs into a USB 3.0 port.

The chipset uses the Wi-Fi Alliance’s new wireless networking standard, WiGig.

This standard adds a 60 GHz communication band to the 2.4 and 5 GHz bands used by traditional Wi-Fi. The result is higher data rates, lower latency and dynamic session transferring with multiband devices.

In theory, the W120 WiGig chipset could run some of the heaviest data transfer hogs on the market without a cord. Peraso’s challenge is to design a way for the chipset to dissipate all the heat it generates.

Peraso uses the multiphysics capabilities within the ANSYS Electronics portfolio to predict the Joule heating and the subsequent heat flow effects of the W120 WiGig chipset. This information helps them iterate their designs to better dissipate the heat.

How to Design High Speed Wireless Chips That Don’t Overheat

Systems designers know that asking for high-power transmitters in a compact and cost-effective enclosure translates into a thermal challenge. The W120 WiGig chipset is no different.

A cross section temperature map of the W120 WiGig chipset’s PCB. The map shows hot spots where air flow is constrained by narrow gaps between the PCB and enclosure.

The chipset includes active/passive components and two main chips that are mounted on a printed circuit board (PCB). The system reaches considerably high temperatures due to the Joule heating effect.

To dissipate this heat, design engineers include a large heat sink that connects only to the chips and a smaller one that connects only to the PCB. The system is also enclosed in a casing with limited openings.

Simulation of the air flow around the W120 WiGig chipset without an enclosure. Simulation was made using ANSYS Icepak.

Traditionally, optimizing this set up takes a lot of trial and error as measuring the air flow within the enclosure would be challenging.

Instead, Peraso uses ANSYS SIwave to simulate the Joule heating effects of the system. This heat map is transferred to ANSYS Icepak, which then simulates the current heat flow, orthotropic thermal conductivity, heat sources and other thermal effects.

This multiphysics simulation enables Peraso to predict the heat distribution and the temperature at every point of the W120 WiGig chipset.

From there, Peraso engineers iterate their designs until they reached their coolest setup.

This simulation led design tactic helps Peraso optimize their system until they reached a heat transfer balance they need. To learn how Peraso performed this iteration, read Cutting the Cords.

The post Making Wireless Multigigabit Data Transfer Reliable with Simulation appeared first on ANSYS.

There is only so much communication bandwidth available. This will make it difficult to handle the boost in cellular traffic expected from the 5G network using conventional cellular technologies.

In fact, cellular networks are already running out of bandwidth. This severely limits the number of users and data rates that can be accommodated by wireless systems.

One potential solution is to leverage beamforming antennas. These devices transmit different signals to different locations on the cellular network simultaneously over the same frequency.

Pivotal Commware is using ANSYS HFSS to design beamforming antennas for cellular base stations that are much more affordable than current technology.

How 5G Networks Will Send More Signals on Existing Bandwidths

A 28 GHz antenna for a cellular base station.

Traditionally, cellular technologies — 3G and 4G LTE — crammed more signals on the existing bandwidth by dividing the frequencies into small segments and splitting the signal time into smaller pulses.

The problem is, there is only so much you can do to chop up the bandwidth into segments.

Alternatively, Pivotal’s holographic beamforming (HBF) antennas are highly directional. This means they can split up the physical space a signal moves through.

This way, two cells in two locations can use the same frequency at the same time without interfering with each other.

Additionally, these HBF antennas use varactor (variable capacitors) and electronic components that are simpler and more affordable than existing beamforming antennas.

How to Design HBF Antennas for 5G Cellular Base Stations

A parametric study of Pivotal’s HBF designs allowed them to look at a large portion of their design space and optimize for C-SWaP and roll-off. This study looks at roll-off as a function of degrees from the centerline of the antenna.

Antenna design companies — like Pivotal — are always looking to design devices that optimize cost, size, weight and power (C-SWaP) and performance.

So, how was Pivotal able to account for C-SWaP and performance so thoroughly?

Traditionally, this was done by building prototypes, finding flaws, creating new designs and integrating manually.

Meeting a product launch with an optimized product using this manual method is grueling.

Pivotal instead uses ANSYS HFSS to simulate their 5G antennas digitally. This allows them to assess their HBF antennas and iterate their designs faster using parametric studies.

For instance, Pivotal wants to optimize their design for performance characteristics like roll-off. To do so they can plug in the parameter values, run simulations with these values and see how each parameter affects roll-off.

By setting up parametric studies, Pivotal assess which parameters affect performance and C-SWaP the most. From there they could weigh different trade-offs until they settled on an optimized design that accounted for all the factors they studied.

To see how Pivotal set up their parametric studies and optimize their antenna designs, read 5G Antenna Technology for Smart Products.

The post Designing 5G Cellular Base Station Antennas Using Parametric Studies appeared first on ANSYS.

Imagine that you are modeling an engine. Engines are complex machines, and accurately modeling an engine is not an easy undertaking. Capturing in-cylinder dynamics, intake and exhaust system characteristics, complicated boundary conditions, and much more creates a problem that often takes multiple software suites to solve.

Convergent Science has a solution: CONVERGE Lite—and we’ve just introduced a new licensing option.

CONVERGE Lite is a reduced version of CONVERGE that comes free of charge with every GT-SUITE license. Gamma Technologies, the developer of GT-SUITE, and Convergent Science combined forces to allow users of GT-SUITE to leverage the power of CONVERGE.

CONVERGE LITE + GT-SUITE OVERVIEW

GT-SUITE is an industry-leading CAE system simulation tool that combines 1D physics modeling, such as fluid flow, thermal analysis, and mechanics, with 3D multi-body dynamics and 3D finite element thermal and structural analysis. GT-SUITE is a great tool for a wide variety of system simulations, including vehicles, engines, transmission, general powertrains, hydraulics, and more.

Let’s think again about modeling an engine. GT-SUITE is ideal for the primary workflow of engine design. But, what if you want to model 3D mixing in an intake engine manifold to track the cylinder-to-cylinder distribution of recirculated exhaust gas? Or simulate complex 3D flow through a throttle body to find the optimal design to maximize power? In these scenarios, 1D modeling is not sufficient on its own.

In this type of situation where 3D flow analysis is critical, GT-SUITE users can invoke CONVERGE Lite to obtain detailed 3D analysis at no extra charge. CONVERGE Lite is fully integrated into GT-SUITE and is known for being user friendly. One of the biggest advantages of CONVERGE Lite is that it allows GT-SUITE users access to CONVERGE’s powerful autonomous meshing. With automatic mesh generation, fixed mesh embedding, and Adaptive Mesh Refinement, CONVERGE Lite eliminates user meshing time and allows for efficient grid refinement. In addition, CONVERGE Lite comes with automatic CFD species setup and automatic setup of fluid properties to match the properties in the GT-SUITE model. And as if that weren’t enough, recently CONVERGE Lite has been enhanced to include a license for Tecplot for CONVERGE, an advanced 3D post-processing software.

LICENSING

You can run CONVERGE Lite in serial for free if you have a GT-SUITE license. If you want to run CONVERGE Lite in parallel, you can purchase parallel licenses from Convergent Science. We have just introduced a new low-cost option for running CONVERGE Lite in parallel. For one flat fee, you can obtain a license from Convergent Science to run CONVERGE Lite on an unlimited number of cores. Even though CONVERGE Lite contains many features to enhance efficiency, 3D simulations can be computationally expensive. This new option is a great way to affordably speed up your integrated GT-SUITE + CONVERGE Lite simulations.

CONVERGE Lite is a robust tool, but it does not contain all of the features of the full CONVERGE solver. For example, if you want to take advantage of advanced physical models, like combustion, spray, or volume of fluid, or you want to simulate moving walls, such as pistons or poppet valves, a full CONVERGE license is required. With both a full CONVERGE license and a GT-SUITE license, you can also take advantage of CONVERGE’s detailed chemistry solver, multiphase flow modeling, and other powerful features while performing advanced CONVERGE + GT-SUITE coupled simulations.

The combined power of CONVERGE and GT-SUITE opens the door to a whole array of advanced simulations, like engine cylinder coupling, exhaust aftertreatment coupling, or fluid-structure interaction coupling, that cannot be accomplished with just one of the programs.

Contact a Convergent Science salesperson for licensing details and pricing information.

Contact sales

One of the more controversial subjects we talk about here at Convergent Science is the role of turbulence-chemistry interaction (TCI) when using our SAGE detailed chemistry solver.

What is TCI?

TCI is used to describe two separate but linked processes: enhanced mixing in momentum, energy, and species due to turbulence and the commutation error in the reaction rate evaluation. A good turbulence model should always account for the enhanced mixing due to turbulence.

The commutation error is more difficult to address. In an LES simulation, the commutation error is the difference between evaluating the reaction rates using the spatially filtered quantities and using the un-filtered quantities (the latter is exact and the former is an approximation) and then filtering the reaction rates. It is usually convenient to use the averaged or filtered values to evaluate the reaction rates, which unfortunately means more error. For LES, the commutation error reduces as the cell size is reduced^[1], and thus, with sufficient grid resolution, the commutation error becomes negligible.

In this blog post, we briefly describe a study that demonstrates that with sufficient grid resolution, CONVERGE CFD (with LES and detailed chemistry) can resolve the enhanced mixing due to turbulence without explicitly assigning a sub-grid model for the commutation error. For more details, please see the accompanying white paper.

Simulation Strategy

We simulate a canonical turbulent partially premixed flame, Sandia Flame D. We leverage Adaptive Mesh Refinement (AMR) and adaptive zoning as acceleration strategies to speed up the computationally expensive LES simulations. Figure 1 shows the fine resolution around a subsection of the flame due to AMR, which allows us to get good resolution when and where we need it.

Conclusion In Brief

We first conduct grid convergence studies and find that 0.25 mm minimum grid size is sufficient to resolve most of the velocity and species fluctuations.

Then, we demonstrate that the commutation error becomes smaller and we resolve more velocity and species fluctuations as we use finer meshes. With the finest mesh, we match not only the the mean and RMS to the experimental value, but also the conditional mean and the shape of joint probability distribution function.

Finally, we take on the challenge of accurately predicting of non-equilibrium combustion processes. These processes (i.e., extinction and reignition) are dependent on two factors:

1. An accurate mechanism for the range of conditions simulated and
2. A good LES solver with sufficient grid resolution.

We compare thousands of data points from experiments to the equivalent points from the LES to determine that CONVERGE correctly predicts the extinction and reignition trends.

So what?

The SAGE detailed chemistry solver with LES has demonstrated success in a host of applications^[2,3,4,5,6], including gas turbines and internal combustion engines.

We show in this white paper that when you resolve most of the velocity and species fluctuations and significantly reduce the commutation error, you can predict mixing-controlled turbulent combustion without a model for the commutation error in the reaction rates.

CONVERGE contains multiple acceleration strategies that make SAGE detailed chemistry + LES a reasonable strategy as far as computational costs go. Ready to dive more in-depth? Our TCI white paper is waiting for you!

[1] Davidson, L., “Fluid mechanics, turbulent flow and turbulence modeling,” Chalmers University, 2018. www.tfd.chalmers.se/~lada/postscript_files/solids-and-fluids_turbulent-flow_turbulence-modelling.pdf

[2] Drennan, S.A., and Kumar, G., “Demonstration of an Automatic Meshing Approach for Simulation of a Liquid Fueled Gas Turbine with Detailed Chemistry,” 50th AIAA/ASME/SAE/ASEE Joint PropulsionConference, AIAA 2014-3628, Cleveland, OH, United States, July 28-30, 2014. DOI:10.2514/6.2014-3628

[3] Kumar, G., and Drennan, S., “A CFD Investigation of Multiple Burner Ignition and Flame Propagation with Detailed Chemistry and Automatic Meshing,” 52nd AIAA/SAE/ASEE Joint Propulsion Conference, Propulsion and Energy Forum, AIAA 2016-4561, Salt Lake City, UT, United States, July 25-27, 2016. DOI:10.2514/6.2016-4561

[4] Yang, S., Wang, X., Yang, V., Sun, W., and Huo, H., “Comparison of Flamelet/Progress-Variable and Finite-Rate Chemistry LES Models in a Preconditioning Scheme,” 55th AIAA Aerospace Sciences Meeting, AIAA SciTech Forum, AIAA 2017-0605, Grapevine, TX, United States, January 9-13, 2017. https://doi.org/10.2514/6.2017-0605

[5] Pei, Y., Som, S., Pomraning, E., Senecal, P.K., Skeen, S.A., Manin, J., Pickett, L.M., “Large Eddy Simulation of a Reacting Spray Flame with Multiple Realizations under Compression Ignition Engine Conditions,” Combustion and Flame, 162, 4442-4455, 2015. DOI:10.1016/j.combustflame.2015.08.010

[6] Liu, S., Kumar, G., Wang, M., and Pomraning, E., “Towards Accurate Temperature and Species Mass Fraction Predictions for Sandia Flame-D using Detailed Chemistry and Adaptive Mesh Refinement,” 2018 AIAA Aerospace Sciences Meeting, AIAA SciTech Forum, AIAA 2018-1428. DOI:10.2514/6.2018-1428.

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.

Hiro Yukioka Senior Engineer/Technical Specialist from Mercury Marine discusses how Simcenter FLOEFD aids the engineering process of designing an Intercooler Filter.

Welcome to the Smart Design Series, a library of videos developed to help you become familiar with how Computational Fluid Dynamics (CFD) can be utilized by the design engineer. The series will illustrate how your CAD models can be easily analyzed and dissected to give insight into the workings of their behavior with Simcenter FLOEFD, the award-winning CAD-embedded CFD solution for the design engineer. In this installment of the series, we will review an intake manifold design. The model is quickly prepared for analysis and analyzed. A parametric study is then set up to find how the angle of the throttle valve will affect the flow rate at the exit and then we’ll compare the results between different scenarios. We will also set up a transient study to see the changes in pressure over time when each exit has a different pressure profile versus time. We should point out that while this video features Siemens NX, you can expect the same level of integration with Creo, CATIA V5 and Solid Edge. Watch this 5-minute video now.

These Solid Edge Electrical courses includes interactive videos, written course materials, knowledge checks and hands-on labs through a Virtual Lab platform

Thermal Simulation Software Aims to Improve Design of Autonomous Cars Is Cloud Computing Suitable For Chip Design? Beyond DRC and LVS, why Reliability Verification is used by Foundries Wally Rhines Talks About the Future of PCB and System Design Using an SMTP client Thermal Simulation Software Aims to Improve Design of Autonomous Cars Design News The thermal behavior of an autonomous electric vehicle

Find out what’s new in Simcenter Flomaster Software V9.1.

Load netCDF data with FVCOM loader, import georeferenced images and shapefiles, compute vertical transects

BELLEVUE, WA (October 17, 2018) – Tecplot, Inc. has announced the general availability of Tecplot 360 2018 Release 2.

This release will benefit geoscientists who work with results from numerical models such as FVCOM (Finite-Volume Community Ocean Model), ROMS (Regional Ocean Modeling System), WRF (Weather Research Forecasting Model) and Telemac (Loaders for ROMS, WRF and Telemac are available upon request, contact support@tecplot.com). Highlights that will benefit general Tecplot customers include new colormaps, handy Python scripts, updated Excel add-in, and a CONVERGE output file loader. See all of what is new.

“In our research [of the Geoscience market], we’ve found that most geoscientists spend an inordinate amount of time writing and modifying scripts to evaluate their simulation output,” says Scott Fowler, Tecplot 360 Product Manager. “We’ve also found that many with 3D model results are missing important features in their data because they use tools that do not easily support viewing and exploring the full 3D data.”

Georeferenced image of Puget Sound (Salish Sea) with vertical transect. Image created with Tecplot 360

Unlike script-based post-processing, Tecplot 360 allows geoscientists to quickly view and analyze full 3D models in an interactive user interface – without the need to write scripts. Tecplot 360 allows a quick and thorough exploration of XY, 2D and 3D results, which ensures that important information is neither missed nor overlooked.

Automation can speed analysis, and Tecplot 360 has a rich Python API known as PyTecplot. The Tecplot 360 Python API can generate images, movies and perform advanced analysis. Python scripts may be recorded based on user actions, which accelerates understanding of the API.

Unlike open-source solutions, Tecplot 360 comes with a responsive and knowledgeable Technical Support Team.  Tecplot’s website reports a 96.4% response time within one business day, and a 61.3% immediate response time.

Key features in this release for geoscientists are:

• FVCOM loader for netCDF data.
• ROMS, WRF, Telemac loaders available on request.
• Georeferenced image import to help communicate the location of your data (see video).
• Shapefile import to give additional context to the location of your data (see video).
• Vertical transect (curved slices) computation for vertically projecting a 2D plane along a prescribed path (see video).
• New colormaps for creating beautiful plots.
• Load-on-Demand technology for loading huge datasets.

Download Tecplot 360

Tecplot 360 2018 Release 2 is available for download as Free Trial Software, or for customers through the MyTecplot Customer Portal.

About Tecplot, Inc.

Tecplot, an operating company of Toronto-based Constellation Software, Inc. (CSI), 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 (local or remote) 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

The post Tecplot 360 2018 R2 Helps Geoscientists Analyze Simulated Data appeared first on Tecplot.

Description

In this video, we introduce the use of georeferenced images in Tecplot 360. For datasets that represent a geographic region, a georeferenced image gives additional context to help communicate the location for your data.

We start with a dataset already open, which are results from the Salish Sea model courtesy of Pacific Northwest National Labs. The Salish Sea is situated along southwestern British Columbia and northwestern Washington State. Without a background map the geography is difficult to ascertain when looking at this model.

To better understand our region, we will import a georeferenced image via Insert > Image/Georeferenced Image… Note that you can also use the image insertion tool on the toolbar.

World Files

A georeferenced image consists of an image file and a world file. Tecplot 360 supports JPG, PNG, and BMP image formats. The world file defines the coordinates for where the image should be placed. Tecplot 360 is unit agnostic, so make sure that your world file is in the same coordinate system as your data. This model uses UTM 10, so our world file is also UTM 10.

Once the image is loaded it is placed in the plot with your data. In this case we’re in a 3D Cartesian view so the image is an actual 3D object which will rotate with the data. As we animate through time notice that the tide drops below our image. To adjust the Z-value of the image, right-click on the image and select Image details…. Note that you can also launch this dialog by double-clicking on the image. Use the slider or text field to adjust the image to a lower location – in this case we’ll use -15. Now you can animate and the surface temperature is no longer covered by the image.

Georeferenced images may also be used in 2D plots. In this case you likely no longer need the axes so you may want to disable the axes and increase the extents of the viewport to use the entirety of the frame. In 2D there is no Z adjustment as the image is always drawn behind the data.

This concludes the tutorial for georeferenced images in Tecplot 360.

Thank you for watching!

Try Tecplot 360 for Free

The post Georeferenced Images in Tecplot 360 appeared first on Tecplot.

Description

In this video, we introduce the use of shapefiles in Tecplot 360. For datasets that represent a geographic region, a shapefile can give additional context to help communicate the location of your data. In this video we’ll demonstrate the use of a Python script to convert a shapefile to Tecplot binary data format.

Here we are looking at pressure contours from a simulation of Hurricane Katrina. Without knowing it is hurricane Katrina, it’s difficult to tell where we are in the world. A shapefile will help make the region we are looking at more obvious.

Prerequisites are that you have a 64-bit version of Python and the PyTecplot and pyshp (Pyshape) Python modules installed. From a command prompt execute the script as such:

shapefile_to_plt.py USA_adm1.shp USA_adm1.plt

The script will then prompt you for additional information.

1. Convert to a single zone or one zone per shape. In this case we have a shapefile that represents the entire United States where each state is a separate shape. If we convert this file to one zone per shape, we will have one zone per state. This will allow us to turn on and off individual states and color them differently. Select option #2.
2. Choose the variable names to use. Note that this script does not make any coordinate transformations. If your shapefile is in UTM or Stateplane, it’s likely that you’re displaying your data using X/Y variables – so you should select X/Y. If your shapefile is in longitude/latitude coordinates you should select lon/lat as the exported variable names. In this case our shapefile is in lon/lat and we are displaying our data in lon/lat as well, so select option #2.
3. Finally, when choosing a separate zone per shape, the script will also prompt you for which shapefile record column to use to name the zones. It will display the column name and the first shape file entry. This selection is critical to identify each shape while in Tecplot 360. In this case we’ll choose option #5 which will give each shape the name of the state.

Now that we’ve converted the shapefile to Tecplot PLT format we can append it to the dataset.

• File > Load Data
• Browse to the PLT file
• Append data to active frame
• Match lon/lat to XLONG and XLAT respectively

Now that the shapefile data is loaded we will activate the Mesh layer so we can see the shapefile information. This presents a much clearer picture of the region and the path of the hurricane. If we fit the data to the screen, we can see the entire United States. Because we imported each state as a separate zone, we can deactivate any zones that are outside of our region of interest.

This concludes the tutorial on using shapefiles in Tecplot 360.

Thank you for watching!

Try Tecplot 360 for Free

The post Converting Shapefiles to PLT Using PyTecplot appeared first on Tecplot.

Description

Computing an average over time is an important method in CFD to understand overall trends in turbulent flow fields. In ocean science, a time average can be used to remove the effects of seasonality to understand long term trends. Thankfully, this can be accomplished fairly easily in Tecplot 360.

In this video we’ll start with a vertical transect extracted from an FVCOM solution. This transect shows the salinity along a prescribed path through time. The data has a common grid throughout time, so we can use simple equations to compute the average.

We will duplicate the first zone in our transect and rename the zone to “Transect Time Average.”

Then we can use the Specify Equations dialog to compute the average as such:

1. Select the Transect Time Average zone
2. Enter an equation summing the salinity in each zone, and dividing by the number of zones:
   {salinity} = ({salinity}[1]) + {salinity}[2] + … + {salinity}[n]) / n

Clearly, this will become cumbersome for a large number of timesteps and multiple variables. This will be better done with a Python script which will not only easily handle a large number of zones, but can also compute the time average for a large number of variables.

To run this script we must first enable PyTecplot Connections via the Scripting menu. Then, from a command prompt we execute the script. This will prompt us for which Strand we want to average. The strand number can be found in the Dataset Information dialog. A strand is simply an integer which identifies a collection of zones through time.

Once we enter the strand number the script will handle the zone duplication and execution of the formulas to average the results.

When the script is finished we’ll simply copy the original frame and activate the Time Average zone to view our results.

This concludes the tutorial for computing an average over time in Tecplot 360 using PyTecplot.

Thank you for watching!

Try Tecplot 360 for Free

The post Calculating Average Over Time appeared first on Tecplot.

Description

In this video we’ll show you how to compute a vertical transect from FVCOM data using PyTecplot, our Python API (in Tecplot 360).

A vertical transect is a 2D plane that follows a prescribed path through the data and is projected vertically from the surface to the bottom.

We start with an FVCOM dataset already loaded. This dataset is of the Salish Sea, extending from British Columbia and down into Washington State.

Vertical Transect of the Salish Sea using Tecplot 360.
Related Webinar

Define the Vertical Transect Path

First we need to define the path of the transect. To do this select the poly-line geometry tool. Using the geometry tool, click on locations to define the path of the transect.

Here we’ll define a path from the Straight of Juan de Fuca through the San Juan and Gulf islands, and up to the mouth of the Fraser River.

Extract the Points

Then right-click on the geometry to extract the points. This will create a new zone called “Extracted Points” which defines the XY coordinates to use for the transect.

Check the Grid Density

It is important to ensure that there are enough XY points to effectively capture the density of the grid. By turning on Scatter for the Extracted Points and turning on Mesh for the solution data we can see that the density of XY points is sufficient for our grid. Too many points are better than too few points, as you want to ensure you don’t skip over too many cells. This will result in a good continuous transect.

Invoke PyTecplot

Now that we have the XY points defined by the Extracted Points zone, we can invoke the PyTecplot script. To do this we must first allow PyTecplot Connections via Scripting -> PyTecplot Connections. Now you can run the VerticalTransect.py script from a command prompt. Using “python –O” will run the script in optimized mode, which will improve performance.

This script will connect to Tecplot 360, find the zone called Extracted Points and use the XY points to define a vertical surface zone through the volume, which defines the shape of the transect. The solution variables are then interpolated from the solution data onto the transect zone at each time step. This dataset has 24 timesteps with approximately 140,000 elements per timestep – this script should take about 15 seconds to run.

Animate Through Time

Now that we have the result, we can animate through time with the two frames linked together.

If you have a specific transect path, you can easily modify the script to supply a specific set of XY points.

This concludes the tutorial for computing a vertical transect in Tecplot 360.

Thank you for watching!

Try Tecplot 360 for Free

The post Computing a Vertical Transect in Tecplot 360 appeared first on Tecplot.

Learn More and Download the TecIO Library »

TecIO is the library supplied with Tecplot 360 that enables third-party applications to output solution data directly to Tecplot binary-formatted files.

It exists as two separate libraries. The original serial version of TecIO outputs either .plt or the newer .szplt format. The newer parallel version, TecIO-MPI, outputs only .szplt.

Both versions are also available in source form, which enables their use on some otherwise unsupported platforms. And in the case of TecIO-MPI, it enables support for a variety of MPI implementations.

In its serial form, TecIO has been around for a long time, and it’s starting to show its age. A few examples:

• As zone types and features have been added, the routine to create zones (now called TECZNE142) has accumulated parameters to accommodate the new features. It now has 21 parameters—a bit ungainly.
• Only 10 files may be output simultaneously, and you have to do some bookkeeping to keep track of which file you’re currently outputting to.
• Solution data must be output in sequential zone-variable order.
• Integer data types are not supported.
• 32-bit integer parameters limit the size of the zones you can output, a limitation that will become important for some customers in the next few years.

New TecIO API

To address these and other issues, Tecplot 360 2017 R2 introduced a new API (application programming interface) to TecIO, both serial and parallel versions. This new API offers many advantages over the legacy API:

• Separate routines for creating each zone type take only the parameters required for that zone type.
• The number of files you can output simultaneously is limited only by the underlying operating system.
• You can output zone variables out of order—you are not required to output all of your X variables before you can start outputting your Y variables, etc.
• You can output zones that have 8-, 16-, and 32-bit integer data.
• 64-bit integer parameters allow outputting zones whose index limits would overflow 32-bit integers.

You can see the new API at work and compare it with the old API in TecIO’s C++ example flushpartitioned.cpp. You’ll find lines such as the following, which show the old and new side-by-side:

#if defined OLD_API
returnValue = TECDAT142(&pNCells[ptn - 1], p[ptn - 1], &dIsDouble);
#else
returnValue = tecZoneVarWriteFloatValues(fileHandle, zone, 4,
ptn, pNCells[ptn - 1], p[ptn - 1]);
#endif

Fortran 90 programmers might prefer to look at the example rewriteszl.F90, which shows both reading and writing a .szplt file using TecIO’s Fortran 90 interfaces.

Please note that this new API in its current form outputs only the newer .szplt format, which is not readable by Tecplot Focus and does not (currently) support polyhedral zones. The legacy API will continue to be available until those limitations are addressed. But if .szplt works for you, please consider using the new API for your Tecplot binary file output.

As always, please contact our excellent technical support team if you have questions.

Happy Tecplotting!

Learn More and Download the TecIO Library

David E. Taflin, Ph.D.
Senior Software Engineer
Tecplot, Inc.

The post New TecIO API for Tecplot 360 .szplt Output appeared first on Tecplot.

The post AU 2018 goes convergent appeared first on Schnitger Corporation.

The post Bentley makes AIworx official, announces second deal appeared first on Schnitger Corporation.

The post Altair + Datawatch = interesting opportunities appeared first on Schnitger Corporation.

The post Quickie: Altair to acquire Datawatch for analytics appeared first on Schnitger Corporation.

The post Eek – schnitgercorp.com not secure??? appeared first on Schnitger Corporation.

The post Nemetschek’s Build offerings contribute to strong Q3 appeared first on Schnitger Corporation.