TrueGrid^® Frequently Asked Questions (FAQ's)

There are many reasons, but the two most compelling are quality and speed.

Analysis codes are complicated enough, they have many other topics other than mesh generation on which to focus their software talent. Advances in engineering mechanics such as new elements, more sophisticated contact algorithms, material models, and slicker GUIs are keeping developers busy. In addition, high quality hexahedral mesh generation on complex geometries is a difficult problem and quite different than simulation algorithms. XYZ Scientific Applications, Inc. does not author analysis codes or any other software other than TrueGrid^®. We focus only on mesh generation and are dedicated to solving difficult meshing problems. For this reason we can ensure the best quality a mesh generation software can provide.

Pre-processing is typically 80% or more of the time taken to conduct a simulation. Faster mesh generation, with no reduction (or even an increase) in mesh quality, is your best way to reduce simulation costs. Your employee's time, not the price of the software, is the real cost of generating a mesh. TrueGrid^®'s parametric batch input capability and our company's dedication to backward compatibility makes it easy to document the analysis code's input and to regenerate input files. Once all potential variations of a product's design are encoded in the TrueGrid^® input file, the user only has to enter a few parameters, run the input file and proceed immediately to the analysis.

From our perspective, a mesh generation tool must be continually developed. To successfully accomplish this, we set aside time as TrueGrid^® users to solve customer problems. This way we are better able to handle tech support issues, we can test the code, and we are better able to anticipate the needs of the user. At XYZ Scientific Applications, Inc. everyone who codes TrueGrid^® uses TrueGrid^® and this tradition is being maintained as our company continues to grow.

Yes. There are many TrueGrid^® features which allow users to work together to build a mesh.

The block boundary command enables users to easily glue two different parts together so that they have a node-for-node correspondence. One method of handling assemblies with a group of users is to first create the interfaces between the components using the block boundary feature. Then each individual working on the project must attach his or her component to the appropriate interface, guaranteeing that the parts will meet perfectly. Alternatively, if the geometry is formed initially so that everyone uses the same geometry, then it is simply a matter of concatenating the session files from each component part and then running TrueGrid^® in batch mode. Parameters statements can be used to avoid conflicts in numbering.

TrueGrid^® supports many analysis programs, including today's most popular commercial FEA and CFD analysis codes. Among them are: ABAQUS^®, ANSYS^®, AUTODYN^®, CFD-ACE^®, CFX^®, FLUENT^TM, LS-DYNA^®, MARC^®, NASTRAN^®, GRIDGEN3D, NEUTRAL file, STAR-CD, MPACT, NEK5000, STL, and TASCflow^TM. If your favorite format is not supported by TrueGrid^®, you may find that you can use the NEUTRAL file, NASTRAN, or PLOT3D format.

In addition, DOE and DOD users will enjoy the fact that we also support several of the LLNL and Sandia model formats, including ALE3D, DYNA3D, EXODUSII, NIKE3D, PLOT3D, SAMI, and TOPAZ3D.

Yes. Go to the Parametric and Scripting Page to view TrueGrid^®'s parametric capabilities.

Yes. While XYZ Scientific Applications, Inc. markets and sells TrueGrid^® in the United States and Canada, we depend on our skilled and motivated distributors to sell TrueGrid^® in other countries. Go to our Contact Page to view our list of distributors.

Primarily because others tend to copy what they see on the internet and then forget to update when the information changes. In order to obtain current pricing information, please go to our Contact Page to contact XYZ Scientific Applications, Inc. or a TrueGrid^® distributor in your region.

All CAD systems with an IGES output interface to TrueGrid^®. TrueGrid^® uses the IGES interface to CAD systems because it offers the highest quality meshes.

The 2D coordinate system in TrueGrid^® is independent of the 3D coordinate system.

If you select a solid to be interpolated or smoothed and you want the boundary faces to be smoothed as well, then you should select each of the faces for the same interpolation or smoothing. Sometimes, by interpolating or smoothing the faces, there is no need to interpolate or smooth the interior.

There is a consistent way that TrueGrid^® interpolates or smoothes part of the mesh and it is based on the dimension of the selected region.

• CASE 1 - 1 Dimension
• When an interpolation is done along an edge of the mesh, the end nodes are fixed and serve as the boundary condition for the interpolation.
• CASE 2 - 2 Dimensions
• When a face is interpolated or smoothed, the edges of the face are fixed and serve as the boundary conditions for the interior.
• CASE 3 - 3 Dimensions
• When a solid is interpolated or smoothed, the faces of the solid are fixed and serve as the boundary conditions for the interior.
• CASE 4 - Neumann boundary
• Some smoothing algorithms will move the boundary nodes to produce a near orthogonal mesh near the boundary. This makes it possible to glue several blocks together and get a smooth mesh at their interface. The disadvantage is two fold. First, this limits the shape of the mesh at the interface, which may not be ideal. Second, most implementations cause the nodes to wonder off of the surface. In TrueGrid^®, we have resisted this approach. A better solution is achieved by smoothing the two blocks together. Also, the Neumann boundary condition violates the nodal distribution conditions that TrueGrid^® works hard at preserving.

Use a text editor and modify the .tgauth file found in your TrueGrid^® directory. The second line in this file has the name of your computer in the first field between the 2 semicolons. Change this to the new name then start the License Manager.

Newer versions of WINDOWS will disconnect the ethernet card automatically when the network is disconnected. This is considered a plug-n-play feature. It makes it possible to have one ethernet card in a laptop computer and second ethernet card that is within a docking station. This is a problem for the TrueGrid^® license manager.

The best way to avoid problems is to authorize the TrueGrid^® license manager in the configuration in which TrueGrid^® will be used. If the machine is typically on the network when TrueGrid^® is being used, then the license manager should be authorized in that configuration.

Yes, TrueGrid^® is available on Linux. For the TrueGrid^® license manager to run on a Linux system, however, a hardware key (dongle) is required. Please contact us for more information on this hardware requirement.

There are several ways, depending on your situation. In all cases, it depends on having or adding a negative index in the block command.

• 1. Put shells around the block. If you start out with


• block 1 11; 1 11; 1 11; -1 1 -1 1 -1 1;


• then change to the following:


• block -1 0 2 12 0 -13;-1 0 2 12 0 -13; -1 0 2 12 0 -13;
• -1 0 -1 1 0 1 -1 0 -1 1 0 1 -1 0 -1 1 0 1

Be sure to do the same thing to the shells that are done to the solids. Alternatively, use the bb command to glue the shell to the block and the shell will follow the shape of the solid.

2. Add shells to the part. Use the insprt command and add a new shell partition before the first partition (left side) or after the last partition (right side).

3. Add a new part with just shells. Copy the commands that formed the first part and modify the block command by adding the minus sign on the indices that correspond to the shells. You may need to delete unwanted solids or undo commands that only have meaning for solids.

Use the vector option to define the orientation of the local coordinate system of the cross section of the beam. Then use the ztol command with a tolerance of around .0001 to compensate for numerical errors.

This is needed because TrueGrid^®'s internal data structure for a beam includes its orientation point (not vector). When the output file is written for ABAQUS, TrueGrid^® converts the points to vectors, and sorts them to get a unique list. This can be the source of numerical errors, and is the reason for the tolerance parameter.

The performance of TrueGrid can be improved by changing the way the model is built. Below are the key issues:

• 1. Every time a single mesh generation command is issued, the entire part must be rebuilt.


• 2. The resolution of the geometry can slow the projection algorithm.


• 3. The command insprt command causes an increased load every time the session file is re-run.


• 4. Smoothing commands (relax, unifrm, esm, tme) can be very slow, depending on the number of iterations selected.


• 5. Edges or vertices projected to the intersection of tangent surfaces are problematic. The iterative Newton method cannot work in this case and TrueGrid resorts to a primitive search algorithm to find the intersection.


• 6. Edges in a part are the most expensive calculation, except for smoothing.


• 7. If there is not enough RAM, TrueGrid^®, like any program, TrueGrid^® will have to swap memory which will have a dramatic effect on performance.

Here are some suggestions to improve the speed of TrueGrid^®.

• 1. Build smaller parts and use the BB command liberally to glue parts together.


• 2. Reduce the mesh size while building the part and then increase the mesh density after everything is completed and run the model in batch mode for the last time. Design the mesh density so that it is a half or a third the required mesh density. Then use meshscal of 2 or 3, respectively, to increase the mesh density in your final rerun.


• 3. Issue multiple commands before having TrueGrid^® draw (and consequently rebuild) the mesh.


• 4. Never issue one of the smoothing commands while in the initial stages of positioning the vertices, attaching edges, projecting faces, or other routine steps to shape the mesh. If you issue a smoothing command, then every time you enter a new command, the smoothing is recalculated. Save the smoothing for the last step in the development of the part.


• 5. The insprt command is not re-executed every time you issue a new command, so you only have to pay the price once every time you rerun. But this too can become a problem. You can avoid this by planning your part out in advance, removing the need for many insprt commands. Alternatively, once you have run the part with insprt commands, you can recreate a cleaned up version without the insprt commands by using the tghist file that is automatically generated.


• 6. The intersection of tangent surfaces must be avoided at all cost. The primary way to avoid this is to make a composite surface (sds option of the sd command) and project both faces that share the edge to the composite surface. If you need the edge to be on the intersection of the two tangent surfaces, create a 3D curve and attach the edge to the curve. This avoids the calculation of the intersection of two tangent surfaces. If it is not possible to combine the two tangent surfaces because they are not trimmed where they meet, use the curf command (instead of the default curs command) to permanently attach the edge to the curve, again avoiding the costly calculation of intersecting tangent surfaces. This discussion also applies to vertices in the part.


• 7. The positioning of nodes along an edge is the second most expensive calculation in TrueGrid^®. Only smoothing is more expensive. Usually you cannot reduce the number of edges in a part. But if you are not aware of this fact, you may inadvertently generate a part with many more edges than are needed, decreasing the efficiency.


• 8. It is usually an easy matter to increase the RAM. You should get approximately 120 bytes per nodes (32 bit system).


• 9. If you can, use the getol command of about 30 or 50 to reduce the number of polygons used to approximate the surface geometry from a CAD model. Keep in mind that once you build and use a binary IGES file (saveiges and useiges), changing the getol will not effect the existing IGES binary file. If this low resolution affects the projection quality, increase the accuracy to 3. This keeps the number of polygons that are searched for the initial projection to a minimum and then kicks in the highly accurate Newton method on the algebraic surface. This trade off of number of polygons and algebraic surface evaluations can be significant.

Create a 3D curve and attach the interior edges. Also, use transfinite interpolation (tfi) which spreads the perturbation smoothly across two regions. You have to inspect the region with the greatest distortion, then determine how to change one or more of its boundary edges to improve it without cause of serious degrading of the neighboring regions.

In regions where the aspect ratio is bad, use res or one of the other nodal distribution commands along one edge to improve the aspect ratio in one area at the expense of a poorer aspect ratio or element quality in the neighboring regions.

• 1. Change the size of the initial mesh in TrueGrid^® so that it matches the geometry without modifying the geometry. The results will be a mesh that matches the geometry. This requires scaling the coordinates in the block/cylinder command and all of the move commands (mb, mbi, pb, pbi, tr) or can be easily done with one new command (tr) if there are no insprt commands. Alternatively, a scale factor is needed and an expression in place of every number (for example 1.2 would be replaced with [1.2*%sf] where sf is the scale factor parameter).


• 2. Modify the geometry so that it matches the initial mesh used in the previous model. The result will be a mesh that is the same size as previous model, not the size of the new geometry. This is easily done by scaling the geometry when importing or creating the geometry. The transformation option sca %sf would be added at the end of the geometry import or geometry creation command where sf is the scale factor parameter.


• 3. Modify the geometry so that the initial mesh does not need to be changed. After projection to the modified geometry, scale the mesh so that it matches the size of the original geometry. The result is the same as 1 above. This is usually the easiest thing to do but is more complicated to understand. This uses the same method as in 2 with an additional command to scale the mesh after it is projected. Use the csca %sf as one of the first commands to scale the final mesh.

• 0. Block structured - Key to a good hex mesh for CFD is block structured grids. Within TrueGrid^® , one can form any size block structured meshes. The blocks can be connected to other blocks (or not). When they are connected, one can use different interpolation and smoothing features across multiple blocks to form the highest quality interfaces between blocks. Interpolation and smoothing methods can be applied to any faces or blocks (or both). If you are familiar with ICEM or Lawrence Livermore National Laboratory INGRID (these were all developed by the same developer of TrueGrid^® , prior to the development of TrueGrid^® ), then you already have a sense of the multi-block method used in TrueGrid^® .


• 1. Conformal meshing - In my opinion, this is not the best name for what it refers to. Conformal mapping would indicate that all the elements will be formed using 90 degree angles at the corners. Except for some special cases where the boundary (in 2D) is conformal can we expect a conformal mapping of the interior. For all other problems, the solution is an approximation to a conformal mapping with compromises. This natural limitation has lead to many variations of methods in the field and the literature. In TrueGrid^® , we have implemented 4 methods. They are all iterative and you control the maximum number of iterations and the tolerance (which will cause the smoothing process to terminate early if the process has converged). When dealing with CFD models with boundary layers, we recommend the Thomas-Middlecoff method. You can check out this method in the literature. I believe it was published in the mid-1980s. We have made a few minor improvements to their method. It promises to form a nearly orthogonal mesh along the boundary at the expense of orthogonality in the interior. We have gotten good results with this method. It produces (preserves) a boundary layer.
• 
  
• 2. Boundary layers - Boundary layers are formed in TrueGrid^® using several commands. One class of commands can be used to distribute the nodes along an edge with a bias. It is usually a geometric progression so that the elements are small near the boundary and grow larger as one moves further away from the boundary, but in a smooth fashion. Interior faces of blocks are the result of interpolation and smoothing methods which are at the control of the user. Similarly, blocks are interpolated as a result of the nodal position of the faces. Both interpolation and smoothing can be applied to blocks as well.


• 3. Projection method - The ramifications of the projection method in TrueGrid^® are profound. Two key points should be made with regards to CFD. First, with the projection method, you can use a IGES file for geometry without geometry clean up. This includes not having to reform the surfaces so that you have surfaces that match faces of of your block structure. This cannot be over stated. The savings in time and effort, the advantage in mesh quality, and the simplification in block topology is huge. Secondly, when an edge or face is projected to a surface, it is constrained there. Smoothing does not lift the boundary faces of a block off of the surface. This is because we are using Dirichlet boundary conditions when solving the elliptic PDE's underlying the smoothing method, not the Neumann boundary conditions typical of simpler block structured mesh generators.


• 4. Automatic verses parametric - TrueGrid^® is not automatic. It is, however, highly parametric. One can build a parametric or templet model with TrueGrid^® (and many of our advanced users have) so that one can change some of the parameters and rerun the templet file to form a new mesh. The templet file can be constructed to generate a whole class of designs or models, and for that class, TrueGrid^® is essentially an automatic hex mesh generator.

First, I will try to list the basic ways to select coordinates. They are in the manual in Volume 1, starting on page 126.

• 1. Projection (from a 3D curve or a surface)


• 2. Using the project command (coordinates are stored in automatic parameters xprj, yprj, zprj)


• 3. Z-buffer (from anything in the picture)


• 4. By node (from the mesh or a block boundary interface)


• 5. By vertex



You can choose any portion of the mesh to be attached.




You can choose any or all of the three coordinates for the attach by clicking on/off the x, y, or z check mark
in the Pick panel of the environment window.




You can also move portions of the mesh using the mouse. This is described in the manual in Volume 1,
page 148. Any selection of the mesh can be moved as a rigid body using the following options:



• 1. Rotate


• 2. Screen plane


• 3. Front view


• 4. Constrained to the x, y, z, xy, yz, or xz directions



You can assign any region of the mesh to a labeled point of a 3D curve or a surface using the pbs command.




You can attach an edge of the mesh to a 3D curve.




You can attach a face to an entire surface (with no holes and with 4 boundary edges) (both initialization and projection in one command). This is the PATRAN feature, but it is very inflexible and not recommended.




You can have a cubic spline for and edge of the mesh using the splint command. You control the shape of the edge by assigning coordinates to the vertices along the edge.




Underlying initialization features are the basic commands listed in the table of contents on page 11 of Volume 1, section 2 and 3.




I think you are going to find more answers to your question by developing techniques. For example, after a session where you have moved many vertices around, remove those commands that have no effect. The tghist file will show you which commands are deactivated. You can also remove, for example, a pb command for a vertex if there is another pb command that follows it for the same vertex.




Use the ilin command strategically to interpolate intermediate vertices, where appropriate.




Initialize several vertices to the same place, relying on projection to separate them.




Plan your part out so that you use the insprt command. It will interpolate all new vertices automatically.




When you plan ahead, you can move a group of vertices together as a rigid body using the mbi or tri command.




Keep the number of vertices you have to initialize to the smallest number possible. Know the limitations of the projection method. Use 3D curves to initialize edges so that your blocks can be larger and have large curvature.

When a command has the letter i as a suffix, it means that the portion of the mesh to be applied is identified using an "index progression".

An index progression has the advantage of selecting more that a single region. So, for example, the index progression

2 3 0 5 6;1 2;2 3 0 5 6;

selects 4 regions (note "0" means and) which are:

2 1 2 3 2 3

2 1 5 3 2 6

5 1 2 6 2 3

5 1 5 6 2 6

In each region, an interval in each of the three index directions is selected. But when you use a minus sign, you are indicating a constant (i.e. not an interval). For example,

2 3 0 5 6;-2;2 3 0 5 6;

selects 4 regions, all of which are j-faces (i.e. j is a constant 2). This selects

2 2 2 3 2 3

2 2 5 3 2 6

5 2 2 6 2 3

5 2 5 6 2 6

There is a more detailed discussion in the manual. Both regions and index progressions

are closely coupled to selections using the index bars in the computational mesh.

Use the ampersand to continue an expression.

In all other cases, you can put as many or as few arguments to a command on a single line. End of lines only have meaning in a few places. They are:

comments

titles

expressions

Also, keep in mind that the character string containing commands and arguments can be up to 256 characters.

There are two approaches, both of which depend on using a negative tolerance. A negative tolerance means that there will be no merging where ever that tolerance is applied.

Suppose part 1 has nodes to be merge.

METHOD 1:

bptol 1 2 -1

stp .001

Method 2:

ptol 1 .001

stp -1

In METHOD 1, the bptol (between part tolerance) sets a tolerance between parts 1 and 2 to be -1. This will override the default tolerance set by the stp command between these two parts. Then the stp command sets the default tolerance for all merging where bptol or ptol commands have not been set. In particular, nodes within part 1 merge using a tolerance of .001.

METHOD 2 is the compliment of METHOD 1. A tolerance for part 1 (overriding the default set by stp) merges nodes with a tolerance of .0001. Everywhere else, the tolerance is -1.

For completeness, one could also use the dummy sliding interface to block merging across the master and slave. This gives you more control but requires a little more effort. These is also a node set version of this using the bnstol so that you can control the merging between 2 node sets. However, the bnstol causes the merging algorithm to slow down.

Block boundaries have matching independent nodes where they meet. One can attach a slave side to the master side of a block boundary with a transformation applied to the slave side (or even the master side) which means the master and slave do not have coincident nodes. This is the justification that we do not automatically merge the nodes at an interface. There is another reason, one that you may not ever encounter. TrueGrid^® is also very good at building block structured CFD grids. Some codes allow for two grids to have a mismatch in mesh density typically with a ratio of 2:1 which the BB command supports. In such a case, it would be incorrect for TrueGrid^® to merge the nodes.

More generally, TrueGrid^® errors on the side of most general, requiring the user to be specific on what is wanted in the mesh. So the answer is, you need to issue the stp command.

Instead of giving the set an ASCII text name, use a number for the name. For example

nset 1 2 3 4 5 6 = 5

When this set, called "5", is written to the LSDYA file, it will be assigned the set number 5 to match its name. TrueGrid^® preserve the numerical names when it writes the LS-DYNA output file.

Now you might say that the name "5" is not descriptive. In that case, use a descriptive parameter. For example, if the set of nodes forms the bottom plate, you could use the parameter called "bottom_plate". You might issue the following commands:

para bottom_plate 5;

nset 1 2 3 4 5 6 = %bottom_plate

They are applied left to right. You can prove this to yourself by the following example:

block 1 2;1 2;1 2;-1 1 -1 1 -1 1

lct 1 rz 45 mx 10;

lrep 1;

block 1 2;1 2;1 2;-1 1 -1 1 -1 1

lct 1 mx 10 rz 45;

lrep 1;

merge

grid on

la parts

Part 1 remains on the x-axis proving that the rotation was done first.

Part 2 is on the 45 degree diagonal proving the rotation was done second.

There are many ways. The first thing to remember is that the stp command, as well as the t, and tp commands, set the default tolerance for nodes to be merged. Prior to issuing such a merge command, you can set special tolerance for difference areas in various ways. Also keep in mind that until you issue one of the merge commands (stp, tp, t) nothing will be merged. Also, you can issue one of these merge commands as often as you want until you find the right tolerance. Finally, a negative tolerance (such as -1) means no merging between nodes within the scope of the command. For example, if you used the stp command to merge (stp .001) and then used the same command with a -1 (stp -1), all nodes that were merged will no longer be merged.

Here are the different ways to set special tolerances in different areas:

i.) bptol sets a special tolerance between two parts

