This is gid.info, produced by Makeinfo version 3.12h from gid.texinfo. This is the GiD manual Copyright 1997-2002 CIMNE  File: gid.info, Node: Top, Next: Introduction, Prev: (dir), Up: (dir) TO USE THIS HELP: -Pick with left mouse button on colored item to go into it. -Use letters `p, n, u, l' as shortcuts for previous, next, up, last. -Use arrows `up' and `down' to go up and down in the page. -Use `Control-s' to make an incremental search. * Menu: * Introduction:: * GiD basics:: * Invoking GiD:: * User interface:: * User basics:: * Files:: Pre-processing * Geometry:: * Data:: * Meshing:: * View:: * Utilities:: * Calculate:: Solving * POSTPROCESS OPTIONS:: * postprocessing results:: * Customization:: Customization * POSTPROCESS DATA FILES:: * TCL-TK extension:: Tcl-TK * Index:: --- The Detailed Node Listing --- INTRODUCTION * Using this manual:: USER INTERFACE * Mouse operations:: * Command line:: USER BASICS * Point definition:: * Entities selection:: * Quit:: * Escape:: Point definition * Picking in the graphical window:: * Entering points by coordinates:: * Selecting an existing point:: * Button Base:: * Option point in line:: * Option point in surface:: * Option tangent in line:: * Option normal in surface:: * Option Arc center:: Entering points by coordinates * Local/global coordinates:: * Cylindrical coordinates:: * Spherical coordinates:: FILES * New:: * Open:: * Save:: * Save as:: * Import:: * Export:: * About:: * Print to file:: * Read image:: Import * IGES read:: * DXF read :: * Parasolid read:: * ACIS read:: * VDA read:: * NASTRAN read:: * STL mesh read:: * Mesh read:: * Read surface mesh:: * Batch file:: * Insert geometry:: Export * IGES write:: * DXF write:: * GiD mesh:: * Text data report:: * Save ASCII project:: * Save ON layers:: * Calculation file:: * Using template:: GEOMETRY * View geometry:: * Create:: * Delete:: * Edit:: Create * Point creation:: * Line creation:: * Arc creation:: * Arc tangents:: * NURBS line creation:: * Polyline creation:: * Parametric line:: * Planar surface creation:: * 4-sided surface creation:: * 4-sided surface automatic creation:: * NURBS surface creation:: * Volume creation:: * Contact creation:: * Intersection:: * Volume boolean operations:: * Surface boolean operations:: * Object:: Volume creation * Automatic 6-sided volumes:: Intersection * Intersection line-line:: * Intersection multiple lines:: * Intersection Surface 2 points:: * Intersection Surface lines:: * Intersection Surface surface:: * Intersection Multiple surfaces:: Edit * Move point:: * Explode polyline:: * Edit polyline:: * Edit NURBS line:: * Edit NURBS surface:: * Hole NURBS surface:: * Divide:: * Join lines end points:: * Swap arcs:: * Edit SurfMesh:: * Convert to NURBS:: * Simplify NURBS:: DATA * Problem type:: * Transform problem type:: * Conditions:: * Materials:: * Problem data:: * Intervals:: * Interval data:: * Local axes:: Conditions * Assign condition:: * Draw condition:: * Unassign condition:: Materials * Assign material:: * Draw material:: * Unassign material:: * New material:: * Import/Export material:: MESHING * Generate:: * Mesh view:: * View boundaries:: * Assign unstruct sizes:: * Draw Sizes :: * Structured mesh:: * Structured concentrate:: * Mesh criteria:: * Element type:: * Quadratic:: * Reset mesh data:: * Cancel mesh:: * Mesh quality:: * Edit mesh:: Edit mesh * Move node:: * Delete elements:: * Delete lonely nodes:: VIEW * Zoom:: * Rotate:: * Pan:: * Redraw:: * Render:: * Label:: * Entities:: * Layers:: * Multiple windows:: * Save/Read View:: Rotate * Rotate screen axes:: * Rotate object axes:: * Rotate trackball:: * Rotate angle:: * Rotate points:: * Rotate center:: * Rotate original view:: UTILITIES * Preferences:: * Renumber:: * Calculator:: * Id:: * Signal:: * List:: * Status:: * Distance:: * Draw line normals:: * Draw surface normals:: * Copy:: * Move:: * Repair:: * Collapse:: * Uncollapse:: * Undo:: * Comments:: * Graphical:: * Coordinates window:: * Read batch window:: * Clip planes:: * Save configuration file:: * Perspective:: * Change Light Vector:: * Default background:: * Macros window:: * Selection window:: * Animate controls:: * Dimensions:: POSTPROCESS OPTIONS * introduction - postprocess:: * files - postprocess:: * utilities - postprocess:: * Point and Line options:: * Display Style:: * Textures:: * Cover mesh:: POSTPROCESSING RESULTS * Contour Fill:: * Contour Ranges:: * Contour Lines:: * Show Minimum and Maximum:: * Display vectors:: * Iso Surface:: * Stream Lines:: * Line Diagrams:: * Legends:: * Graphs:: * Deform Mesh:: * Do Cuts:: * Animation:: * Automatic comments:: * Several results:: POSTPROCESSING RESULTS * Contour Fill:: * Contour Lines:: * Show Minimum and Maximum:: * Display vectors:: * Iso Surface:: * Stream Lines:: * Line Diagrams:: * Legends:: Graphs * Graph Lines Description:: * Graph Lines Options:: * Graph Lines File Format:: CUSTOMIZATION * Introduction - ProblemType:: * Configuration Files:: * Template File:: * Executing an external program:: Configuration Files * Conditions file:: * Materials file:: * Problem and intervals data file:: * Conditions symbols file :: * Unit System file:: * Special fields:: Conditions file (.cnd) * Example Conditions File creation :: Materials file (.mat) * Example Materials File creation :: Problem and intervals data file (.prb) * Example Problem and intervals data file creation:: Conditions symbols file (.sim) * Example Symbols File creation :: Template File * General description:: * Commands used in the .bas file:: * Detailed example:: Commands used in the .bas file * Single value return commands:: * Multiple values return commands:: * Specific commands:: Executing an external program * Commands accepted by the GiD command.exe:: * showing feedback when runing the solver:: * Managing errors :: * Shell script examples:: POSTPROCESS DATA FILES * File ProjectName.flavia.msh:: * File ProjectName.flavia.res:: * old results format:: * old mesh format:: New postprocess mesh format - File ProjectName.flavia.msh * Mesh example:: New postprocess results format - File ProjectName.flavia.res * Gauss Points:: * Result Range Table:: * Result Block:: * Results example:: Old postprocess results format * Gauss Points - Old format:: Old postprocess mesh format * File ProjectName.flavia.msh old:: * File ProjectName.flavia.bon old:: * File ProjectName.flavia.dat old:: Old format - File ProjectName.flavia.bon TCL-TK EXTENSION * Control functions:: * Managing menus:: * HTML support:: * GiD version:: * Using EXEC in GiD:: * Detailed example - TCL-TK extension creation:: Control functions * process function:: * info function:: CN $Revision: 1.129 $ April 2002  File: gid.info, Node: Introduction, Next: GiD basics, Prev: Top, Up: Top INTRODUCTION ************ GiD is an interactive graphical user interface that is used for the definition, preparation and visualization of all the data related to a numerical simulation. This data includes the definition of the geometry, materials, conditions, solution information and other parameters. The program can also generate a mesh for finite element, finite volume or finite difference analysis and write the information for a numerical simulation program in its correct format. It is also possible to run the numerical simulation from within GiD and to visualize the results from the analysis. GiD can be customized and configured by users so that the data required for their own solver modules may be generated.These solver modules may then be included within the GiD software system. The program works, when defining the geometry, similar to a CAD (Computer Aided Design) system but with some differences. The most important one is that the geometry is constructed in a hierarchical mode. This means that an entity of higher level (dimension) is constructed over entities of lower level; two adjacent entities will then share the same lower level entity. All materials, conditions and solution parameters can also be defined on the geometry without the user having any knowledge of the mesh: the meshing is done once the problem has been fully defined. The advantages of doing this are that, using associative data structures, modifications can be made to the geometry and all other information will automatically be updated and ready for the analysis run. Full graphic visualization of the geometry, mesh and conditions is available for comprehensive checking of the model before the analysis run is started. More comprehensive graphic visualization features are provided to evaluate the solution results after the analysis run. This post-processing user interface is also customizable depending on the analysis type and the results provided. A query window appears for some confirmations or selections. This feature is also extended to the end of a session, when GiD prompts the user to save the changes, even when the normal ending has been superseded by closing the main window from the Window Manager, or in most cases with incorrect exits. * Menu: * Using this manual::  File: gid.info, Node: Using this manual, Prev: Introduction, Up: Introduction Using this manual ================= This manual has been split into five clearly differentiated parts. It consists of a first part, General aspects, where the user can find the program from basics. This helps gain confidence on how to get the maximum from the interactive actions between users and the system. The second part, Pre-processing, describes the pre-processing functionality. The users will learn how to configure a project, define all its parts, geometry, data and mesh. The third part, Analysis, is related to the calculation process. Although it will be performed by an independent solver, it forms part of the integrated GiD system in the sense that the analysis can be run from inside GiD. The fourth part, Post-processing, emphasizes aspects related to the visualization of the results. The fifth part, Customization, explains how to customize the users own files to be able to introduce and run different solver modules according to their own requirements. Different kinds of fonts are used to help the users follow all the possibilities offered by the code: 1. `font' is used for the options found in the menus and windows. 2. `font' is used for the windows names used in the post-processing. 3. font is used for special references in some parts. Sections are referenced throughout the manual with the section number, section name given in square brackets as [section] and the page number.  File: gid.info, Node: GiD basics, Next: Invoking GiD, Prev: Introduction, Up: Top GiD BASICS ********** GiD is a geometrical system in the sense that, having defined the geometry, all the attributes and conditions (i.e., material assignments, loading, conditions, etc.) are applied to the geometry without any reference or knowledge of a mesh. Only once everything is defined, is the meshing of the geometrical domain carried out. This methodology facilitates alterations to the geometry while maintaining the attributes and conditions definitions. Alterations to the attributes or conditions can simultaneously be made without the need of reassigning to the geometry. New meshes can also be generated if necessary and all the information will be automatically assigned correctly. GiD also provides the option of defining attributes and conditions directly on the mesh once this has been generated. However, if the mesh is regenerated, it is not possible to maintain these definitions and therefore all attributes and conditions must be then redefined. In general, the complete solution process can be defined as: 1. define geometry - points, lines, surfaces, volumes. * use other facilities. * import geometry from CAD. 2. define attributes and conditions. 3. generate mesh. 4. carry out simulation. 5. view results. Depending upon the results in step (5) it may be necessary to return to one of the steps (1), (2) or (3) to make alterations and rerun the simulations. Building a geometrical domain in GiD is based on the following four geometrical levels of entities: points, lines, surfaces and volumes. Entities of higher level are constructed over entities of lower level; two adjacent entities can therefore share the same level entity. A few examples are given: * example 1: One line has two lower level entities (points), each of them at an extreme of the line. If two lines are sharing one extreme, they are really sharing the same point, which is a unique entity. * example 2: When creating a new line, what is being really created is a line plus two points or a line with existing points created previously. * example 3: When creating a volume, this is created over a set of existing surfaces which are joined to each other by common lines. The lines are, in turn, joined to each other by common points. All domains are considered in 3-dimensional space but if there is no variation in the third coordinate (into the screen) the geometry is assumed to be 2-dimensional for analysis and results visualization purposes. Thus, to build a geometry with GiD, the users must first define points, join these together to form lines, create closed surfaces from the lines and define closed volumes for the surfaces. Many other facilities are provided for creating the geometrical domain; these include: copying, moving points, automatic surface creation, etc. The geometrical domain can be created in a series of layers where each one is a separate part of the geometry. Any geometrical entity (points, lines, surfaces or volumes) can belong to a particular layer. It is then possible to view and manipulate some layers and not others. The main purpose of the use of layers is to offer a visualization and selection tool, but they are not used in the analysis. An example of the use of layers might be a chair where the four legs, seat, backrest and side arms are the different layers. GiD has the option of importing a geometry or a mesh that has been created by a CAD program outside GiD. At present, this can be done via a DXF, IGES,VDA,STL or NASTRAN interfaces available inside GiD. Attributes and conditions are applied to the geometrical entities (points, lines, surfaces and volumes) using the data input menus. These menus are specific to the particular solver that will be utilized for the simulation and, therefore, the solver needs to be defined before attributes are defined. The form of these menus can also be configured for the user's own solver module, as explained below and later in this manual. Once the geometry and attributes have been defined, the mesh can be generated using the mesh generation tools supplied within the system. Structured and unstructured meshes containing triangular and quadrilateral surface meshes or tetrahedral and hexahedral volume meshes may be generated. The automatic mesh generation facility utilizes a background mesh concept for which the users are required to supply a minimum number of parameters. Simulations are carried out from within GiD by using the calculate menu. Indeed, specific solvers require specific data that must have been prepared previously. A number of solvers may be incorporated together with the correct pre-processing interfaces. The final stage of graphic visualization is flexible in order to allow the users to critically evaluate the results quickly and easily. The menu items are generally determined by the results supplied by the solver module. This not only reduces the amount of information stored but also allows a certain degree of user customization. One of the major strengths of GiD is the ability for the users to define and configure their own graphic user interface within GiD. This is done by the users, defining first, via use of graphic windows, the format for the data definition windows for pre-processing. The format that GiD must use to write a file containing the necessary data in order to run the numerical simulation program must also be defined in a similar way. This pre-processor or data input interface will thus be tailored specifically for the users simulation program, but using the facilities and functionality of the GiD system. The user's simulation program can then be included within GiD so that it may be run utilizing the calculate menu option. The third step consists of writing an interface program that provides the results information in the format required by the GiD graphic visualizer, thereby configuring the post-processing menus. This post analysis interface may be included fully into the GiD system so that it runs automatically once the simulation run has terminated. Details on this configuration can be found in Chapters 16 and 17.  File: gid.info, Node: Invoking GiD, Next: User interface, Prev: GiD basics, Up: Top INVOKING GiD ************ When starting the GiD program from a shell or script it is possible to supply some options in the same command line. With gid -help the program will list the possible command line options. The standard UNIX command is used: gid [-b[{+/-}g][{+/-}i][{+/-}w] batch_file] [-h] [-p problem] [-e anything] [-n] [-n2] [-c] All options and `filename' are optional. `filename' is the name of a problem to be opened (extension `.gid' is optional) Options are: * -b batchfile executes `batch_file' as a script file (*note Batch file::.). · +/- g Enable/Disable Graphics (if -g, GiD doesn't redraw until the batch file has finished.) · +/- i Enable/Disable GraphInput (enable or disable peripherals while the batch file is being executed: mouse, keyboard, ...) · +/- w Enable/Disable Windows (GiD displays, or not, windows which require interaction with the user) * -h shows GiD's command line arguments. * -p problem loads `problem' as the type of the problem to be used for a new project. * -e anything can continue until the end of the line. Execute `anything' as if it were a group of commands entered into GiD. * -n runs the program without any window. It is most useful when used with the option `batchfile'. * -n2 runs the program without any window but theTk library is loaded. This option is useful if in you use TCL commands in a batch file. * -c conffile Takes window configuration from `conffile'. This file can be generated with option *Note Save configuration file::. * -openglconfig ( Only for Windows): this allows the user to choose between the accelerated OpenGL, if present, or the generic implementation, if the user experiences troubles using the accelerated libraries of the graphic card. Other useful options are: gid -compress [ -123456789ad] file_name_in file_name_out to compress a file, for instance to compress '`.dat'' files or new posprocess formated data files. and gid [ -PostBinaryFormat { 1.0 / 1.1}] -PostResultsToBinary file_in file_out to compress Ascii results files into compressed binary ones. You can select wether to use the binary format 1.0 or 1.1. The default, and recommended, is the 1.1.  File: gid.info, Node: User interface, Next: User basics, Prev: Invoking GiD, Up: Top USER INTERFACE ************** The user interface allows the GiD user to interact with the program. It is composed of buttons, windows, icons, menus, text entries and graphical output of certain information. The interface can be configured by the user who may use as many menus and windows as required for its application. The initial layout of GiD is composed of a large graphical area, pull down menus at the top, click on menus on the right side, a command line at the bottom left and a message window above it. The project that is being run is written on the window header. The pull down menus and the click on menus are utilized for fast accessing to the GiD commands. Some of them offer a shortcut for an easier access, which is activated by clicking at the same time the keys `Control' and the letter that is displayed. The right mouse button pressed over the graphical area, opens an on-screen menu with some visualization options. To select one of them, use the left or right button; to quit, select the left button anywhere outside the menu. First option in this menu is called `Contextual'. It will give different options related to the current function that is being used. The pair of icon bars contain some facilities that also appear on the graphical area of the window or on the menu bar. When clicking on the icon with the left mouse button, the corresponding command is performed or a icon menu with several options will be shown. Whilst when clicking the right (or center, when this exists) mouse button, a menu with the options `help' and `configure toolbars' will appear allowing the user to get a description of the icon or to configure the position of the toolbars. The description apperas also when the mouse remains quiet for a couple os seconds inside the icon. To configure the toolbars position and view, the Toolbars position window can be called from `Utilities' > `Graphical' > `Toolbars' or clicking with the right mouse button over a toolbar. Using the Toolbars position window it is possible to enable the Right buttons menu. These buttons should be used only by advanced users. The Standard bar has common options for both pre and post-processing parts like open, take a snapshot, print, preferences, help, exit and others. *Notes:* If windows are used to enter the data, it is generally necessary to accept this data before closing the window. If this is not done, the data will not be changed. Usually, commands and operations are invoked by using the menus or mouse, but all the information can be typed into the command line. In Windows95/NT the secondary windows appear generally in top of the main window and cannot be hiiden behind it. This mode can be changed deselecting the `Always on top' flag in the Window system menu (press second button over the windows bar to achieve it). * Menu: * Mouse operations:: * Command line::  File: gid.info, Node: Mouse operations, Next: Command line, Prev: User interface, Up: User interface Mouse operations ================ The left mouse button is also used to make selections, selecting entities or opening a box (*note Entities selection::.) and to enter points in the plane z=0 (*note Point definition::.). The middle mouse button is equivalent to `escape' (*note Escape::.). The right mouse button opens an on-screen menu with some visualization options. To select one of them, use the left or right button; to quit, select the left button anywhere outside the menu. First option in this menu is called `Contextual'. It will give different options related to the current function that is being used. When the mouse is moved to different windows, depending on the situations, different cursor shapes and colors will appear on the screen. In some windows, help is achieved pressing button-2 or button-3 over one icon.  File: gid.info, Node: Command line, Prev: Mouse operations, Up: User interface Command line ============ All commands may be entered via the command line by typing the full name or only part of it (long enough to avoid confusion); case is not significant. Any command within the right side menu can be entered by the name given there or by a part of it. Special commands are also available for viewing (zoom, rotation and so on) and these can be typed or used at any time when working or from within another function. A list of these special commands is given in `View' (*note View::.). Commands entered by typing are word oriented. This means that the same operation is achieved if one writes the entire command and then presses `enter' or if one writes a part of it, presses `enter' and then writes the rest. All these typed commands can be retrieved with the use of the up (to recover) and down arrows (to come back).  File: gid.info, Node: User basics, Next: Files, Prev: User interface, Up: Top USER BASICS *********** The following features are essential to the effective use of the GiD system. They are, therefore, described apart from the pre-processing facilities section. * Menu: * Point definition:: * Entities selection:: * Quit:: * Escape::  File: gid.info, Node: Point definition, Next: Entities selection, Prev: User basics, Up: User basics Point definition ================ Many functions inside GiD need the definition of a point to be given by the user. Points are the lowest level of geometrical entity and, therefore the most commonly used. It is, consequently, important that the user has a thorough understanding of their definition and uses. Sometimes an existing point is required and sometimes a new or an old point must be defined. All the options explained in this section are available through the specific window of Points Definition (*note Coordinates window::.). This window is accessed via the options `Utilities' and `Graphical' in the title's bar. In doing so, the user can choose not only the kind of reference system, cartesian, cylindrical or spherical, but also the system to be used, global or local and if the origin of coordinates is fixed or relative (new coordinates are referred to the last entered origin point). * Menu: * Picking in the graphical window:: * Entering points by coordinates:: * Selecting an existing point:: * Button Base:: * Option point in line:: * Option point in surface:: * Option tangent in line:: * Option normal in surface:: * Option Arc center::  File: gid.info, Node: Picking in the graphical window, Next: Entering points by coordinates, Prev: Point definition, Up: Point definition Picking in the graphical window ------------------------------- Points are picked in the graphics window in the plane z=0 according to the coordinates viewed in the window. Depending on the activated preferences (*note Preferences::.), if the user selects a region located in the vicinity of an existing point, GiD asks whether it should create a new point or if it should use the existing one.  File: gid.info, Node: Entering points by coordinates, Next: Selecting an existing point, Prev: Picking in the graphical window, Up: Point definition Entering points by coordinates ------------------------------ GiD offers a window for entering points in order to easily create geometries, defining fixed or relative coordinates as well as different reference systems, cartesian, cylindrical or spherical. Coordinates of the point can be entered either in the `enter points' window or in the command line by following one of two possible formats: 1. In the format: `x,y,z' 2. In the format: `x y z' Coordinate z can be omitted in both cases. The following are valid examples of point definitions: 5.2,1.0 5.2,1 8 9 2 8 9,2 All the points coordinates can be entered as local or global and through different reference systems in addition to the cartesian one. * Menu: * Local/global coordinates:: * Cylindrical coordinates:: * Spherical coordinates::  File: gid.info, Node: Local/global coordinates, Next: Cylindrical coordinates, Prev: Entering points by coordinates, Up: Entering points by coordinates Local/global coordinates ........................ Local coordinates are always considered relative to the last point that was used, created or selected. It is possible to use the commands `Utilities' and `Id' in order to make a reference to one point (*note Id::.). Then, to define points using local coordinates referring to the same point, use `Options' and `Fixed Relative' when entering each point. The last point selected or created before using this will be the origin of the local coordinate system. It is also possible to enter this central point by its coordinates. The following are valid examples of defining points using local coordinates: example (1): 1,0,0 @2,1,0 (actual coordinates 3,1,0) @0,3,0 (actual coordinates 3,4,0) 2,2,2 @1,0,3 (actual coordinates 3,2,5) example (2): 1,0,0 Fixed Relative (when creating the point) @2,1,0 (actual coordinates 3,1,0) @0,3,0 (actual coordinates 1,3,0) 2,2,2 @1,0,3 (actual coordinates 2,0,3) example (3): 'local_axes_name'2.3,-4.5,0.0 The last example shows how to enter a point from a local coordinate system called `'local_axes_name'' (any name inside the quotation marks will fit), previously defined via the option `define local axes' (*note Local axes::.). All the examples have been presented using a cartesian notation. However, cylindrical or spherical coordinates can also be used.  File: gid.info, Node: Cylindrical coordinates, Next: Spherical coordinates, Prev: Local/global coordinates, Up: Entering points by coordinates Cylindrical coordinates ....................... Cylindrical coordinates can be entered as: `r Variables. *Caution:* Use only `Fast Selection' when needing to select a large amount of entities, for example in a large mesh. The possibility of repeating entities within the selection is dangerous. Entities belonging to frozen layers (*note Layers::.) are not taken into account in the selection. Entities belonging to OFF layers cannot be selected directly in the graphical window, but can be selected by giving its number or giving a range of numbers. It is possible to add filters to the selection that, after selecting some entities, only remains selected the ones that accomplish with the filter criteria. To enter one filter write in the command line the word `filter:' and one option. Options are: * HigherEntity * MinLength * MaxLength * EntityType * BadMinAngle * BadMaxAngle Note: To apply selection filters you can also use the Selection window (*note Selection window::.). *Note:* MinLength and MaxLength can be used either in the geometry lines or in elements of the mesh. Example: filter:HigherEntity=1 Means that only the entities that have higher entity equal to one will be selected.  File: gid.info, Node: Quit, Next: Escape, Prev: Entities selection, Up: User basics Quit ==== Command `Quit' is used to finish the working session. If there were changes since the last time a session was saved, GiD asks the user to save them.  File: gid.info, Node: Escape, Prev: Quit, Up: User basics Escape ====== The command `escape' is used for moving up a level within the right side column menus, for finishing most commands, or for finishing selections and other utilities. This command can be applied by: 1. Middle button of the mouse. 2. Key `ESC'. 3. Button `escape' in the right side commands menu. 4. Writing the reserved word `escape' in the command line. This is useful in scripts (*note Batch file::.). All above options give the same result. *Caution:* `escape' is a reserved word. It cannot be used in any other context.  File: gid.info, Node: Files, Next: Geometry, Prev: User basics, Up: Top FILES ***** GiD includes the usual ways of saving and reading saved information (`Save', `Read') and other file capabilities, such as importing external files, saving in other formats and so on. * Menu: * New:: * Open:: * Save:: * Save as:: * Import:: * Export:: * About:: * Print to file:: * Read image::  File: gid.info, Node: New, Next: Open, Prev: Files, Up: Files New === `New' opens a new project with no title assigned. If this option is chosen from inside a project where some changes have been introduced, GiD asks to save them before entering the new project. Next, a new problem without a title is begun.  File: gid.info, Node: Open, Next: Save, Prev: New, Up: Files Open ==== With this command, a project previously saved with `Save' (*note Save::.) or with `Save ASCII project' (*note Save ASCII project::.) can be open. Generally, there is no difference between using a project name with the `.gid' extension or without it.  File: gid.info, Node: Save, Next: Save as, Prev: Open, Up: Files Save ==== `Save' a project is the way of saving all the information relative to the project: geometry, conditions, materials, mesh, etc. onto the disk. To save a project, GiD creates a directory with its name and extension `.gid'. Some files are written into this directory containing all the information. Some of these files are binary and others are ASCII. The user can then work with this project directory as if it were a file. User doesn't need to write the `.gid' extension because it will be automatically added to the directory name. *Caution:* Be careful if changing some files manually into the `Project.gid' directory. If done in this way, some information may be corrupted. *Advice:* It is advisable to save often to prevent losing information.  File: gid.info, Node: Save as, Next: Import, Prev: Save, Up: Files Save as ======= With this command, GiD allows the user to save the current project with another name. When it is selected, an auxiliary window appears with all the existing projects and directories to facilitate the introduction of the project's new name and directory.  File: gid.info, Node: Import, Next: Export, Prev: Save as, Up: Files Import ====== * Menu: * IGES read:: * DXF read :: * Parasolid read:: * ACIS read:: * VDA read:: * NASTRAN read:: * STL mesh read:: * Mesh read:: * Read surface mesh:: * Batch file:: * Insert geometry::  File: gid.info, Node: IGES read, Next: DXF read, Prev: Import, Up: Import IGES ---- With this option it is possible to read a file in IGES format, version 5.1. GiD can incorporate files in IGES version 5.1 format, incorporating most parts of the currently recognized entities. Entity number and type Notes 100 Circular arc 102 Composite curve 104 Conic arc ellipse, hyperbola and parabola 106 Copious data forms 1, 2, 12 and 63 108 Plane (form1 bounded) 110 Line 112 Parametric spline curve 114 Parametric spline surface 116 Point 118 Ruled surface 120 Surface of revolution 122 Tabulated cylinder 124 Transformation matrix form 0 126 Rational B-spline curve 128 Rational B-spline surface 140 Offset surface entity 141 Bounded entity 142 Curve on a parametric surface 143 Bounded surface 144 Trimmed surface 308 Subfigure definition 402 Associativity instance 408 Singular subfigure instance The variable `ImportTolerance' (*note Preferences::.) controls the creation of new points when an IGES file is read. Points are therefore defined as unique if they lie further away than this tolerance distance from another already defined point. Curves are also considered identical if they have the same points at their extremes and the "mean proportional distance" between them is smaller than the tolerance. Surfaces can also be collapsed. Entities that are read in and transformed are not necessarily identical to the original entity. For example, surfaces may be transformed into plane,into Coons or into NURBS surfaces defining their contours and shape.  File: gid.info, Node: DXF read, Next: Parasolid read, Prev: IGES read, Up: Import DXF --- With this option it is possible to read a file in DXF format, version AutoCAD 2000. Mostly all the geometry in the DXF is read except the solid modeled entities. A very important parameter to consider is related to how the points must be joined. This means that points that are close to each other must be converted to a single point. This is done by defining variable ImportTolerance (*note Preferences::.). Points closer together than `ImportTolerance' will be considered to be a single point. Straight lines that share both points are also converted to a single line. User can perform one `Collapse' (*note Collapse::.) to join more entities.  File: gid.info, Node: Parasolid read, Next: ACIS read, Prev: DXF read, Up: Import Parasolid --------- With this option it is possible to read a file in Parasolid format, version 11. GiD can incorporate files in Parasolid version 11 format (ASCCI or binary formats). The most usual Parasolid file extension is `.x_t' for ASCII and `.x_b' for binary format. The variable `ImportTolerance' (*note Preferences::.) controls the creation of new points when a Parasolid file is read. Points are therefore defined as unique if they lie further away than this tolerance distance from another already defined point. Curves are also considered identical if they have the same points at their extremes and the "mean proportional distance" between them is smaller than the tolerance. Surfaces can also be collapsed.  File: gid.info, Node: ACIS read, Next: VDA read, Prev: Parasolid read, Up: Import ACIS ---- With this option it is possible to read a file in ACIS format, version 5.0. GiD reads the ASCII version, the SAT Save File Format. ACIS files (in ASCII) have the `.sat' extension.  File: gid.info, Node: VDA read, Next: NASTRAN read, Prev: ACIS read, Up: Import VDA --- With this option it is possible to read a file in VDA format. A very important parameter to consider is related to how the points must be joined. This means that points that are close to each other must be converted to a single point. This is done by defining variable `ImportTolerance' (*note Preferences::.. Points closer together than `ImportTolerance' will be considered to be a single point. Straight lines that share both points are also converted to a single line. User can perform one `Collapse' (*note Collapse::.) to join more entities.  File: gid.info, Node: NASTRAN read, Next: STL mesh read, Prev: VDA read, Up: Import NASTRAN mesh ------------ With this option it is possible to read a file in the NASTRAN format, version 68. GiD can read files written in NASTRAN version 68 format, incorporating most parts of the currently recognized entities: Entity name Notes GRID CBAR CBEAM translated as 2 node bars CELAS2 translated as 2 node bars CHEXA 8 or 20 nodes CONM2 CORD1C CORD1R CORD1S CORD2C CORD2R CORD2S CQUAD4 CROD translated as 2 node bars CTRIA3 CTETRA There are two options that can be used when reading a mesh if GiD already contains a mesh: * a) Erasing the old mesh (`Erase') * b) Adding the new mesh to the old without sharing the nodes; the nodes will be duplicated although they will occupy the same position in the space (`AddNotShare'). The properties and materials of elements are currently ignored, because of the difficulties in associating the NASTRAN file properties with the requirements of the analysis programs. The user must therefore assign the materials "a posteriori" accordingly. However, in order to make this easier, the elements will be partitioned into different layers each with the name PIdn, where n is the property identity number associated with the elements as defined in the NASTRAN file. Note that CELAS2 elements do not have associated property identities so these will be created by default during the reading of the file.  File: gid.info, Node: STL mesh read, Next: Mesh read, Prev: NASTRAN read, Up: Import STL mesh -------- With this option it is possible to read a mesh in the STL format. The STL binary format is also supported. The variable `ImportTolerance' (*note Preferences::.) controls the creation of new points when the file is read.  File: gid.info, Node: Mesh read, Next: Read surface mesh, Prev: STL mesh read, Up: Import GiD mesh -------- With this option it is possible to read a mesh in order to visualize it within GiD. It is also possible to read a new mesh and add it to the existing one. In this case, the user is prompted to keep the former one or join it to the new mesh. The format of the file (whose name is introduced by means of the command line or directly by getting it from the auxiliary window) describing the mesh must have the following structure: mesh dimension = 3 elemtype tetrahedra nnode = 4 coordinates 1 0 0 0 2 3 0 0 3 6 0 0 4 3 3 0 5 3 1.5 4 6 3 1.5 -4 7 1.5 0 2 end coordinates elements 1 1 2 4 5 1 2 2 3 4 5 1 3 1 4 2 6 1 4 2 4 3 6 1 5 1 2 5 7 1 end elements Code `nnode' means the number of nodes per element and `dimension' can be either: * `2': 2 dimensions. Nodes have just two coordinates. * `3': 3 dimensions. Nodes have three coordinates. Where `elemtype' must be: * Linear * Triangle * Quadrilateral * Tetrahedra * Hexahedra Every element may have an optional number after the connectivities definition. This number usually defines the material type and it is useful to divide the mesh into layers to visualize it better. GiD offers the possibility of dividing the problem into different layers according to the different materials through the option `Material' (*note Layers::.). *Note:* The sign `=' is optional, but if it is present it is necessary to leave a space. If it is necessary to enter different types of elements, every type must belong to a different mesh. More than one mesh can be entered by writing one after the other, all of them in the same file. The only difference is that all meshes except the first one have nothing between `coordinates' and `end coordinates'. They share the first mesh's points. Example: to enter tetrahedra elements and triangle elements, mesh dimension = 3 elemtype tetrahedra nnode = 4 coordinates 1 0 0 0 2 3 0 0 3 6 0 0 4 3 3 0 5 3 1.5 4 6 3 1.5 -4 7 1.5 0 2 end coordinates elements 1 1 2 4 5 1 2 2 3 4 5 1 3 1 4 2 6 1 4 2 4 3 6 1 5 1 2 5 7 1 end elements mesh dimension = 3 elemtype triangle nnode = 3 coordinates end coordinates elements 1 1 2 4 1 2 2 3 4 1 3 1 4 2 1 4 2 4 3 1 5 1 2 5 1 end elements