ii) ptol sets a special tolerance for nodes to be merged within a single part

iii) nodes with shared nodal constraints are not merged

iv) no merging is done across the master and slave side of a contact surface

v) the dummy contact surface is a contact surface in name only. Its only function is to block merging between the nodes of the master and slave side.

vi) bnstol blocks merging between two node sets (slow execution in large problems)

vii) nodes in a rigid body joint are not merged

These can be abused. If you try to use bptol everywhere, you will have a huge number of these commands. As soon as you make a change, you have to adjust this list of commands. It is much cleaner to use the bb command liberally to make sure parts meet perfectly so that one stp command with a small tolerance is all that is needed to merge the nodes for the entire model.

When you write the IGES file from your CAD system, choose trimmed surfaces as the format for the geometry. The reason is that TrueGrid^® is surface based, not solids based.

I assume that you have the two nodes that you want to use to attach the anchor. Click on the "Select First Node" in the bm menu and then "Select An Existing Node" and choose the node for the first end of the anchor. This is the N1 option. Do the same for the "Select Second Node" which is the N2 option.

The bm command can put as many elements between node N1 and N2 as you wish by using the "Number Of Beam Elements" option, nbms. You may also wish to give this string of beams a shape other than a line by using the "Interpolate Along A Curve" option, cur.

However, you may wish to have a single string of beam elements that terminates at a specific point offset from the rock, for example. And then make multiple single beam connects from the offset node to different locations on the rock. This is when you use the RT1 or RT2 option to create the offset node. This is the node that you connect to multiple nodes on the rock by creating one beam at a time with the bm command. In the creation of each of the conecting beams, you use the N1 and N2 options.

Transitions are used to reduce the mesh density in areas of least importance. It automatically forms a 2-to-4 or 1-to-3 ratio of all hexa elements between two blocks. That is, one side of a block interface can have, for example, 20 elements and the opposing side of the interface can have 10 elements. TrueGrid^® will automatically strip out a layer of elements and substitute a new layer so that the two blocks are properly connected.

In most cases, transitions are not needed. They are used to reduce the number of elements needed to form one contiguous hexa mesh. But if the mesh is not planned out carefully, one can paint themselves into a corner, so to speak, and transitions may be needed corrections due to poor planning.

There are two approaches that I would recommend. I much prefer the first.

First Approach

Project the face to the desired plane. Construct 4 additional planes where each corresponds to one of the four boundary edges of the face. Each of these four planes needs to intersect the first plane along the line that gives you the desired direction of projection. I like this method because it takes full advantage of the projection method.

Second Approach

Use the spp command "by direction". This feature is a little tricky. You need to make a template first to establish a pattern for the projection. I think this approach is overkill.

Usually, a scanner produces more than a point cloud. Usually the data is ordered in rows and columns. If this is the case, you can import each data set as a mesh surface. If you have an STL file, you can import it as an STL surface. There are other ways to import a polygon surface into TrueGrid^® , but I am guessing that if you have a polygon data set, it will be in one of these two formats.

If your data is truely a point cloud with no structure, then you need a specialize software to construct a polygon surface from the points cloud.

All surface types in TrueGrid^® work the same within TrueGrid^® . There are no special cases. As soon as you learn the basics of TrueGrid^® you will know how to use these surfaces to build a mesh.

A special note: You may have many surfaces created by the scanner. In this case you will probably want to use composite surfaces in TrueGrid^® . It is simple in TrueGrid^® to form a composite surface from a collection of smaller surfaces. On the other hand, if you have a STL file, it may be only one surface with many features. This can be awkward because you will not be able to take advantage of some of TrueGrid^®'s powerful features. In this case you may wish to break the large STL surface into smaller surfaces along feature lines. This is also possible within TrueGrid^® .

The f4 (function key 4) will save the current setup. I suggest you apply it during the part phase to make sure all the windows are in place.

You could create a surface, use it to select all nodes close to it. Then apply the constraint to that set, all in the merge phase.

I will explain a technique to remember. Once you get the idea, then you can select objects of similar complexity using the index bars in the computation window. You will notice that there is a direct correspondence between what is called an index progression and what you can select using the index bars.

STEP 1: select a volume region that is contained within the faces you wish to select. For example, if you want to select the two i-faces at reduced index i=2 and reduced index i=4, then you would select the interval in the i-index bar from i=2 through i=4. That is done with a click and drag of the mouse along the i-index bar from node 2 through to node 4.

STEP 2 & 3: do the same for the j and k-index bars, as needed. Note that if you do not select something within an index bar, it is interpreted as though you had selected the entire index bar.

STEP 4: You now can select any faces contained within this solid. Select a face by clicking on that face's associated node in the index bar. For example, click on the 2nd node along the i-index bar and the 4th node along the i-index bar.

STEP 5 & 6: Do the same for the j-index bar for any j-faces and along the k-index bar for any k-faces.

Edges and vertices have some special rules - no need to complicate things at this stage.

A complete description of this is found in the TrueGrid^®? manual (with examples).

Use the TrueGrid^® Controls program to set the working directory.

For Windows 7 and earlier found with the start button:

=> => < XYZ Scientific Applications> => "TrueGrid Controls"

For Windows:

"TrueGrid Controls" is found in the XYZ Scientific Applications program group.

You might wish to increase your memory (Megabytes of Memory box) as well.

The accuracy command changes the tolerance in the Newton method for projection. For example, use

accuracy 10

which means there is an increase of the maximum number of iterations by a factor of 10 and the tolerance is decreased by a factor of 10.

However, if you are only projecting to a plane (i.e. no other surface is also being projected to - no iterative Newton method is invoked) then the projection to the plane is a one step projection and increasing the accuracy will not help.

The precision of the computer can be the issue in this case. A 32 bit version of TrueGrid^® (which is usually run a 32 bit system) only has 7 digits of accuracy. Projections usually require a square root and a divide, which introduces numerical error in several digits. It is more complicated than that, but this is sufficient to understand the issues. If you have a point , for example, that is 1000 units from the origin, then you already consume the first 3 digits before any projection is made. Of these 7 digits, there are only 2 left for precision calculations.

If you have a 64 bit system and you are running tgd, then you have more precision and the accuracy command gives you more accuracy.

There are 3 ways to set the thickness of a shell element:

1. set the default thickness with thic

2. use the th/thi command to override the default thickness for a region of the mesh

3. set the thickness in the material definition using the lsdymats command

Some people are cautious and use only one block in each part. This is not taking advantage of the power of TrueGrid^® to build parts consisting of many blocks, most of which are connected. This is a great simplification because one does not have to spend much time getting the interface between parts to match.

Because there is this great savings in effort when building a part with many blocks, some people try to build a model with just one part. This too can be impractical.

You will get best results when you build parts with as many blocks as you feel conformable building. Then use the bb command to force the unconnected faces of blocks to match.

In case you may think that the bb command is equivalent to merging, you should know that it is not the same. The bb command moves the slave side of the interface to match the coordinates of the master side. They are still distinct nodes on both sides of the interface.

You must be in the merge phase in order to merge nodes. If you issue another merge command (such as the stp command) in the merge phase, you cause the previous merging to be undone before the new merge is executed. So merging before the model is completed usually does not help. I will frequently go to the merge phase while the model is only partially completed to check if I have build the parts so that they merge. There are numerous ways to check the places where the parts merged or did not merge. In other words I am checking my work at different stages of the construction. So there is a good reason to merge at different stages, but not for the reason that you stated.

ZTOL tolerance

For example, suppose the master side is an i-edge of the mesh starting at full index node 1 and ending at full index node 11. This is an edge along 10 elements.

Now suppose the slave side edge starts at full index 5 and ends at full index 14. This is an edge along 9 elements. There is no way to form a 1 to 1 correspondence between the nodes along the master and the slave edge.

The easiest way to correct the problem is outlined below.

1. put an interrupt command after the bb command for the slave side

2. run in batch mode and when it becomes interactive, the warning

3. for more information, execute the bbinfo command.

4. use lmseq command to add/subtract elements to/from the slave part so that the two sides are compatible.

Use the MOF command.

There are three primary advantages to using the projection method in building block structured hexa meshes. The advantages are all related to the inherent limitations in CAD geometry. A typical 3D CAD model has 3D curves and surfaces or solids consisting of 3D surfaces. A single surface is usually not convenient for such a mesh. So the first advantage is that multiple surfaces can be combined to form one face of a block structure. These surfaces that form a composite usually do not meet perfectly. The second advantage of the projection method deals with these imperfections in composites. The third advantage of the projection method is when an block mesh edge needs to be at the intersection of two surfaces which do not meet properly.

When a node is projected to a composite surface, first it is projected to each individual surface. Then the projection that is closest is chosen as the projection point. It will always project to a point on one of the surfaces.

If you project two faces with a common edge onto two different surfaces (respectively) that almost intersect, then TrueGrid^® will place the edge nodes along the intersection of the tangential extension of the two surfaces.

Most mesh generators require that the CAD geometry be cleaned up or healed before it can be used. A lot of time and money can be spent in this process. TrueGrid^® automatically compensates for these imperfections so that the clean up process can skipped.

There are four variations of the curve attachment function. The commands are: cur, curs, cure, and curf. The default is curs.

CURS: The default is curs. This moves all vertices to their closest points on the curve. Then the interior nodes are placed along the curve between their respective end points. For example, if you have an edge to be attached to a curve and this edge has three vertices (i.e. both end nodes and one vertex in the interior) then all three vertices would be moved to their closest point w.r.t. the curve. To be more specific, you might issue the command:

curs 2 3 4 2 5 4 17

which has three vertices along the j-edge at reduced indices 2,3,4 & 2 4 4 & 2 5 4.

CUR: Cur moves the two end nodes of the edge to the closest points on the curve, respectively and evenly distributes the nodes between the two end vertices. Any intermediate vertices are treated the same as interior nodes of the edge.

CURE: This command places the two end nodes to the endpoints of the curve and evenly distributes the nodes between the two end vertices. Any intermediate vertices are treated the same as interior nodes of the edge.

CURF: Curf moves the two end nodes of the edge to the closest points on the curve, respectively and evenly distributes the nodes between the two end vertices. Any intermediate vertices are treated the same as interior nodes of the edge. These nodes are then frozen. In other words interpolations, smoothing, and projections of these nodes will have no effect.

Not directly. You have two options:

Option 1. Encapsulate the part into a separate file. Do not have an endpart in this file. In your main file:

a. Include the encapsulated file using the include command.

b. Use the lct and lrep command to transform the part with just one transformation.

c. Issue and additional commands unique to this instance of the part.

d. Then end the part.

Repeat a thru d for each instance of the replication.

Option 2. Use the set commands and/or the interactive set feature in the Pick Panel of the environment window to create node, face, or element sets. Then assign conditions/properties to these sets. Note that this is not parametric. If you change the mesh, you will have to remake the sets (sometimes).

This is done with two commands. First establish a local coordinate system using the lsys command. Then apply a constraint on the node within this local coordinate system using the lb command.

TrueGrid^® uses the numbers you specify in the cylinder command as the angles for interpolation. So, for example, if you set the radius and angle on one end of an edge to (80,-15) and the other end to (60,165) and then ask TrueGrid^® to interpolate a node between then, you will get the point at (70,75). This is placed perfectly between the two endpoints, in the polar coordinate system.

In most meshes using the cylinder command, you must keep all angular coordinates within a period that is 360 degrees wide. You need to also choose the minimum angle of the period wisely so that you do not attempt to interpolate from the maximum to the minimum angle of your period. The cylinder part is not a general purpose part like the block part. There are certain parts or geometry that are ideally suited to be interpolated in cylindrical coordinates. This feature in TrueGrid^® makes it easy, for example, to create a helix. But for most meshes, the block part is best.