This is Info file gid.info, produced by Makeinfo version 1.67 from the
input file gid.texinfo.

INFO-DIR-SECTION GiD: A graphical pre- and post-processor for numerical simulation programs
START-INFO-DIR-ENTRY
* Manual: (gid).           How to use GiD.
END-INFO-DIR-ENTRY

   This is the GiD manual

   Copyright 1997-2003 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
* View::
* Geometry::
* Utilities::
* Data::
* Meshing::
* 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::
* Print to file::
* About::

Import

* IGES read::
* DXF read ::
* Parasolid read::
* ACIS read::
* VDA read::
* Shapefile 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::

VIEW

* Zoom::
* Rotate::
* Pan::
* Redraw::
* Render::
* Label::
* Entities::
* Layers::
* Save/Read View::
* Background image::
* Multiple windows::

Rotate

* Rotate screen axes::
* Rotate object axes::
* Rotate trackball::
* Rotate angle::
* Rotate points::
* Rotate center::
* Rotate original view::

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::

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::
* Macros window::
* Selection window::
* Animate controls::
* Dimensions::

DATA

* Problem type::
* Transform problem type::
* Internet Retrieve::
* 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::

POSTPROCESS OPTIONS

* introduction - postprocess::
* files - postprocess::
* utilities - postprocess::
* Point and Line options::
* Display Style::
* Textures::
* Cover mesh::

POSTPROCESSING RESULTS

* Contour Fill::
* Smooth 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.post.msh - ProjectName.flavia.msh::
* File ProjectName.post.res - ProjectName.flavia.res::
* old results format::
* old mesh format::

New postprocess mesh format: ProjectName.post.msh, ProjectName.flavia.msh

* Mesh example::

New postprocess results format: ProjectName.post.res, ProjectName.flavia.res

* Gauss Points::
* Result Range Table::
* Result Block::
* Result Group::
* 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::
* special functions::

   CN $Revision: 1.53 $ April 2003


File: gid.info,  Node: Introduction,  Next: GiD basics,  Prev: Top,  Up: Top

INTRODUCTION
************

   GiD is an interactive graphical user interface 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 desired format. It is also
possible to run the numerical simulation from within GiD and to
visualize the results of 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.

* 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.


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 when everything is
defined, the meshing of the geometrical domain is 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 external CAD program. At present, this can be done via a
DXF, IGES, Parasolid, ACIS, VDA, Shapefile, 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 dialog box.
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 creating some configuration files which define new windows,
where the final user will enter data, such as materials or conditions.
The format that GiD uses 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.

   Command line sintaxis:
     gid [-b[{+/-}g][{+/-}i][{+/-}w] batch_file] [filename] [-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 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 (gzip) 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 transform 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, a message window above it and a icon bar.
The project that is being run is written on the window title bar. The
pull down menus and the 'click on' menus are used to access GiD
commands quickly.  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 appears 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 Windows the secondary windows appear generally in over the main
window and cannot be hidden by it. This behaviour 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<angle,z'

   The z_coordinate may be omitted and angles are defined in degrees.
Cylindrical coordinates can be applied to global and local coordinate
systems.

   The following are valid examples of the same point definitions:

     	example (1):
     				1,0,0
     				1.931852<15
     
     	example (2):
     				1,0,0
     				@1.0<30


File: gid.info,  Node: Spherical coordinates,  Prev: Cylindrical coordinates,  Up: Entering points by coordinates

Spherical coordinates
.....................

   Spherical coordinates can be entered as `r<anglexy<anglez'

   `Anglez' may be omitted and angles are defined in degrees. Spherical
coordinates can be applied to global and local coordinate systems.

   The following are valid examples of the same point definitions:

     	Example (1):
     				1,0,0
     				1.73205<18.43495<24.09484
     
     	Example (2):
     				1,0,0
     				@1.0<45<45


File: gid.info,  Node: Selecting an existing point,  Next: Button Base,  Prev: Entering points by coordinates,  Up: Point definition

Selecting an existing point
---------------------------

   When the user is inside a function that asks for a point, GiD can be
in one of the two modes: entering a new point or selecting and old one.
They can be distinguished by the cursor that will be either a cross or
a box. To change from the first mode to the second one, the user must
select button `join' from the right side column commands or its
shortcut (Control-a).  This button is then set to `No Join'. After
this, select an existing point to get it. (Control-a) switches from
`Join' to `No Join' and vice versa.

   Options `Join' and `No join' can also be obtained from the
Contextual submenu in the 3rd button menu (*note Mouse operations::.).

   Special options `FJoin' and `FNoJoin' force GiD to change either to
`Join' mode or `No join' mode independently of the previous mode.


File: gid.info,  Node: Button Base,  Next: Option point in line,  Prev: Selecting an existing point,  Up: Point definition

Option Base
-----------

   If button `Base' is selected (button is set on `No Base'), a point
can be retrieved from any of the other modes. Then, the coordinates of
this point, instead of being used, are written in the command line and
can be edited before entering it.

   It is possible to change the default way that GiD works with points
via preferences (*note Preferences::.).


File: gid.info,  Node: Option point in line,  Next: Option point in surface,  Prev: Button Base,  Up: Point definition

Option point in line
--------------------

   By using this option, the user can pick over a line in the graphical
window.  One point will be created over the line in the position where
the user has picked.


File: gid.info,  Node: Option point in surface,  Next: Option tangent in line,  Prev: Option point in line,  Up: Point definition

Option point in surface
-----------------------

   By using this option, the user can pick over a surface in the
graphical window.  One point will be created over the surface in the
position where the user has picked.


File: gid.info,  Node: Option tangent in line,  Next: Option normal in surface,  Prev: Option point in surface,  Up: Point definition

Option tangent in line
----------------------

   By using this option, the user can pick over a line in the graphical
window.  One vector will be returned that is the tangent to the line in
the position where the user has picked.


File: gid.info,  Node: Option normal in surface,  Next: Option Arc center,  Prev: Option tangent in line,  Up: Point definition

Option normal in surface
------------------------

   By using this option, the user can pick over a surface in the
graphical window.  One vector will be returned that is the normal to
the surface in the position where the user has picked.


File: gid.info,  Node: Option Arc center,  Prev: Option normal in surface,  Up: Point definition

Option Arc center
-----------------

   By using this option, the user can pick over an arc in the graphical
window. One point will be returned in the center of the arc selected.


File: gid.info,  Node: Entities selection,  Next: Quit,  Prev: Point definition,  Up: User basics

Entities selection
==================

   Many commands need some entities to be selected before applying
them, and the method of selection is always identical. Before selecting
entities, the user is prompted to decide whether to select points,
lines, surfaces or volumes (in some cases this decision is obvious or
it is made within the context of the option).
Within one of the generic groups (points, lines, surfaces, volumes,
nodes or elements), it does not matter what type of entity is selected
(for example, an arc or a spline, both line entities are selected in
the same way). After this, if one entity of the desired group is
selected, it is colored red to indicate its selection and the user is
prompted to enter more entities. If the user selects away from any
entity, a dynamic box is opened that can be defined by picking again in
another place.  All entities that are either totally or partly within
this box are selected.  Next, the user is prompted to enter more
entities. The normal selection mode is `SwapSelection': If one entity
is selected a second time, it becomes deselected and its color reverts
to normal, It also exist the options `AddToSelection' and
`RemoveFromSel' to only add or only remove entities to the selection.
Note: Instead of picking twice to begin and end the selection box, it is
possible to keep leftmouse pressed and move the cursor.
Option `Clear selection' found in the Contextual mouse menu, deselects
all previously selected entities.
It is also possible to select entities by entering their label in the
command line. For instance, to select the entity with number 2, the
user has to input this number, `2', in the command line. To select the
entities 3 to 7, the user has to input `3:7' in the command line.
Option `3:' will select all entities from number 3 to end and option
`:3' will select all options from beginning to number 3.
If a layer named `ll1' exists, it is possible to select all entities
belonging to that layer with command: `layer:ll1' . Using command
`layer:' select all entities belonging to no layer.
Another way of selecting points or nodes is to write:
         plane:a,b,c,d,r
      Where a,b,c,d and r are real numbers that define a plane and a
tolerance in the following way: `ax+by+cz+d<r'.  Points close to that
plane are chosen.

   In some commands, another item is added to the selection group. This
item, called `AllTypes', means to select all entities levels
(points...volumes) at the same time.
In this case, only selection via a dynamic box is possible in the
graphical window and all entities (points, lines, surfaces and volumes)
in the box are selected.
To finish the entities selection, use `escape' (*note Escape::.).
If the option `Fast Selection' is used, entities are not colored red
when selected and choosing an entity twice does not deselect it. Option
`Fast Selection' is avalaible in the right buttons (*note
Graphical::.), in Utilities > 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.

   Note: A typical use of filter is to select only boundary lines
(higherentiety=1).

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: View,  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::
* Print to file::
* About::


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 begins.


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.  It is possible to automatically save a model backup by
selecting a user frequence (*note Preferences::.).


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::
* Shapefile 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 read files in IGES version 5.1 format, including most of the
entities, which are:

     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 2002.

   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 read files in Parasolid version 11 format (ASCII 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: Shapefile read,  Prev: ACIS read,  Up: Import

VDA
---

   With this option it is possible to read a file in VDA 2.0 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: Shapefile read,  Next: NASTRAN read,  Prev: VDA read,  Up: Import

Shapefile
---------

   With this option it is possible to read a GIS file written in ESRI
Shapefile format, version 1000.  Shapefiles have the `.shp' extension.


File: gid.info,  Node: NASTRAN read,  Next: STL mesh read,  Prev: Shapefile 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, accepting
most of its entities, whic are:

     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 GiD ASCII mesh (saved with
`Export GiD 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


File: gid.info,  Node: Read surface mesh,  Next: Batch file,  Prev: Mesh read,  Up: Import

Surface mesh
------------

   With this option, a mesh can be read from a file in GiD or STL format
(*note Mesh read::.). Elements of this mesh must be triangles or
quadrilaterals.  This mesh is converted by GiD in a set of surfaces,
points and lines.  The geometric definition of surfaces is the mesh
itself, but GiD treat them as truly geometric entities. For example:
this surfaces can be used as the boundary of a volume, and a new mesh
can be generated over them.

   User is asked for the value of an angle. An angle between elements
bigger than this value, is considered to be an edge and lines are
inserted over them. As a consequence, a set of boundary and interior
lines are created and attached to the surfaces to mark their edges.


File: gid.info,  Node: Batch file,  Next: Insert geometry,  Prev: Read surface mesh,  Up: Import

Batch file
----------

   Sometimes, it may be useful not to use GiD interactively. To do so,
commands can be written into a file and GiD will read this file and
execute the commands.  These commands are the same that are used in GiD
when written in the command line or using the commands in the right
side commands menu.

   Example: Many points have been digitalized and their coordinates
saved in a file. These points are to be joined with straight lines to
create the outline of the geometry. To do so, the file would look
similar to this:

     geometry create line
     3.7 4.5 8
     2 5 9
     4,5,6
      ...
     1 7 0.0
     escape

   A batch file can also be loaded into GiD by giving its name with
option -b when opening GiD. (*note Invoking GiD::.) Another way to read
batch files to create dynamic presentations is with the `Read batch
window' (*note Read batch window::.). One GiD session can be registered
in a batch file. This can be useful to check the batch commands or to
repeat one session (*note Preferences::.).
*BATCH FILE COMMANDS*
There are some especial commands to be added  to a batch than are
treated differently than regular GiD commands. Their format is one or
several words after the control string ***** (five stars) and
everything in one line.

   * Write a log file
          *****OUTPUTFILENAME filename
     `filename' is substituted with a real file name where all the
     session warnings (that which appear in the GiD messages warn line)
     are written. This can be useful when running GiD in batch with
     option -n (*note Invoking GiD::.) and GiD output is desired.
   * Execute a TCL command in a batch file
          *****TCL tcl_command

     Note: If this command is used in batch file and GiD is invoked
     with option `-n' it will not work. To make TCL commands execute
     when GiD is executed without any window, you should use the `-n2'
     option. (*note Invoking GiD::.)

   * Insert comments in the code of a batch file
          geometry create line
          1,2
          *****COMMENTS -this is a comment-
          2,3
          escape

   * Print messages in the inferior GiD messages line
          geometry create line
          1,2
          *****PRINT  -This is a message which will appear in the messages line-
          2,3
          escape

   * Print messages in a window
          geometry create line
          1,2
          *****PRINT1  -This is a message which will appear in a new window-
          2,3
          escape


File: gid.info,  Node: Insert geometry,  Prev: Batch file,  Up: Import

Insert GiD geometry
-------------------

   This command permits to insert one previously created GiD model
inside another one.  Entities from the old and the new model are not
collapsed.

   User can perform one `Collapse' (*note Collapse::.) to join the old
and new model.


File: gid.info,  Node: Export,  Next: Print to file,  Prev: Import,  Up: Files

Export
======

* Menu:

* IGES write::
* DXF write::
* GiD mesh::
* Text data report::
* Save ASCII project::
* Save ON layers::
* Calculation file::
* Using template::


File: gid.info,  Node: IGES write,  Next: DXF write,  Prev: Export,  Up: Export

IGES
----

   GiD can export the geometry in IGES format (version 5.1). Points,
curves and surfaces are exported and volumes are ignored.

   The IGES entities generated are:

     116	Point
     110	Line
     102	Composite curve
     126	Rational B-spline curve
     128	Rational B-spline surface
     142	Curve on a parametric surface
     144	Trimmed surface


File: gid.info,  Node: DXF write,  Next: GiD mesh,  Prev: IGES write,  Up: Export

DXF
---

   GiD can export the geometry in DXF format (version AutoCAD 2002).
Points and curves are exported.  Surfaces are ignored because DXF does
not support Trimmed NURBS Surfaces.


File: gid.info,  Node: GiD mesh,  Next: Text data report,  Prev: DXF write,  Up: Export

GiD mesh
--------

   With this option a file is written with all the project's mesh or
meshes inside.  This file can be read with `Import GiD Mesh' *Note Mesh
read::.


File: gid.info,  Node: Text data report,  Next: Save ASCII project,  Prev: GiD mesh,  Up: Export

Text data report
----------------

   With this option a file is written containing all the information
within the project. It is created in a way that is easily understood
when read with an editor. This is useful for checking the information.

   *Note:* This ASCII format is only used to check information. It
cannot be read again by GiD. To write ASCII files that can be read
again use the option `SaveAsciiProj' (*note Save ASCII project::.).


File: gid.info,  Node: Save ASCII project,  Next: Save ON layers,  Prev: Text data report,  Up: Export

ASCII project
-------------

   This option saves a project in the same way as the regular `save'
(*note Save::.) but files are written in ASCII. It may be useful to copy
projects between non-binary-compatible machines. GiD also allows this
information to be written in a file (*note Text data report::.).

   Projects saved in this way may be read with the same `open' command
(*note Open::.).


File: gid.info,  Node: Save ON layers,  Next: Calculation file,  Prev: Save ASCII project,  Up: Export

ON layers
---------

   With this option, only the geometrical entities with its layer set
to `ON' will be saved in a new project (*note Layers::.).

   *Note:* Lower entities necessary to define the saved entities will be
also saved into the new project (example: The two points extremes of a
line are also saved if the line is saved).


File: gid.info,  Node: Calculation file,  Next: Using template,  Prev: Save ON layers,  Up: Export

Calculation file
----------------

   If GiD runs the solver module automatically, this command is not
necessary. It is however useful if the solver program is required to be
run outside GiD, or to check the data input prior to any calculations.

   This command writes the data file needed by the solver module.

   The format of this file must be defined in a Template File (*note
Template File::.). GiD uses the template file of the current Problem
Type to write the data file; so, to run this command, a problem type
must be selected.

   When testing a new problem type definition, GiD produces messages
about errors within the configuration.  When the error is corrected,
the command can be used again without quitting the example and without
having to reassign any condition or meshing again.


File: gid.info,  Node: Using template,  Prev: Calculation file,  Up: Export

Using template
--------------

   This command does the same as `Export calculation file' (*note
Calculation file::.), but it uses a `.bas' file provided by the user,
instead of using the template file of the current Problem Type. So,
it's not necessary to select a Problem Type to run this command.

   When choosing option `Others...' from the submenu, GiD asks for a
`.bas' file (*note Template File::.) and, using that file, writes the
data file needed by the solver module. There are some `.bas' codes
available in the submenu which write output files in some formats (DXF,
NASTRAN, STL, VRML). These example `.bas' files are located in the
`Templates' directory of the main GiD directory. It's possible to add
other `.bas' files to that directory so that they appear in the submenu.


File: gid.info,  Node: Print to file,  Next: About,  Prev: Export,  Up: Files

Print to file
=============

   This option asks the user for a file name and save an image in the
required format.

   Accepted formats are:

   * `TIFF:' Tagged Image File Format.

   * `EPS:' Encapsulated postscript. Useful to insert in documents.

   * `Postscript screen:' Postscript. Useful to send to a postscript
     printer.  It is a snapshot of the screen.

   * `Postscript vectorial:' Postscript. Useful to send to a postscript
     printer.  It gives higher quality but it is only usable for small
     modells. Otherwise, very large files are created and it takes very
     long time to print them.

   * `VRML:' Writes a VRML model file with the current visualization.

   * Other supported formats are: `BMP', `GIF', `JPG', `PNG', `TGA'


File: gid.info,  Node: About,  Prev: Print to file,  Up: Files

About
=====

   This command gives some information about the program, such as the
version number which is being run, the system or libraries.


File: gid.info,  Node: View,  Next: Geometry,  Prev: Files,  Up: Top

VIEW
****

   Visualization commands change the way to display the information in
the graphical window.  They do not change any definition of the
geometry or any other data.

   Generally, they can be used within any other command without leaving
it. When the visualization process finishes, the first command
continues.

   They can be accessed either from the top menu `View' or form the
right mouse button.

* Menu:

* Zoom::
* Rotate::
* Pan::
* Redraw::
* Render::
* Label::
* Entities::
* Layers::
* Save/Read View::
* Background image::
* Multiple windows::


File: gid.info,  Node: Zoom,  Next: Rotate,  Prev: View,  Up: View

Zoom
====

   Zoom is used to change the visualized size of the objects without
deforming them.  This only enlarges or reduces the objects and changes
the orthogonal perspective of the window.

   * `Zoom in:' Pick inside the graphical window. A dynamic rectangle
     is opened. Pick again and the visualization changes to display
     only the part within the defined rectangle.

   * `Zoom out:' Pick inside the graphical window. A dynamic rectangle
     is opened. Pick again and the visualization changes so that
     everything in the graphical window is reduced to the size of the
     rectangle.

   * `Zoom frame:' Choose a visualization size so as to display
     everything inside the window.

   * `Zoom points:' User enters two points (*note Point definition::.),
     and a visualization size is chosen so as to display these two
     points inside the window.

   * `Zoom dynamic:' Moving mouse horizontally, view is enlarged or
     shortened.

   * `Zoom previous:' GiD goes to the previous saved zoom.

   * `Zoom next:' If one previous zoom has been made, this option goes
     to the one after the current view in the stack list.

   `Note:' Instead of picking twice to begin and end the rectangle, it
is possible to maintain the leftmouse pressed and move the cursor.


File: gid.info,  Node: Rotate,  Next: Pan,  Prev: Zoom,  Up: View

Rotate
======

   There are various ways to make a rotation in order to change the
graphical view of the geometry, without changing it.

* Menu:

* Rotate screen axes::
* Rotate object axes::
* Rotate trackball::
* Rotate angle::
* Rotate points::
* Rotate center::
* Rotate original view::

   `Note:' Instead of picking twice to begin and end the rotation, it
is possible to maintain the leftmouse pressed and move the cursor.


File: gid.info,  Node: Rotate screen axes,  Next: Rotate object axes,  Prev: Rotate,  Up: Rotate

Rotate screen axes
------------------

   With this option, a dynamic rotation about the screen axes is made.
Screen axes are defined as:

   * `X-axis': A horizontal axis.

   * `Y-axis': A vertical axis.

   * `Z-axis': An axis orthogonal to the screen.

   When entering this command, `Z-axis' is set by default and moving
the mouse to the left or to the right will rotate the geometry around
this axis. Picking the left mouse changes the axis. To leave this
function, use `escape' (*note Escape::.).

   To change the axes is also possible by entering the letters `x', `y'
or `z' in the command line.

   To move the geometry by a fixed angle, enter the number of degrees,
positive or negative, in the command line.


File: gid.info,  Node: Rotate object axes,  Next: Rotate trackball,  Prev: Rotate screen axes,  Up: Rotate

Rotate object axes
------------------

   With this option, a dynamic rotation about the object axes is made.
Object axes are the global axes in the position they are in that
particular moment. i.e.  the axes currently drawn in the graphical
window.

   When entering this command, `Z-axis' is set by default and moving
the mouse to the left or to the right will rotate the geometry around
this axis. Picking the left mouse changes the axes. To leave this
function, use `escape' (*note Escape::.).

   To change the axes is also possible by entering the letters `x', `y'
or `z' in the command line.

   To move the geometry by a fixed angle, enter the number of degrees,
positive or negative, in the command line.


File: gid.info,  Node: Rotate trackball,  Next: Rotate angle,  Prev: Rotate object axes,  Up: Rotate

Rotate trackball
----------------

   With this option, a dynamic rotation is made, resembling a trackball
device. It means that when picking over a geometry point with the left
mouse and moving the mouse, the geometric point tries to follow the
mouse pointer. This can be imagined as a ball over the graphical window
which is moved with the mouse.

   The left mouse button can be pressed several times to connect and
disconnect the movement. To leave this function, use `escape' (*note
Escape::.).


File: gid.info,  Node: Rotate angle,  Next: Rotate points,  Prev: Rotate trackball,  Up: Rotate

Rotate angle
------------

   The new position of the geometry after the rotation can be defined
as the direction orthogonal to the screen via a pair of angles:

  1. The angle in the plane `XY' starting from the `X-axis'.

  2. The elevation angle from the `XY' plane.

   As an example, the initial view (orthogonal to the Z-axis and with
the X-axis horizontal) can be obtained with:

     rotate angle 270 90


File: gid.info,  Node: Rotate points,  Next: Rotate center,  Prev: Rotate angle,  Up: Rotate

Rotate points
-------------

   This option appears only in the right side commands menu.

   The new position of the geometry after the rotation can be defined
as the direction orthogonal to the screen via a pair of points:

  1. The target point, the point to look at.

  2. The view point, the point to look from.


File: gid.info,  Node: Rotate center,  Next: Rotate original view,  Prev: Rotate points,  Up: Rotate

Rotate center
-------------

   The default center of rotation is defined approximately in the
center of the geometry.

   If it is desired to change this center, use this command and enter a
point (*note Point definition::.). This new rotation center will be
maintained until the next `zoom frame' (*note Zoom::.).


File: gid.info,  Node: Rotate original view,  Prev: Rotate center,  Up: Rotate

Rotate original view
--------------------

   This option, that appears only in the graphical pop-up menu, changes
the view to the original one: screen orthogonal to the Z-axis with the
X-axis lying horizontally and pointing to the right.


File: gid.info,  Node: Pan,  Next: Redraw,  Prev: Rotate,  Up: View

Pan
===

   * `Two points:' With this command, the location of the geometry is
     displaced in the graphical window. To do this, pick two points in
     the graphical window.

   * `dynamic:' In this case the displacement is made dynamically,
     moving the mouse horizontally.


File: gid.info,  Node: Redraw,  Next: Render,  Prev: Pan,  Up: View

Redraw
======

   This command redraws the geometrical model in the graphical window.
For those machines that include overlays, all the layers that stay
underneath are not affected, so the redraw goes faster and the
underneath drawings remain untouched.


File: gid.info,  Node: Render,  Next: Label,  Prev: Redraw,  Up: View

Render
======

   By using this option, the way of viewing the model changes. There
are four options:

   * `Normal:' This is the usual way of visualizing. The geometry and
     mesh are viewed including all definition lines.

   * `Filled:' Solid model with no illumination and lines.

   * `Flat lighting:' Solid model with flat illumination and lines.

   * `Smooth lighting:' Solid model with smooth illumination (better
     quality).

   *Note:* The rendering of a volume mesh requires the option `View
boundaries' (*note View boundaries::.).

   *Note:* Quality of visualization is controlled via preferences
(*note Preferences::.).

   *Note:* The light vector direction can be changed interactively with
the menu option `Change Light Vector' inside the menu `Utilities'
(*note Change Light Vector::.).


File: gid.info,  Node: Label,  Next: Entities,  Prev: Render,  Up: View

Label
=====

   With this option, the labels of the entities are drawn or not. It is
possible to select some entities or to apply this option to all
entities viewed in the graphical window.  To select some entities,
choose `select' before applying on the `Points', `Lines', `Surfaces' or
`Volumes'. Then, select entities in the usual way (*note Entities
selection::.). Options are:

   * `All:' All entities in the graphical window will have their labels
     drawn.

   * `points,lines,surfaces' or `volumes:' If `select' is not set, all
     the entities in the graphical window will have their labels drawn.

   * `Off:' Finish drawing labels for all entities.


File: gid.info,  Node: Entities,  Next: Layers,  Prev: Label,  Up: View

Entities
========

   With this option, it is possible to choose some of the `points,
lines, surfaces or volumes' to be drawn. It is useful to make drawing
faster or clearer in some instances.
Note: this option is only available in the right buttons menu. (*note
User interface::.)


File: gid.info,  Node: Layers,  Next: Save/Read View,  Prev: Entities,  Up: View

Layers
======

   Layers are a way to split a complex drawing into separate pieces.
The idea is that any entity can belong to one layer or to none (an
entity cannot belong to more than one layer). Then, it is possible to
view only some layers and not others. It is also useful to easily select
entities in the graphical window.

   Commands related to layers are:

   * `New:' Creates a new layer. If name is given the layer is called
     "`Layer#'". The new layer will be used as the default layer until
     the end of the session or until it is changed.

   * `Layer To use:' Selects a layer to be used as default. All the new
     entities will be created within this layer. All the layers are
     capable of being selected.
     Next to the `Layer To use' button, there's an arrow facing down.
     This is a menu which lets you select a point, a line, a surface or
     a volume; the layer to which it belongs that entity, will be set
     as the default layer.

   * `On:' Entities belonging to this layer will be drawn and can be
     selected in the graphical window.

   * `Off:' Entities belonging to this layer will not be drawn and
     cannot be selected in the graphical window.

   * `Lock/Unlock (Freeze/Unfreeze):' Entities belonging to this layer
     will be drawn but cannot be selected in any way. When copying
     entities (*note Copy::.) and sharing old entities, entities
     belonging to frozen layers are not taken into account and not even
     a range of numbers (*note Entities selection::.) can be selected.
     The opposite command is `Unlock', where the entities belonging to
     this layer can be selected, copied and shared.

   * `Delete:' Deletes a layer. A layer can only be deleted if it has
     no entities in it.

   * `Send to:' Moves entities to a new layer. No new entities are
     created. They are only moved from one layer to another. When
     choosing, in geometry mode, `point', `line', `surface', `volume'
     or `all', option `all' can be used only to select entities in the
     graphical window and change all the entities in the dynamic box to
     the new layer. In mesh mode, it is possible to choose `nodes',
     `elements' or `all'.
     Especial option `Also lower entities' permits to send to the layer
     also the entities that are lower entities of the selected ones.
     Example: If this flag is set and one surface is selected, its
     lines and its points are also sent to the layer.

   * `To back:' Sends entities to the back of its layer. When an entity
     is "at the back" it's not visible and cannot be selected, moved,
     copied or deleted. To bring again the entities of a layer "to the
     front", select a layer and choose the `Bring to front' option,
     from the `To back' menu. There is another option, `Bring ALL to
     front', which brings to front all entities of all layers.
     If the flag `Opposite' is set, entities which are not selected
     will go to the back.

   * `Color:' Change color to layer. This color is used when making a
     render (*note Render::.).

   * `Sel...:' In the layer window, there is the option `select' that
     allows the selection of several layers. This can be useful when
     using a large number of layers. After pressing `Sel...' a new
     window appears to allow the input of a pattern that will match the
     layer's name. In this pattern, characters * and ? are wildcards
     that match any characters or character, respectively, in the
     layer's name. So, the pattern `select' will match `select', `
     selection', ` select-surface' and so on.

   * `Rename:' Changes the name of a layer.

   * `Close:' Closes the Layers window.

   *Important:* The mesh generation does not depend on the state of the
layers when the generation is performed (*note Layers::.). All layers
are meshed and every node and element will be assigned to the layer
where the original geometrical entity was. The only exception to this
rule is for the case of frozen layer if the option `No mesh frozen
layers' is selected.


File: gid.info,  Node: Save/Read View,  Next: Background image,  Prev: Layers,  Up: View

Save/Read View
==============

   These two options permits to save the actual view configuration into
a file. Then, that configuration can be loaded using the `Read View'
command.


File: gid.info,  Node: Background image,  Next: Multiple windows,  Prev: Save/Read View,  Up: View

Background Image
================

   An image can be used as background of GiD for visualization purposes
(supported image formats are `.bmp' and `.ppm'). There are the
following options:
   * Fit screen: an image will be fitted into GiD's background window.

   * Real size: the image will not be deformed; the image is placed in
     a plane. Three points must be entered: two of them to define the
     line where the bottom line of the image lies, and a stand-up
     point, which defines the upper direction of the image.

   * Default: use this option to use the default background.


File: gid.info,  Node: Multiple windows,  Prev: Background image,  Up: View

Multiple windows
================

   Command `Multiple windows' permits to have several views of the same
project. Different views can be displayed inside the program main
window or in supplementary windows.


File: gid.info,  Node: Geometry,  Next: Utilities,  Prev: View,  Up: Top

GEOMETRY
********

   All available geometrical operations, generating or deleting
entities and performing particular options are included in this chapter.

* Menu:

* View geometry::
* Create::
* Delete::
* Edit::


File: gid.info,  Node: View geometry,  Next: Create,  Prev: Geometry,  Up: Geometry

View geometry
=============

   This command changes from mesh visualization to geometry
visualization. If mesh doesn't exist, the user is asked to generate it.


File: gid.info,  Node: Create,  Next: Delete,  Prev: View geometry,  Up: Geometry

Create
======

   Generation of all the different possible geometrical entities.
Usually, the new entities are created inside the current layer (*note
Layers::.).

* Menu:

* 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::


File: gid.info,  Node: Point creation,  Next: Line creation,  Prev: Create,  Up: Create

Point creation
--------------

   Individual points are created by entering each point in the usual way
(*note Point definition::.). The point can later be used to join lines
to it.

   *Caution:* It is impossible to create new points joining old ones.

   Option `Number' Lets the user choose the label that will be assigned
to the next created point. If a point with this number already exists,
the old point changes its number.


File: gid.info,  Node: Line creation,  Next: Arc creation,  Prev: Point creation,  Up: Create

Line creation
-------------

   To create a straight line it is only necessary to enter two points
(*note Point definition::.) and continue entering points in order to
create more lines from the first one. Every part of the total line
created is an independent line.

   It is important to note that when creating lines, new points are
also being created (if not using existing ones).

   Option `Close' joins the first point and the last point created with
a straight line and finishes.

   Option `Undo' undoes the creation of the last point (if new) and the
last line. It is possible to continue undoing back until the first
point.

   Option `Number' Lets the user choose the label that will be assigned
to the next created line. If a line with this number already exists,
the old line changes its number.

   If `Join' is chosen, it is maintained for all points until `No join'
is selected.


File: gid.info,  Node: Arc creation,  Next: Arc tangents,  Prev: Line creation,  Up: Create

Arc creation
------------

   To create an arc it is necessary to enter 3 points (*note Point
definition::.) or enter a radius and the two tangent lines at the arc
ends.

   It is important to note that when creating an arc, new points are
also being created (if not using existing ones).

   An arc that begins and ends on one of the first or third points
defined is always created. The arc will always contain the second
point. This one is only used as a reference and, if non-existent, it is
automatically erased when the arc is created.

   Option `Undo' undoes the creation of the last point (if new). It is
possible to continue undoing back until the first point.

   Option `By tangents' lets the user input a radius and select two
lines that share one common point. An arc will be then created and the
two lines will be modified to be tangent and continuous with this new
arc. This function is the same than the one defined in (*note Arc
tangents::.).

   To convert one arc to another one with the same center and in the
same plane but with complementary angle, command `Swap arcs' can be used
(*note Swap arcs::.).


File: gid.info,  Node: Arc tangents,  Next: NURBS line creation,  Prev: Arc creation,  Up: Create

Arc tangents
------------

   This option lets the user input a radius and select two lines that
share one common point. An arc will be then created and the two lines
will be modified to be tangent and continuous with this new arc.


File: gid.info,  Node: NURBS line creation,  Next: Polyline creation,  Prev: Arc tangents,  Up: Create

NURBS line creation
-------------------

   NURBS are non-uniform rational B-splines. They are a type of curves
that can interpolate a set of points. NURBS can also be defined by their
control polygon, another set of points that the curve approximates
smoothly.

   This command can be used to create a NURBS line in the following two
ways.

   To create a NURBS, user enters either some interpolated points or
enters the points that form the control polygon (*note Point
definition::.).

   Option `Undo' undoes the creation of the last point. It is possible
to continue undoing back until the first point.

   By default, NURBS will be a cubic polynomial passing through all the
points.  However, this option can be changed by calling `ByControlPts',
which defines NURBS by their control polygon. This polygon is a set of
points where the first and the last points match the first and last
points of the curve.  The rest of the points do not lie on the curve.
It can be assumed that the curve approximates the points of the polygon
in a smooth way. In this case, user chooses the degree of the curve
that will be the degree of the connected polynomials that define the
NURBS.

   When defining interpolating curves, user can choose to define the
tangents to one or both ends (option `Tangents'). These tangents are
customizable, in the sense that they can either be defined by picking
their direction on the screen or by considering an existing line as a
tangent to the NURBS if it follows a previous curve (option `ByLine').
The option `Next' allows only one tangent to be defined.

   In this way, it is possible to create a closed NURBS by selecting
the initial point as the end one, choosing option 'tangent', 'next',
and 'ByLine'.

   When a NURBS has been created, all the interior points (except the
first and last) are not really entity points unless they previously
existed.

   Option `Number' Lets the user choose the label that will be assigned
to the next created line. If a line with this number already exists,
the old line changes its number.

   To enter rational weights to the curve, command *Note Edit NURBS
line::, can be used.


File: gid.info,  Node: Polyline creation,  Next: Parametric line,  Prev: NURBS line creation,  Up: Create

Polyline creation
-----------------

   Polylines are a set of other lines (two, at least) of any type
(including polylines themselves).  Every line must share one or two of
its endpoints with the endpoints of other lines.

   There are two possible ways to create a polyline, either by
selecting one line and searching the rest until a corner or end is
reached or by selecting several lines (*note Entities selection::.). In
the case of the latter, the order of selection is not important but all
of them must join each other by sharing common points.

   Polylines are drawn in green to show the difference between the
other lines which are drawn in blue.

   Polylines are widely used when creating 4-sided surfaces (*note
4-sided surface creation::.) and automatic 4-sided surfaces (*note
4-sided surface automatic creation::.).

   When deleting a polyline, all its lines are also deleted. When
exploding (*note Explode polyline::.), the polyline will disappear and
its individual lines will appear.

   It is not possible to create third level polylines: one former
polyline can be included inside another, but not the new one.

   Option `Number' Lets the user choose the label that will be assigned
to the next created line. If a line with this number already exists,
the old line changes its number.


File: gid.info,  Node: Parametric line,  Next: Planar surface creation,  Prev: Polyline creation,  Up: Create

Parametric line
---------------

   The required input datas are the mathematical formulas of the
coordinates X(t), Y(t), Z(t), where 't' is the parameter of the curve,
and its value belongs at the interval [ t0-t1 ] The curve is created by
approximation. That curve is a NURB (Non Uniform Rational B-Spline)
which is created with N points. In GiD these kind of curves are created
with degree 3 (cubical).
EXAMPLE
We fill the formulas with the expression of a conic helix. That helix
starts with radius R0=4 and finishes with radius R1=1, performing N=3
turns from t=0.0 to t=1.0, the height also changes from 0 to H=5.

File: gid.info,  Node: Planar surface creation,  Next: 4-sided surface creation,  Prev: Parametric line,  Up: Create

Planar surface creation
-----------------------

*Note:* Entity planar surface has been substituted by entity NURBS
surface (*note NURBS surface creation::.). This entity automatically
detects if boundary lines lie in a plane and create a planar NURBS.

   *Note:* It is possible to access to this deprecated function with
the Right buttons (*note Graphical::.).

   Planar surface is an entity formed by a closed set of lines, all of
them lying on the same plane. Lines must share endpoints between them.

   To create a planar surface, some lines must be selected (*note
Entities selection::.).  The order of selection is not important but
all of them must join each other by sharing common points and must form
a closed contour. If all lines are not in the same plane the surface is
not created.

   It is possible to add holes to a planar surface. To do so, it is
first necessary to create the outside planar surface. After this, press
`Hole' button and select the created surface. Then, select lines that
form every hole, one by one. Finish with `escape' (*note Escape::.).
It is also possible to define the surface and holes at the same time,
selecting all the curves.

   If the surfaces lie on the plane `z=0', the orientation of the
surfaces will be anti-clockwise in this plane (the normal vector points
towards `z' positive).  Otherwise, orientation will be arbitrary. This
can be checked with the DrawNormals command (*note Draw surface
normals::.).


File: gid.info,  Node: 4-sided surface creation,  Next: 4-sided surface automatic creation,  Prev: Planar surface creation,  Up: Create

4-sided surface creation
------------------------

   *Note:* Entity 4-sided surface has been substituted by entity NURBS
surface (*note NURBS surface creation::.). This new entity has all the
functionality of the old one.

   *Note:* It is possible to access to this deprecated function with
the Right buttons (*note Graphical::.).

   A 4-sided surface is an entity formed by a closed set of four lines
in the space.  Its mathematical definition is a bilinear Coon's
surface. The surface is totally defined by the shape of the lines, with
no information about the interior.  This means that, sometimes, it will
be necessary to use more surfaces to obtain a good shape definition.

   To create a 4-sided surface defined by three lines, it is necessary
to divide one of the lines in two pieces (*note Divide::.). Then, the
creation of a 4-sided surface is possible.

   To create a 4-sided surface, several lines must be selected (*note
Entities selection::.).  The order of selection is not important, but
all of them must join each other by sharing common points and they must
form a closed contour. If the creation is not possible, information
about the endpoints is displayed in one window.

   In order to make one or more lines form parts of a polyline (*note
Polyline creation::.), select the entire polyline as one of the lines
and GiD will automatically select the piece or pieces of the polyline
that are required.  Using this facility, non-conforming surfaces can be
created. This means creating a surface by using the entire line on one
side of the polyline, and creating more than one 4-sided surface by
using parts of it on the other side.

   When selecting more than four lines, GiD will automatically search
for all the possible 4-sided surfaces that can be created with these
lines. This allows the creation of many surfaces at the same time.

   The button `Automatic' is equivalent to `4-sided surface automatic
creation' (*note 4-sided surface automatic creation::.).

   If the surfaces lie on the `z=0' plane, the orientation of the
surfaces will be anti-clockwise in this plane (normal vector points
towards `z' positive).  Otherwise, the orientation will be arbitrary.
This can be checked with the DrawNormals command (*note Draw surface
normals::.).

   Option `Number' Lets the user choose the label that will be assigned
to the next created surface. If a surface with this number already
exists, the old surface changes its number.

   *Caution:* When creating some surfaces at the same time, it is
possible that some undesired surfaces may also be created. It is
necessary to check the surfaces after creation and erase the undesired
ones.


File: gid.info,  Node: 4-sided surface automatic creation,  Next: NURBS surface creation,  Prev: 4-sided surface creation,  Up: Create

4-sided surface automatic creation
----------------------------------

   Inside this option, GiD creates as many 4-sided surfaces as it can
find. Every new surface will be created either in the current layer.

   *Caution:* When creating some surfaces at the same time, it is
possible that some undesired surfaces may also be created. It is
necessary to check the surfaces after creation and erase the undesired
ones.


File: gid.info,  Node: NURBS surface creation,  Next: Volume creation,  Prev: 4-sided surface automatic creation,  Up: Create

NURBS surface creation
----------------------

   NURBS are non-uniform rational B-splines. They are a type of surfaces
defined by their control polygon (one set of points that the surface
approximates smoothly); one set of knots for the two senses u and v (a
non-decreasing list of real numbers between 0 and 1) and, optionally,
one set of rational weights.

   To draw the isoparametric lines in u,v=0.5, check `Surface drawing
type' (*note Preferences::.).

   * `By contour:' creates a NURBS by their contour lines. GiD
     calculates automatically the interior information of the surface
     so as to interpolate the boundaries smoothly.
     To create a NURBS surface, some lines must be selected (*note
     Entities selection::.). The order of selection is not important
     but all of them must join each other by sharing common points and
     must form a closed contour. Number of lines must be equal or
     bigger than one and shape must be topologically similar to a
     triangle or a quadrilateral in the space, for the algorithm to
     work correctly. This last argument is not necessary if all the
     lines lie in one plane. In this case, the surface is created as a
     trimmed one and problems about the shape are avoided.

     It is possible to select the boundary lines and the boundary lines
     of interior holes at the same time, if all the lines belong to a
     plane.
     Note: Option `No try planar' (this option is found in the
     Contextal mouse menu) avoid the creation of a trimmed NURBS
     surface when lines are coplanar.
     Note: To enter rational weights to the surface, use command `Edit
     NURBS surface' (*note Edit NURBS surface::.).
   * `Automatic:' creates automatically all possible surfaces with a
     number of sides given by the user. Every new surface will be
     created in the current layer.
     *Caution:* When creating some surfaces at the same time, it is
     possible that some undesired surfaces may also be created. It is
     necessary to check the surfaces after creation and erase the
     undesired ones.
   * `Trimmed:' this option let the user select one existing NURBS
     surface and a set of closed lines that are inside the surface.
     Some of this lines may belong already to the contour of the
     existing surface. Some other lines may be created with an
     intersection with another surface. Another new surface will be
     created without changing the old one.

     It is possible to select the boundary lines and the boundary lines
     of interior holes at the same time, if all the lines belong to the
     surface:

     Option `Untrimm' (inside the Contextual mouse menu after selecting
     a Nurbs surface), constructs one new surface with the selected
     surface as base and as contours, the natural contours of the NURBS
     surface. The resulting surface is not trimmed.

   * `Parallel lines:' permit to create one surface given a set of
     parallel lines in the space. The new surface will interpolate all
     the selected lines.
   * `Search:' lets the user select one line and creates one surface
     that contains this line.

   * `By points/By line points:' these two options are avalaible in the
     Contextual mouse menu after the NURBS surface creation tool is
     selected. `By points' creates a NURBS surface from a cloud of
     points, and `By line points' creates a NURBS surface from level
     curves. This two functions are very useful to create reliefs and
     terrains. In the image below, a NURBS surface created from level
     curves:

     Note: This surface only is an  approximation to the selected
     points/lines, but there's no interpolation.


File: gid.info,  Node: Volume creation,  Next: Contact creation,  Prev: NURBS surface creation,  Up: Create

Volume creation
---------------

   A volume is an entity formed by a closed set of surfaces that share
their lines between them.

   To create a volume, some surfaces must be selected (*note Entities
selection::.).  The order of selection is not important but all of them
must join each other by sharing common lines and they must form a
closed contour.

   If there is an error and the volume is not created, helpful
information is displayed in one window.

   It is possible to add holes to a volume. To do so, it is first
necessary to create the outside and the interior volumes as independent
volumes. After this, push `Hole' button and select the outside volume.
Then, select the interior volumes that form every hole, one by one.
Finish with `escape' (*note Escape::.).

   Orientation of volumes and their surfaces is automatically set to
facilitate a correct meshing.

   An additional feature allows the selection of surfaces that form the
outer part of the volume as well as the ones that form the holes at the
same time. In this case, GiD automatically recognizes the holes.

   Option `Search' lets the user select one surface and create one of
the volumes that contains this surface.

* Menu:

* Automatic 6-sided volumes::


File: gid.info,  Node: Automatic 6-sided volumes,  Prev: Volume creation,  Up: Volume creation

Automatic 6-sided volumes
.........................

   This option creates all possible volumes that have 6 sides. It can
be applied several times over the geometry and volumes are not repeated.

   It can be useful for structured meshing (*note Structured mesh::.).


File: gid.info,  Node: Contact creation,  Next: Intersection,  Prev: Volume creation,  Up: Create

Contact creation
----------------

   Contact surfaces or contact volumes are defined between two lines or
two surfaces that are physically in the same place but with different
entities as surfaces, lines and points. From a contact surface, it is
possible to generate contact elements or algorithms that define special
contact between two bodies.

   Those surfaces that have been generated from another one, although
not physically in contact, or simply, identical surfaces separated by a
movement, can obtain equal meshes from this option, ensuring a
one-to-one relationship between nodes.

   It is necessary to choose `contact surface' or `contact volume' to
create contact surfaces. The first one is between lines and the second
one is between surfaces.  After this, it is necessary to choose lines
in the first case and surfaces in the second.  GiD automatically
searches possible contacts combining selected surfaces in pairs.

   Contact elements are, by default, 4-node planar quadrilaterals for
surfaces and 8-node hexahedra or 6-node prisms (depending on the
geometry) for contact volumes.

   However, the user can select 2-node lines for all cases (*note
Element type::.).

   The 4-node planar quadrilaterals can be converted to the 8-node or
9-node for the quadratic case.

   The user can also select `no mesh' for the contact entity. This
makes it possible to have exactly the same mesh in both lines or both
surfaces but without  any additional element.

   When creating the contact volumes, GiD internally checks what
surfaces occupy the same location in the space and creates the contact,
therefore there is no need to specify what surfaces have to be in
contact. For this reason, several surfaces can be selected at once and
GiD performs the contact automatically, indicating the number of
contact volumes that have been generated.

   For contact surfaces, however, the two lines in contact have to be
specified.

   A feature in GiD is the option of creating `contact separated
volumes' for surfaces that are not physically in contact.

   For these separated volumes, GiD internally checks whether there
exists a unique solid-rigid movement between two surfaces and creates
the contact between both. There is the possibility of the existence of
more than one solid-rigid movement between two of them.  In this
situation, GiD asks for the point image of a particular original point
to define the movement and, consequently, applies the right contact.

   The same considerations about element type for `contact volumes' are
used.


File: gid.info,  Node: Intersection,  Next: Volume boolean operations,  Prev: Contact creation,  Up: Create

Intersection
------------

* Menu:

* Intersection line-line::
* Intersection multiple lines::
* Intersection Surface 2 points::
* Intersection Surface lines::
* Intersection Surface surface::
* Intersection Multiple surfaces::


File: gid.info,  Node: Intersection line-line,  Next: Intersection multiple lines,  Prev: Intersection,  Up: Intersection

Intersection line-line
......................

   With command `Intersect lines', two lines must be selected.  GiD
searches the closest points between the two lines. If the lines do not
intersect, GiD determines the distance between the two closest points,
draws both points and asks for confirmation. Otherwise, the new point
will be the intersection point. If confirmed, the two lines are
converted into four and the second point is moved to the one in the
first line and converted into a unique point (if interior points of one
or two of the lines coincide with endpoints, only two or three new lines
are created). Polylines cannot accept this option.

   Option `No divide lines' creates the intersection point but do not
modify the lines.

   `Note:' This option can be used to extend one line until reaching
the other line.

   *Caution:* Second selected line can have higher entities  only if it
is not necessary the extension of this line.


File: gid.info,  Node: Intersection multiple lines,  Next: Intersection Surface 2 points,  Prev: Intersection line-line,  Up: Intersection

Intersection multiple lines
...........................

   This option lets the user select several lines. Then, it tries to
find as many intersection points between them as possible. Lines are
divided when applicable.

   Option `No divide lines' creates the intersection point but do not
modify the lines.


File: gid.info,  Node: Intersection Surface 2 points,  Next: Intersection Surface lines,  Prev: Intersection multiple lines,  Up: Intersection

Intersection Surface 2 points
.............................

   User must select one surface and two points that lie approximately
over the surface. GiD calculates the line intersection between the
surface and a plane defined by the two given points and the average
normal to the surface in these points.

   `Note:' Planar surfaces can not be used with this option.

   `Note:' *Note Option point in line::, or *Note Option point in
surface::, can be used to define the points.


File: gid.info,  Node: Intersection Surface lines,  Next: Intersection Surface surface,  Prev: Intersection Surface 2 points,  Up: Intersection

Intersection Surface lines
..........................

   User must select one NURBS surface and several lines. GiD calculates
the intersection between the surface and the lines. Lines will be
divided in the intersection point.

   Option `No divide lines' creates the intersection point but do not
modify the lines.

   Option `Extend' Divide lines and also extends lines until they reach
the surface.


File: gid.info,  Node: Intersection Surface surface,  Next: Intersection Multiple surfaces,  Prev: Intersection Surface lines,  Up: Intersection

Intersection Surface surface
............................

   This command creates the intersection lines between two surfaces. If
these lines intersect surfaces contour lines, these are divided.

   Option `No divide lines' creates the intersection point but do not
modify the contour lines.

   Option `No divide surface'. By default the surfaces are divided,
unless this option is selected.


File: gid.info,  Node: Intersection Multiple surfaces,  Prev: Intersection Surface surface,  Up: Intersection

Intersection Multiple surfaces
..............................

   This command creates the intersection lines between surfaces.


File: gid.info,  Node: Volume boolean operations,  Next: Surface boolean operations,  Prev: Intersection,  Up: Create

Volume boolean operations
-------------------------

   The GiD Volume Boolean Modeler has been designed to accomplish
geometric feats as physically punching a hole trough a volume,
combining two volumes into one and creating a new volume from the
intersecting points of two separate volumes.

   The valid volume boolean operations are:

   * `union': fuses two volumes wherever they intersect to create a
     single, more complex volume.

   * `intersection': creates a volume based on the intersecting points
     of two separate volumes.

   * `substraction': negates a specific portion of a volume to create a
     hole or indentation.

   User must select the two volumes (order is important in
substraction).


File: gid.info,  Node: Surface boolean operations,  Next: Object,  Prev: Volume boolean operations,  Up: Create

Surface boolean operations
--------------------------

   User must select the two 2D surfaces located in the XY plane (order
is important in substraction).

   The valid surface boolean operations are:

   * `union': fuses two surfaces wherever they intersect to create a
     single, more complex volume.

   * `intersection': creates a surface based on the intersecting points
     of two separate volumes.

   * `substraction': negates a specific portion of a surface to create
     a hole or indentation.


File: gid.info,  Node: Object,  Prev: Surface boolean operations,  Up: Create

Object
------

   With this command it is possible to create several objects which are:

   * Rectangle

   * Circle

   * polygon

   * sphere

   * cilynder

   * cone

   * prism

   * thorus

   When creating an object, GiD asks for a center and a normal. To
enter the coordinates of the center you can click on the screen or
select an existing point (*note Point definition::.). To enter the
normal, GiD displays a window where you can choose one of the three
axes or enter the coordinates of a point.

   The button In screen of the `Enter normal' window, lets you manually
enter the coordinates of the point which defines the normal: you can
directly click on the screen or pick an existing point using the option
Join C-a of the Contextual mouse menu.

   When using the commands `sphere', `cilynder', `cone', `prism' or
`torus' the volume of the object is also created.


File: gid.info,  Node: Delete,  Next: Edit,  Prev: Create,  Up: Geometry

Delete
======

   The deletion of entities can be done in two ways: at one level
(`point', `line', `surface' or `volume') or erasing all entities at
once. A selection is made (*note Entities selection::.) in both cases.
After pressing `escape' (*note Escape::.), the entities are erased.

   To avoid erasing the selected entities, press `Clear selection'.

   Entities which depend on higher entities, cannot be erased. For
example, if a surface is created over some lines, it is necessary to
erase the surface before erasing the lines.


File: gid.info,  Node: Edit,  Prev: Delete,  Up: Geometry

Edit
====

   There are some particular editing options for geometrical entities:

* Menu:

* 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::


File: gid.info,  Node: Move point,  Next: Explode polyline,  Prev: Edit,  Up: Edit

Move point
----------

   By using this command, an existing point is selected and moved. The
new position is entered in the usual way (*note Point definition::.).
If the new position is an existing point (when using `join'), GiD will
determine the distance between the points and ask if they should be
joined. If answered `yes', both points are converted into one. Lines
and surfaces joined to the point are also moved and deformed to
maintain their links.


File: gid.info,  Node: Explode polyline,  Next: Edit polyline,  Prev: Move point,  Up: Edit

Explode polyline
----------------

   This command lets the user select lines. Lines that are not
polylines or have higher entities or conditions are rejected. After
confirmation, the polylines are exploded and converted into their
original lines. Polylines then disappear (*note Polyline creation::.).


File: gid.info,  Node: Edit polyline,  Next: Edit NURBS line,  Prev: Explode polyline,  Up: Edit

Edit polyline
-------------

   The command `Edit Polyline' allows the user select lines. Lines that
are not polylines are rejected. It is possible to choose several
options for the polylines:

   * Use points: When meshing this polyline, there will be at least one
     node at every point location that defines the polyline. These will
     be the endpoints of interior lines.

   * Not use points: When meshing this polyline, the mesh generator
     ignores the points and therefore, the nodes will be placed
     anywhere. This is the default option. Nodes will only be put in
     the position of a point if there is a 4-sided surface over a part
     of a polyline (*note 4-sided surface automatic creation::.).

   * Only points: When meshing this polyline, the nodes will only be
     placed where the geometry points are.

   `Note:' If one condition is assigned to one interior point of a
polyline (*note Conditions::.), one node of the mesh will be placed over
that point.


File: gid.info,  Node: Edit NURBS line,  Next: Edit NURBS surface,  Prev: Edit polyline,  Up: Edit

Edit NURBS line
---------------

   Once a NURBS line is selected (use the Pick button of the `Edit
NURBS Line' window), it is possible to interactively edit its control
points (*note NURBS line creation::.). Select the control points as if
they were regular points and enter their new positions in the usual way
(*note Point definition::.).

   The `Influence factor' affects the movement propagation of the
neighboring control points.

   Options:

   * Fix boundary Check olption `fix boundary', if you don't want to
     move the boundary control points of the untrimmed surface.

   * Insert knot: User is asked by a knot value between 0.0 and 1.0 and
     this is inserted. Program checks that knot multiplicity is not
     bigger than order (order=degree+1). As the number of knots
     increase, the number of control points also increase. So, this
     option can be used to have more points defining the same curve.

   * Degree elevate: With this option degree of the curve is elevated
     by one. The new curve will have the same shape but with more
     control points and knots.

   * Change Weight: A new positive weight can be introduced for any
     control point, except the end points.

   * Cancel weights: All weights of the NURBS are converted to 1.0 and
     the curve is no more rational.

   * Reparametrize: With the same control points a new curve is
     calculated to get a better curve with a more uniform
     parametrization.

   * Simplify: This option converts the curve to a simplified curve,
     which is an approximation of the original one.


File: gid.info,  Node: Edit NURBS surface,  Next: Hole NURBS surface,  Prev: Edit NURBS line,  Up: Edit

Edit NURBS surface
------------------

   Once one NURBS surface is selected (use the Pick button of the `Edit
NURBS Surface' window), it is possible to interactively edit its
control points (*note NURBS surface creation::.). Select the control
points as if they were regular points and enter their new positions in
the usual way (*note Point definition::.).

   Options:

   * Insert knot: User is asked by a knot value between 0.0 and 1.0 and
     it is inserted. Program checks that knot multiplicity is not
     bigger than order. This option can be used to have more points
     defining the same surface.

   * Degree elevate: With this option degree of the surface is elevated
     by one. The new surface will have the same shape but with more
     control points and knots.

   * Change Weight: A new positive weight can be introduced for any
     control point, except the extremes.

   * Cancel weights: Converts the weights of all the control points to
     1.0

   * Simplify: Simplifies the surface (if possible) removing the less
     significant knots.

   * Reparametrize: Reparametrizes the surface obtaining an optimized
     surface. When a Nurbs surface is not well parametrized, the mesh
     has a worse quality.

   The Movement type menu of the `Edit NURBS Surface' window,
determines the kind of movement of the selected knots. This movement
can be along an axis (X-Axis, Y-Axis, Z-Axis), describing the Normal of
the surface (Normal), following the screen movement of the mouse
(Screen) or the new location of the knot can be defined introducing the
coordinates of a point (Point).

   `Note:' Options `Insert knot' and `Degree elevate' can be chosen for
the `u' or the `v' parameters direction.


File: gid.info,  Node: Hole NURBS surface,  Next: Divide,  Prev: Edit NURBS surface,  Up: Edit

Hole NURBS surface
------------------

   This option let the user select one existing NURBS surface and a set
of closed lines that are inside the surface and that form a hole inside
it.  The lines may be created with an intersection with another surface.
The hole will be added to the existing surface.


File: gid.info,  Node: Divide,  Next: Join lines end points,  Prev: Hole NURBS surface,  Up: Edit

Divide
------

   Command `Divide', can be applied either to lines that are not
polylines or to surfaces (trimmed surfaces included). After selecting
the entity, the division can be given in several ways:

   * Number of divisions: line will be converted in equally spaced
     pieces.

   * Near point: With this option one point must be selected near the
     line.  (*Note Option point in line::, or *Note Option point in
     surface::, can be used).  The line will be divided into two
     entities near that point.

   * Parameter: One factor is given between 0.0 and 1.0 and entity will
     be divided where the parametric variable takes that value.

   * Relative length: One factor is given between 0.0 and 1.0 to divide
     the line with relative arc length ratio equal to the selected
     factor. (same concept as `Parameter' if the curve was arc length
     parameterized).
     If the line is a polyline, the user must choose an existing
     interior point. The polyline will be converted into two lines that
     may or not be polylines.

     Polyline division have an option `Angle' that permits to divide
     the polyline in all the points where the angle between the
     sublines before and after is bigger than the given one.
     *Caution:* An interior point must belong to level one of a polyline
     (*note Polyline creation::.).

   * Surfaces
        - Num divisions: surface will be converted in equally spaced
          pieces.

        - Near point: With this option one point must be selected near
          the surface. The surface will be divided into two entities
          near that point.

        - Parameter: One factor is given between 0.0 and 1.0 and the
          surface will be divide into two where the parametric variable
          takes that value.

        - Split: surface will be divided following the divide lines.
          These lines must intersect the surface contour. (command:
          `Geometry Edit SplitSurf')

     In the case of surfaces it is necessary to give the division sense
     that can be `u' or `v'. This sense can be previously checked with
     the command Edit NURBS Surface. (*note Edit NURBS surface::.)

   Note: After the division, the entity disappears and new entities are
created.


File: gid.info,  Node: Join lines end points,  Next: Swap arcs,  Prev: Divide,  Up: Edit

Join lines end points
---------------------

   With command `Join lines end points', two lines must be selected.
GiD determines the distance between the two closest endpoints, draws
both points and asks for confirmation. If one of the lines is a
polyline, interior points are also considered. If accepted, the  points
are converted into one and the lines are deformed. The new point will
then take the place of the first line's point.

   *Note Move point::, for another method of converting two points into
one.

   *Caution:* Second selected line cannot have higher entities (second
point is moved to first).


File: gid.info,  Node: Swap arcs,  Next: Edit SurfMesh,  Prev: Join lines end points,  Up: Edit

Swap arcs
---------

   This command lets the user select and alter arcs. Lines that are not
arcs are rejected. After confirmation, the arc is converted to a new
arc with the same center and in the same plane but opposite the old
one. The old arc disappears and the angle of the new arc will be
supplementary to the angle of the old arc.

   *Caution:* Arcs with higher entities cannot be swapped.


File: gid.info,  Node: Edit SurfMesh,  Next: Convert to NURBS,  Prev: Swap arcs,  Up: Edit

Edit SurfMesh
-------------

   User must select one or several surface meshes (*note Read surface
mesh::.).  Options are:

   * Draw mesh: Surface will be drawn as a mesh.

   * No draw mesh: Surface will be drawn as a regular surface. With
     magenta lines close to the boundary lines.


File: gid.info,  Node: Convert to NURBS,  Next: Simplify NURBS,  Prev: Edit SurfMesh,  Up: Edit

Convert to NURBS line
---------------------

   This option converts the selected lines or surfaces to NURBS lines
or NURBS surfaces.
Note: Some algorithms only work with NURBS entities.


File: gid.info,  Node: Simplify NURBS,  Prev: Convert to NURBS,  Up: Edit

Simplify NURBS
--------------

   This option converts the selected NURBS lines or surfaces to other
ones very similar to the originals but with and easier definition. It
can be useful for imported data that is defined with a too complex
control polygon and displays or is meshed too slow.


File: gid.info,  Node: Utilities,  Next: Data,  Prev: Geometry,  Up: Top

UTILITIES
*********

   Within `Utilities' there are included some commands that provide
information or allow actions over both the geometry and the mesh.
Others can act over the whole project.

* Menu:

* 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::
* Macros window::
* Selection window::
* Animate controls::
* Dimensions::


File: gid.info,  Node: Preferences,  Next: Renumber,  Prev: Utilities,  Up: Utilities

Preferences
===========

   Note:There are some pre-definitions or ways of working that can be
set in GiD. They can be set in two ways: via the Preferences window or
with the `Preferences' command.  In the following description, the
different Preferences options are shown, giving their associated
variables.

   The first group of Preferences (general preferences) is used to set
different ways of working with GiD:
   * `Splash window:' If this option is set, when program is open again,
     a welcome window is displayed. Variable: `SplashWindow'. Values:
     1,0. Default is 1 (`Yes').

   * `Create new point:' It alters the way how the points are entered
     in GiD (*note Point definition::.). Options are:
        - `Always:' If trying to create a new point in the vicinity of
          an existing one, the new point is always created.

        - `Ask:' If trying to create a new point in the vicinity of an
          existing one, GiD asks the user whether to make use of the
          existing point or create a new one.

        - `Never:' Only allows to select existing points. It can be
          changed interactively  when in creation point mode by setting
          `No join' until all points are entered.  Variable:
     `CreateAlwaysNewPoint'. Respective values: 1,0,-2. Default is 0
     (`Ask').

   * `Display coordinates:' If set, GiD shows the coordinates in the
     graphical window.  Variable: `DisplayCoordinates'. Values: 1,0.
     Default is 1 (`Yes').

   * `Automatic redraw:' If this option is not set, redraws caused by
     window expositions, or by internal functions are not performed.
     This avoids spending a lot of time for large models. Variable:
     `AutomaticRedraw'. Values: 1,0. Default is 1 (`Yes').

   * `Use more windows:' Depending on the selected field, `yes', `no' or
     `beginner', some options are asked to the user inside a new window
     or with a message in the regular messages window. Variable:
     `UseMorewindows'. Values: 1,0,2.  Default is 1 (`Yes').

   * `Backup file:' If this option is set and a model name is given,
     model is saved automatically into that model name with the
     frequency given in the next option.

     *Note:* Mesh is not saved into the backup to save time.  Variable:
     `BackUpName'. Default name is `backup.gid' in current or temporal
     directory.

   * `Backup time:' Number of minutes between each backup save. 0
     minutes means not to save backup.  Variable: `BackUpMinutes'.
     Default is 20 minutes.

   * `Write batchfile:' If this option is set, and a filename is given,
     all commands used during the current session are saved into this
     file. It can be executed later by means of a script file with the
     predefined commands to be run in GiD (*note Batch file::.).
     Variable: `BatchFileToWrite'.

The second group of preferences (graphical) are used to set different
ways of visualizing the model.  They do not change the geometry and the
model information. These preferences are:
   * `Smoothed Elements:' If set and when rendering a mesh (*note
     Render::.), the intersection between elements with a small angle
     between their normals will be illuminated as if it were a
     continuous solid. If not, illumination is made considering every
     element as planar.  Variable: `LightSmoothedElems'. Values: 1,0.
     Default is 1 (`Yes').  The angle (in degrees) is the maximum angle
     between normals of two elements to allow smooth lighting between
     them. If not, one edge is drawn between them.  Variable:
     `CosSmoothedElems'. Saved as the cosinus of this angle. Default is
     0.8.

   * `Surface drawing type:' Lets the user choose how to draw the
     surfaces when in wireframe (normal) mode. Options are:
        - `None:' Surfaces are not drawn.

        - `Boundary lines:' One magenta line is drawn for every contour
          line. This set of lines have a small offset towards the
          interior of the surface.

        - `Isoparametric lines:' Two yellow lines are drawn for every
          NURBS surface.  The one for `u=0.5' and the one for `v=0.5'.

        - `Both:' Draws both modes.

   * `Change color:' It is possible to change the default color of
     several things in the program with this option. One possibility is
     to change the background color of the GiD graphical window. Other
     possibilities are the color of the entities in normal mode (no
     render). Variable: `BackgroundColor'. Value: hexadecimal RGB char.
     And others.

   * `Curve precision:' This option gives the precision used to draw
     curves. The internal definition of curves does not change. In the
     preferences window, it is possible to dynamically change the
     drawing of a curve to test the precision.  Variable:
     `CurvePrecision'. Values: 1.0 to 0.0 from best to worst.  Default
     is 0.8

   * `Surface precision:' This option gives the precision used to draw
     surfaces in render mode. The internal definition of surfaces does
     not change. Variable: `SurfacePrecision'. Values: 1.0 to 0.0 from
     best to worst.  Default is 0.6

   * `Fast rotation:' If set, some options are able to be chosen. These
     options will apply only when rotating. Options are:
        - `points,lines,surfaces,volumes:' To draw or not to draw this
          type of entity when rotating. Variables: the same. Values:
          0,1. Default is 0 (`No').

        - `Always Geometry:' If set, when viewing the mesh and
          rotating, the geometry is drawn instead. Variable:
          `UseAlwaysGeom'. Values: 0,1. Default is 0 (`No').

        - `Draw graphic objects:' If not set, when rotating the
          geometry, some graphical and temporal objects like normals or
          materials or conditions symbols are not drawn.  Variable:
          `DrawGraphicObjects'. Values: 0,1. Default is 1 (`Yes').

        - `Curve precision:' The same as general item `Curve
          precision', but applied only when rotating. Variable:
          `CurvePrecision'. Values: 1.0 to 0.0 from best to worst.
          Default is 0.8 Variable: `FastRotation'. Value: 0,1. Default
     is 0 (`No').
The third group of preferences are meshing options:
Surface meshers can be:

   * `Rfast' The most efficient in speed and reliability. With deformed
     surfaces can give distorted elements.

   * `Rsurf' Meshes are generated directly in the space. Quality is
     better but it is slower and can fail for distorted surfaces.

   * `2dumg' Its use is deprecated.

   These generators are based on the advancing front generation mesh
technique in order to improve speed and portability.

   *Note:* GiD can internally try another mesher when one of them fails
to generate the mesh for one surface.

   * `Mesh until End' If this preference is set, the mesh generator
     will continue until end although there are surfaces or volumes
     that cannot be meshed.

   * `Automatic correct sizes'  If this preference is set, just when
     meshing begins, there is a correction to the meshing sizes
     assigned to entities so as to improve meshing.

   * `Unstructured size transitions:' It controls whether the
     transitions between different element sizes are slow or fast.

   * `Allow automatic structured:' If this preference is set, functions
     like `Assign sizes by Cordal Error' will define some surfaces as
     structured with highly distorted elements over them.

   * `Smoothing:' Options for smoothing to enhance the mesh after the
     generation. Options are:
        - `Nomal:' only the standard smooth is performed.

        - `HighAngle:' an additional smooth with angle criteria is
          performed.

        - `HighGeom:' an additional smooth with cordal error criteria
          is performed.

   * `Mesh always by default:' Changes the default meshing criteria.
     Entities will always be meshed even if they have higuer entities.
     Example: If surfaces are checked, when meshing a volume, volume
     elements and surface elements will be obtained.
The fourth group of preferences are the geometry import and collapse
options:
   * `Automatic Collapse After Import:' If this option is set, after
     reading one IGES file, one global collapse is made. If not, every
     surface and line will be independent from each other.  Variable:
     `AutoCollapseAfterImport'. Default is active (1).

   * `Import tolerance:' When importing a file or collapsing, the
     points closer than this distance are considered to be unique
     (*note IGES read::.). Lines and surfaces can also be collapsed.
     Variable: `ImportTolerance'. Default is 0.0001.

   * `Collapse'
        - `Ignoring Layers:' entities are collapsed also if they belong
          to different layers.

        - `Each layer separately:' entities in different layers are not
          collapsed. (Entities belonging to frozen layers are never
          considered).  Variable: `CollapseIgnoringLayers'. Value is 1.

   * `IGES:Ignore invisible entities:' If this option is set, entities
     with 'invisible' flag in an IGES file are ignored. If it is not
     set, all these entities are sent to a layer with name: "Invisible".
     Variable: `IGESIgnoreInvisible'. Value is 1.

   * `IGES: Curve on surface from 3D:' If this option is set, the IGES
     curves on surface entities are created from the direct 3D space
     definition (recommended); if the option is not set, IGES curves
     are created form the surface space parameter definition.
The fifth group of preferences are the fonts used inside GiD:
   * `Normal font:' This is the font normally used inside GiD.

   * `Fixed font:' This font must have the same spacing for every
     letter. It is used in places where this property is necessary.

   * `Big font:' Used in some dialog boxes.

   * `Comments font:' Used for comments.


File: gid.info,  Node: Renumber,  Next: Calculator,  Prev: Preferences,  Up: Utilities

Renumber
========

When creating new entities, the label of the new entity will be the
lowest number greater than 0 that still does not exist for this entity
type. If an entity is deleted, a gap is left in the label's list. This
gap would be filled with new entities but it is possible to renumber
the geometry to change the former entity labels.  There are no problems
with materials and conditions applied to entities.

   In geometry mode, the renumbered entities are the geometrical ones.
In mesh mode, the renumbered entities are the meshed ones. In this case,
renumbering not only fills the gaps in the labels list but also changes
the node numbers so as to minimize the difference of node numbers
within each element.  This can be useful when the calculating module
uses band or skyline storage methods.

   *Note:* It is usually not necessary to use this command because it is
automatically applied when generating the mesh.


File: gid.info,  Node: Calculator,  Next: Id,  Prev: Renumber,  Up: Utilities

Calculator
==========

   This option opens a scalar and vectorial calculator. It has its own
help. Try button 2 or 3 over one button.

   It's possible to transfer scalar and vector and points and distances
from and to the calculator and the main graphical display.


File: gid.info,  Node: Id,  Next: Signal,  Prev: Calculator,  Up: Utilities

Id
==

   This command gives the label and coordinates of an existing or new
point.

   Options are:
   * `Line parameter:' Selecting a line and given the line parameter
     (t) from 0.0 to 1.0, the point belonging to that line and t is
     returned.

   * `Surface parameter:' Selecting a surface and given the surface
     parameters (u,v) from 0.0 to 1.0, the point belonging to that
     surface and u,v is returned.


File: gid.info,  Node: Signal,  Next: List,  Prev: Id,  Up: Utilities

Signal
======

   With this option, the user can select one entity (point,line surface
or volume), and a pair of crossed lines in the graphical window signal
the center of the entity.

   They must be existing entities, except the especial case of point or
nodes, where they can be existing or defined with any of the usual
methods.

   Option `Superpose Lines' is useful when in render mode. Depending
whether it is set or not, lines will be always in front or the object or
they can be partially hidden by the model.


File: gid.info,  Node: List,  Next: Status,  Prev: Signal,  Up: Utilities

List
====

   Command `List' gives information about the selected entities. This
information is read only.

   If option `Mass' is checked, information about physical properties
is given: length of lines, center of masses, area of surfaces, volume of
solids. It works either for the geometry or for the mesh.


File: gid.info,  Node: Status,  Next: Distance,  Prev: List,  Up: Utilities

Status
======

   Option `Status' gives information about useful general data of the
project.


File: gid.info,  Node: Distance,  Next: Draw line normals,  Prev: Status,  Up: Utilities

Distance
========

   Command `Distance' gives the distance between two existing or new
points.


File: gid.info,  Node: Draw line normals,  Next: Draw surface normals,  Prev: Distance,  Up: Utilities

Draw line normals
=================

   Command `DrawNormals. Lines' draws the sense of the selected lines.

   If the line lies on the plane `z=0', apart from the sense, GiD
displays the normal of the line in 2D.

   Viewing commands (zoom, rotation, etc.) can be applied and the
normals remain on the screen.

   It is possible to swap the sense of the lines using the options `All
swaped' or `Swap some'.

   Options are:

   * `Swap some' changes the sense of the selected lines.

   * `All swaped' changes the sense of all lines asking confirmation
     for the change.


File: gid.info,  Node: Draw surface normals,  Next: Copy,  Prev: Draw line normals,  Up: Utilities

Draw surface normals
====================

   Command `DrawNormals. Surfaces' draws the normals of the selected
surfaces.

   Surfaces belonging to the plane `z=0' will have, by default, its
normal oriented towards the z positive. Then, they are defined as
anti-clockwise surfaces in 2D.

   It is possible to swap the sense of the normals when the
corresponding surfaces do not belong to higher entities.

   Options are:

   * `Swap some:' changes the sense of the normals of the surfaces after
     selecting them again.

   * `All swaped:' changes the sense of all selected surfaces, asking
     for confirmation for the change.

   * `Swap group:' changes normals of all selected surfaces or elements
     so as all of them have its normal to the same sense that adjacent
     entities.  This sense is arbitrary but common to all adjacent
     entities.

   * `Sel by normal:' user is prompt to enter a vector and selection is
     reduced to entities that have their normal in the same sense (dot
     product positive) as the given normal.

   * `Color:' With this option set, all surfaces are draw with filled
     color.  Their front side will be drawn with their regular color,
     and their back face with yellow.

   *Note:* Volumes are correctly oriented by GiD, regardless of their
surface orientation.


File: gid.info,  Node: Copy,  Next: Move,  Prev: Draw surface normals,  Up: Utilities

Copy
====

   `Copy' is a general function that allows the user select a group of
entities and copy them with a movement that can be `translation',
`rotation', `mirror',`scale' or `offset'. The process is:

   Select the type of entities to copy: `point', `line', `surface' or
`volume', when being in geometry mode, or option `nodes' or `elements',
when being in mesh mode. All the lower entities that belong to the
selected ones will be automatically computed.  the type of movement
needs to be chosen and the parameters for the movement are defined.
Options are:

   * rotation: It is necessary to either enter two points in 3D or one
     point in 2D.  These two points define the rotation axis and its
     orientation. In 2D, the axis goes from the defined point towards z
     positive. Enter the angle of rotation in degrees. It can be
     positive or negative. The sense is defined by the right hand rule.
     In 2D, the sense is counter-clockwise.

   * translation: It is defined by two points. Relative movements can
     be obtained defining the first point as 0,0,0 and considering the
     second point as the translation vector (*note Point definition::.).

   * mirror: It is defined by three points that cannot be aligned.
     These points form a plane that is the mirror plane. In 2D, the
     mirror line is defined by two points.

   * scale: It is defined by a center and a point. Every coordinate of
     the point is the scale factor for every `x,y,z' axis. Scale factor
     greater than one, increases size, while less than one decreases
     the size. It may also be negative, changing the sign of the
     corresponding coordinates.

   * offset: It is defined by one positive or negative scalar
     magnitude. It will move each entity in the sense of its normal, the
     magnitude given. In 2D, normal is considered to lie in the `z=0'
     plane. This option works either for lines, surfaces or for mesh
     elements.
   * sweep: This is an option for copying figures along a line (path
     line). You can just copy the figures (and then specify a number of
     copies) or extrude them. Both methods have basically the same
     options.

     The extrusion (and the copy) starts always on the start point of
     the path line.  If you select 'twist mode' to be on, then the
     relative position of the figure to copy respect to the start of
     the path line is conserved along the line.

     In a non-planar curve, there is not only curvature, but also
     torsion. This may cause some unexpected behavior, because the
     figure has also a rotation along tangent direction of path:

     Next it's used 'XY plane' option, that makes certain initial
     vector to remain in this plane during extrusion. (In this example,
     axis is Z).

     Option 'ByDer2' uses the second derivate of the path line as a
     normal to the plane in which that initial vector have to remain.

     A rotation along the path line can be forced using 'Angle'
     parameter (degrees):

     Finally, if path line is a polyline, then the extrusion will be
     divided in several parts:

   Other available options are:
   * extrude: This option can be set to either lines or surfaces or
     volumes. When a movement is selected, the copy is made and lines
     connecting the old and the new points are created.  These lines
     will be either straight lines or arcs depending on the movement
     type.  If extrude surface is chosen, NURBS surfaces connecting old
     and new lines will also be created. If `Volumes' is chosen, the
     volume contained between old and new surfaces is also created.
     This option is not allowed when copying volumes.

   * mcopy: Selecting this option and giving the number of repetitions,
     the operation selected is performed this number of times. This
     option is not available for `mirror'.

   * create contacts: Creates separated contact volumes (*note Contact
     creation::.) for every copied surface. This option is only
     available when copying surfaces.

   * Duplicate entities: If this option is not set, when an entity
     after the `copy' operation occupies the same position than an
     existing one that does not belong to a frozen layer, both entities
     are converted into one.  Mantain layers: If this option is not set
the new entities created will be placed in the layer to use; otherwise,
the new entities are copied to the same layers as their originals.

   *Note:* Entities belonging to a frozen layer (*note Layers::.), are
not checked when sharing old entities.


File: gid.info,  Node: Move,  Next: Repair,  Prev: Copy,  Up: Utilities

Move
====

   This command works like the command `Copy' but moves the entities
instead of copying  them. The program checks automatically if some of
the entities must be copied instead of moved (for this reason, these
entities belong also to non-selected entities of higher level) and
performs the corresponding operation.

   Options like `Extrude', `Multiple copy' and `Create contacts' are
disabled for movements.


File: gid.info,  Node: Repair,  Next: Collapse,  Prev: Move,  Up: Utilities

Repair
======

   This option checks the coherence of the database information. Only
use it if there are problems. When used, a window notifies repaired
items and may give some warnings about incorrect entities.


File: gid.info,  Node: Collapse,  Next: Uncollapse,  Prev: Repair,  Up: Utilities

Collapse
========

   The function  `Collapse' convert coincident entities or entities
that are close each other into one.

   The variable `ImportTolerance' (*note Preferences::.), controls the
maximum distance between two adjacents points to be converted into one.
With lines and surfaces, a maximum distance between both entities is
calculated and when it is less than `ImportTolerance', they are
converted into one.

   Select the type of entities: `point', `line', `surface' or `volume',
when being in geometry mode. All the lower entities that belong to the
selected ones will be automatically computed. After pressing `escape',
collapse is performed.

   Option `Model' performs the operation over all the entities of the
model.

COLLAPSING MESH:

   When a mesh is created the collapse menu changes and it's possible
to collapse edges, nodes, elements or the entire mesh.
   * Collapse edges joins nodes which are connected by edges shorter
     than the Import Tolerance value.

   * Collapse nodes asks you to select some nodes. The nodes which are
     closer than the Import Tolerance value, are collapsed.

   * Collapse elements asks you to select some elements. Then, the
     nodes of these elements which are closer than the Import Tolerance
     value, are collapsed.

   * Collapse mesh collapses all the nodes of the mesh.

   *Note:* Entities belonging to a frozen layer (*note Layers::.), are
not checked when collapsing.


File: gid.info,  Node: Uncollapse,  Next: Undo,  Prev: Collapse,  Up: Utilities

Uncollapse
==========

   Function uncollapse permits the user to select either lines or
surfaces and duplicate boundary entities.

   Typically, if two surfaces share one line as an edge, after applying
this function to both surfaces, that line will be duplicated and every
line will belong to a different surface.


File: gid.info,  Node: Undo,  Next: Comments,  Prev: Uncollapse,  Up: Utilities

Undo
====

   This command allows the user undo any previous commands executed
since the last time the project was saved or read. To do this, the user
must select in the undo window the set of commands that have to be
undone.


File: gid.info,  Node: Comments,  Next: Graphical,  Prev: Undo,  Up: Utilities

Comments
========

   This facility is included to add comments to the pictures obtained
through GiD (*note Print to file::.). Three lines are allowed and with
the `Comments' button the user can impose their printing on the screen
to foresee mistakes or perform changes before printing.

   All the comment lines have their corresponding input button and the
literal text, written into the command line between double-quotes, will
be the output.


File: gid.info,  Node: Graphical,  Next: Coordinates window,  Prev: Comments,  Up: Utilities

Graphical
=========

   In this menu there are some options to change the windows
appearance. They can be inside another window or independent or
disappear. Windows are:

   * Toolbars: Selecting this option the following window appears:

     With this window the position: inside, outside, top left, bottom
     right, etc.  of following item can be configured, or siwtched on
     and off.

        - Geometry & View bar and Standard bar: icon toolbars used to
          perform certain operations. Use middle or right button over
          an icon to get help.

        - Right buttons: These are the buttons that appear usually in
          the right side of the windows. They can perform most of the
          actions of the program.

        - Command line: Inferior line where it is possible to write
          commands.

        - Up menu: Menus located over the graphical window.

     *Note:* To make the `Up menu' appear again, shortcut `Control-U' or
     `Control-Shift-u' can be used.


File: gid.info,  Node: Coordinates window,  Next: Read batch window,  Prev: Graphical,  Up: Utilities

Coordinates window
==================

   This option opens a window used to enter points (*note Point
definition::.).  It can be used in any place where it is possible to
enter one point.

   To accept one point in this window, press `Accept' or press the
`Return' key.

   Option `Coordinate system' allows the user select between:

   * Cartesian: Cartesian coordinate system.

   * Cylindrical: User enters the radius in XY plane, the
     anti-clockwise angle in plane XY from x axe(theta), and the z
     coordinate.

   * Spherical: User enters the radius, the anti-clockwise angle in
     plane XY from x axe(theta), and the angle with z axe(phi).

   Option `Local axes' allows the user choose:

   * Global: Global axes.

   * Relative center: User defines a center of coordinates. All new
     points created with this window will be related to this center. In
     the window where the relative center is entered, user can select
     with button `Pick' a point from graphical window.

   * Relative last: Last point entered is the relative center of
     coordinates.

   * Define new...: It allows the user define a new local axes. Once
     defined, user can select it.

   * Any local axes: All local axes defined with *Note Local axes::,
     will be listed here. Points entered will be related to this axes.

   `New point' shows the current way of entering points. Button `Change'
opens the preferences window (*note Preferences::.) where it can be
changed.

   Button `Pick' allows the user select a point from the window and it
is inserted in the point fields. Then it can be edited and used.


File: gid.info,  Node: Read batch window,  Next: Clip planes,  Prev: Coordinates window,  Up: Utilities

Read batch window
=================

   A batch file can be read to execute some functions (*note Batch
file::.) or to create an animated view of these operations. This latter
case can be performed with the `Read batch window'.

   Once selected a file, it is possible to execute it interactively and
make it stop in some interesting parts. To allow all the movements
(rotations and so on) be executed in the same way that originally,
option `Write rotations in batch:' must be set in preferences (*note
Preferences::.), when creating the batch.

   There are several ways to stop the running batch. One of them is to
include stops in the show file section with the `Mark break' button,
and selecting `Internal stop'. This marks can be saved in the batch
file with button `Write...'.

   Option `Show info' lets the program write all the usual messages in
the GiD messages window.


File: gid.info,  Node: Clip planes,  Next: Save configuration file,  Prev: Read batch window,  Up: Utilities

Clip planes
===========

   Clip planes is a way not to draw the geometry or mesh that is very
close or very far to the viewer.

   Moving `Near plane', hides the geometry that is closer to the viewer.
Moving `Far plane', hides the geometry that is further to the viewer.

   To see the changes dynamically, select `Dynamic update'.  Option
`Fixed distance', allows a constant distance between both planes.

   A new rotation center can be chosen or selected from the window.

   Option `Increase boundaries', increments the ends in the bars of Far
plane and Near plane.

   *Note:* All this information is reset when performing a `zoom frame'.
(*note Zoom::.).


File: gid.info,  Node: Save configuration file,  Next: Perspective,  Prev: Clip planes,  Up: Utilities

Save configuration file
=======================

   It is possible to save a window configuration into a file.  Then if
GiD is open again with option -c (*note Invoking GiD::.) and this file,
the windows are open in the same place and size.


File: gid.info,  Node: Perspective,  Next: Change Light Vector,  Prev: Save configuration file,  Up: Utilities

Perspective
===========

   By default, a model is viewed inside GiD using orthogonal projection.

   With this option, it is possible to change to a perspective
projection.  In this mode, the user can choose a distortion factor for
the perspective. This can be updated dynamically.


File: gid.info,  Node: Change Light Vector,  Next: Macros window,  Prev: Perspective,  Up: Utilities

Change Light Vector
===================

   With this option the user can change the *VECTOR* of the light
direction interactively or just entering the *VECTOR* components on the
command line.

   Options are:

   * `Default Vector:' with this option the ligth direction vector
     changes to its default value.

   * `Change Z Sign:' here the user tells the program if the light
     comes from the front of the object, or from behind the object.
     The mouse cursor are changed arcondingly.


File: gid.info,  Node: Macros window,  Next: Selection window,  Prev: Change Light Vector,  Up: Utilities

Macros window
=============

   Window 'Macros' permits to create sequences of commands and give a
name to them. This group of commands can also be recorded from one
execution set inside the program.

   It is possible to assign a keyboard shortcut to a given macro.

   *Note:* Macros are considered as a user preference and not related
to the active model. So, to transfer a set of macros from one user to
another it is necessary to check the files: `gid.ini' or `.gidDefaults'.


File: gid.info,  Node: Selection window,  Next: Animate controls,  Prev: Macros window,  Up: Utilities

Selection window
================

   In these functions where the user has to select some entities
(creation of a surface or a volume, copy of entities ...) it is
possible to use the selection window. The selection window lets you
take control of the selection process.

   Note: the option `Sel window' is only avalaible in the mouse menu
during the selection process.
The selection window has the following options:

   * `Select all': if this option is chosen all entities are selected.
     If a filter is selected, the filter is applied to all entities.

   * `From, To': this option lets the user select a range of entities.
     If a filter is selected, the filter is applied only to that range
     of entities. To see the id numbers of entities, use the `Label'
     command (*note Label::.).

   * `Mode': there are three selection modes:
        - Swap: if you select an entity which is already selected, the
          entity deselects, and viceversa.

        - Add: in this mode it's impossible to deselect an entity. Only
          new entities are added to the current selection.

        - Rem: in this mode it's impossible to select an entity. This
          mode is used to remove entities of the current selection.

   * `Filter': if a filter is selected, only the entities that
     accomplish with the filter criteria will be selected. This menu
     changes depending on what type of entity is being selected:
          POINTS
        - Higher entities: given a point, number of lines to which it
          belongs.
          LINES
        - Higher entities: given a line, number of surfaces to which it
          belongs.

        - Min. length: selects only the lines which its length is
          smaller than the given length.

        - Max. length: selects only the lines which its length is biger
          than the given length.

        - Entity type: type of line
          SURFACES
        - Higher entities: given a surface, number of volumes to which
          it belongs.

        - Entity type: type of surface.
          VOLUMES
        - Entity type: type of volume.
          ELEMENTS
        - Bad Min Angle: number of minimum degrees accepted (*note Mesh
          quality::.).

        - Bad Max Angle: number of maximum degrees accepted (*note Mesh
          quality::.).

        - Element type: type of element. (*note Element type::.)
   * `Clear': Clears the current selection.


File: gid.info,  Node: Animate controls,  Next: Dimensions,  Prev: Selection window,  Up: Utilities

Animate Controls
================

   This windows allows the creation of animations while using GiD.  Any
of these format can be selected: MPEG, AVI True Color, AVI 15bpp
(reduced number of colors: 32768) and GIF. AVI with MJPEG compression
is also supported.  After giving a name and a delay time between frames
(for 20 frames per second, a delay of 1/20 = 50 ms. should be entered)
the process can start just clicking on the start button ( `film roll
and arrow' button), the green led will change to red.

   The user can add frame by frame the pictures he wants into the
animation file just clicking on the `film roll and arrow' button.  The
option Save redraws tells GiD to save every redraw automatically into
the animation file, so no user intervention is needed to store frames.

   The animation can be finished at any time just pressing the `closed
film roll' button, the red led will change to green.

   *Note:* To avoid problems when trying to view an MPEG format
animation in Microsoft Windows, it is strongly recommended to use the
Default menu to select a 'standard' size and press the Resize button.
The graphical window will change to this 'standard' size.  After
finishing the animation, just selecting Default on the menu and
pressing the Resize button, the previous size will be restored.

   *Note:* The AVI files with MJPEG compression, can be viewed with
`xanim' on Linux and unix machines, and with DirectX 8.x installed in
Microsoft Windows machines.


File: gid.info,  Node: Dimensions,  Prev: Animate controls,  Up: Utilities

Dimensions
==========

   With the `dimensions' option it's possible to add textual
information to your model. That information can be changed of layer or
deleted.

   There are the following options:

   * vertex: shows the coordinates of a vertex. Click over an existing
     point and then click where you want the dimension to be written.

   * distance: shows the distance between two points. You'll have to
     select two points and then click where you want the dimension to
     be written.

   * angle: shows the degrees of an angle. You'll have to select three
     points and then click where you want the dimension to be written.

   * radius: shows the center and radius of an arc. You'll have to
     select an existing arc and then click where you want the dimension
     to be written.

   * text: shows a text string defined by the user. Enter the text and
     click where you want the text to be written.
Deletes a "dimension". Select the dimension you want to delete and
press ESC.

Select the dimension you want to edit, change the text, and click OK.

This option lets you change the appearence of a "dimension"; a
"dimension" can be drawn with or without a box. Choose `ShowBox' on or
off, select a "dimension" and press ESC.


File: gid.info,  Node: Data,  Next: Meshing,  Prev: Utilities,  Up: Top

DATA
****

   All the data that defines the problem and that is managed in the
data menus, depends on the problem type and will change for every
different problem type. The following help will describe the common
interfaces to all the possible data.

   Data for a problem is defined by the following parameters: conditions
(*note Conditions::.), materials properties (*note Materials::.),
problem data (*note Problem data::.) and intervals data (*note Interval
data::.) that define the problem. The conditions and materials have to
be assigned to geometrical entities. It is also possible to define new
reference systems (*note Local axes::.).

* Menu:

* Problem type::
* Transform problem type::
* Internet Retrieve::
* Conditions::
* Materials::
* Problem data::
* Intervals::
* Interval data::
* Local axes::


File: gid.info,  Node: Problem type,  Next: Transform problem type,  Prev: Data,  Up: Data

Problem type
============

   This option permits to select between all installed problem types.
When selecting a new problem type, all information about materials,
conditions and other data parameters that were already selected or
defined is lost.

   Option `Others...' permits to enter one installed problem type or one
that is in the current directory. This last possibility is useful when
creating a new problem type and it cannot be installed until finished.

   *Note:* When defining a new problem type, as this is not installed,
it must be selected by other means. One possibility is to use the
'Others...' possibility in the 'problem types' menu. Another
possibility is to use  the following commands in the right buttons menu
or written in the command line: `data defaults problemtype'.

   One problem type is considered to be installed when it is copied to
the GiD executable directory or inside the subdirectory `problemtypes'
or inside another subdirectory inside this last.


File: gid.info,  Node: Transform problem type,  Next: Internet Retrieve,  Prev: Problem type,  Up: Data

Transform problem type
======================

   This option can be found inside `Problem type' menu and is useful to
actualize one model from an old problem type to a newer one that is
similar to the first.

   When converting, it tries to maintain all the conditions and
materials assigned to the geometry or mesh. Also, it tries to maintain
the rest of the data.

   It will be typically used when a problem type has been updated and is
necessary to use again a model defined with the old version.


File: gid.info,  Node: Internet Retrieve,  Next: Conditions,  Prev: Transform problem type,  Up: Data

Internet Retrieve
=================

   With this option it's possible to download new problem type's or
update existing ones.

   Note: it's necessary to be connected to the internet to use this
option.

   Use button Retrieve list to get the list of available Problem
Type's. Then, click on the items of the list and use buttons Module
info and Module news to get information about them.

   Use button Retrieve module to download the selected Problem Type.


File: gid.info,  Node: Conditions,  Next: Materials,  Prev: Internet Retrieve,  Up: Data

Conditions
==========

   Conditions are all the properties of a problem (except materials),
that can be assigned to an entity.

   One example would be the boundary forces and displacement
constraints in a solid mechanic analysis or initial velocities in a CFD
analysis. Information about contact between master-slave nodes can also
be considered as `conditions'.

   *Caution:* If a mesh has already been generated, any change in the
condition assignments, requires to mesh again to transfer these new
conditions to the mesh. If this new generation has not been made, user
will be warned when the data for the analysis is being written.

* Menu:

* Assign condition::
* Draw condition::
* Unassign condition::


File: gid.info,  Node: Assign condition,  Next: Draw condition,  Prev: Conditions,  Up: Conditions

Assign condition
----------------

   The condition is assigned to the geometric entities or layers with
the given field values.

   If assigning from the command `Assign Cond', the option `Change'
allows the definition of the field values. Do not forget to change
these values before assigning. Option `Delete all' erases all the
assigned entities of this particular condition.

   Conditions can be assigned both on the geometry and on the mesh but
it is advisable to assign them on the geometry and the conditions will
then be automatically transferred to the mesh. If assigned on the mesh,
when remeshing, conditions are lost.

   Conditions that are to be attached to the boundary of the elements,
are assigned to the elements and GiD searches the boundaries of the
elements that are boundaries of the total mesh.

   Option `Unassign' inside `AssignCond', permits to unassign this
condition. It is also possible to unassign from only certain entities.

   *Caution:* If a mesh has already been generated, for any change in
the condition assignments, it is necessary to mesh again.

   Some conditions may have a behavior that depends on the type of the
chosen axes.  The user can choose whether to use global axes or any of
the local axes previously described with the command `Local axes'
(*note Local axes::.), or, alternatively, another option of automatic
local axes calculations. In this latter case, different axes are created
according to the adopted criteria of tangency and orthogonality with
the geometry.

   The user can apply all graphical functions (`zoom', `rotate', ...)
and all the condition symbols are maintained in active mode in the
graphical window until the user selects `escape' or presses `Finish' in
the conditions window.


File: gid.info,  Node: Draw condition,  Next: Unassign condition,  Prev: Assign condition,  Up: Conditions

Draw condition
--------------

   Option `Draw all' draws all the conditions assigned to all the
entities.  This means to draw a graphical symbol or condition name over
every entity that has this condition.

   If one particular condition is selected, it is possible to choose
`Draw' only some field. `Draw' is like `Draw all' but only for one
particular condition. If one field is chosen, the value of this field
is written over all the entities that have this condition assigned.

   When the condition has any field referred to the type of axes, the
latter can be visualized by means of `Draw local axes'.

   Option `Draw colors' Draws groups of entities with different colors
depending on the values assigned to them for this condition.


File: gid.info,  Node: Unassign condition,  Prev: Draw condition,  Up: Conditions

Unassign condition
------------------

   In window mode, command `UnAssign' lets the user choose between three
possibilities:

   * Unassign one condition from some selected entities.

   * Unassign one condition from all the entities that may have this
     assigned.

   * Unassign all conditions from all the entities that may have them
     assigned.

   In command mode `UnAssing', do it for all the conditions. To
unassign only one condition, use command `Delete All' (*note Assign
condition::.).


File: gid.info,  Node: Materials,  Next: Problem data,  Prev: Conditions,  Up: Data

Materials
=========

   For any problem that needs definition of materials, there is a
database of existing materials that can be assigned to entities. The
user can also create new materials derived from existing ones and
assign them as well.

   *Caution:* If a mesh has already been generated, for any change in
the assigned materials, it is necessary to mesh again or assign the
materials directly to the mesh.

* Menu:

* Assign material::
* Draw material::
* Unassign material::
* New material::
* Import/Export material::


File: gid.info,  Node: Assign material,  Next: Draw material,  Prev: Materials,  Up: Materials

Assign material
---------------

   The material is assigned to the selected entities.

   If assigning from a window, every time the assigned material
changes, button `Assign' must be pressed again.

   The user must select the entity where to assign the materials over:
`line, surface or volume' when working in geometry mode or directly
over the `elements' when working in mesh mode.

   If assigning from the command line, option `UnAssignMat' erases all
the assignments of this particular material.

   *Caution:* Although a mesh had been already generated, for any change
in the assigned materials, it is necessary to mesh again or assign the
materials directly to the mesh.


File: gid.info,  Node: Draw material,  Next: Unassign material,  Prev: Assign material,  Up: Materials

Draw material
-------------

   This option draws a color indicating the selected material for all
the entities that have the required material assigned. It is possible
to draw just one material type or alternatively, draw all materials. To
select some of them use `a:b' and all material numbers that lie between
`a' and `b' will be drawn.


File: gid.info,  Node: Unassign material,  Next: New material,  Prev: Draw material,  Up: Materials

Unassign material
-----------------

   Command `Unassign' unassigns all the materials from all the
entities. For only one material, use `UnAssignMat' (*note Assign
material::.).


File: gid.info,  Node: New material,  Next: Import/Export material,  Prev: Unassign material,  Up: Materials

New material
------------

   When using command `NewMaterial', a new material is created taking
an existing one as a base material. Base material means that the new
material will have the same fields as the base one. Then, all the new
values for the fields can be entered in the command line.

   It is possible to redefine an existing material.

   To create a new material or redefine an old one in the materials
window, write a new name or the same one and change some of the
properties. Then, push `Accept'.


File: gid.info,  Node: Import/Export material,  Prev: New material,  Up: Materials

Import/Export material
----------------------

   It is possible to import and export materials from the model
database to one external database. Typically, one centralized database
of materials is mantained and every new model gets its properties from
there.

   *Note:* If it is desired to interchange materials with the `Problem
type' database, it is necessary to check that the current user has
enough permissions to read/write in that directory.


File: gid.info,  Node: Problem data,  Next: Intervals,  Prev: Materials,  Up: Data

Problem data
============

   Problem data refers to all the data that is general to the problem.
This means that it is not related to a geometrical entity and it does
not change in every interval of the analysis.

   It can be entered with the command `ProblemData' or in the problem
data window.

   If entered in a window, the data is not accepted until the  button
`Accept' is pressed.

   This data can be entered before or after meshing.


File: gid.info,  Node: Intervals,  Next: Interval data,  Prev: Problem data,  Up: Data

Intervals
=========

   Intervals are a way to separate some information into several
groups. The information that can be duplicated for every group can also
be duplicated, if desired. When a new interval is defined, it is
possible to copy all the new information about conditions, assigned to
entities or not.

   Therefore, the correct way to work is to define all the conditions
first and afterwards create the new intervals.

   Options are:

   * New: It is allowed to define as many intervals as desired with
     this command.  When creating a new one, user can choose whether
     copy the assigned conditions or not. To copy them, conditions must
     already be assigned (*note Conditions::.).

   * Current: Chooses the current interval to use. Next assigned
     conditions or interval data (*note Interval data::.), will be
     considered inside this interval.

   * Delete: Deletes one existing interval and all its related data.

   These groups called intervals can be used to change some conditions
or information like increment factor in an incremental analysis.  It
may also be useful to define some load states for the same geometry.


File: gid.info,  Node: Interval data,  Next: Local axes,  Prev: Intervals,  Up: Data

Interval data
=============

   This is the amount of information that is maintained different for
every interval (*note Intervals::.).

   It can be entered with the command `IntervalData' or in the
intervals data window.

   If entered in a window, the  data is not accepted until button
`Accept' is pressed.

   This data can be entered before or after meshing.


File: gid.info,  Node: Local axes,  Prev: Interval data,  Up: Data

Local axes
==========

   With this option, GiD allows to define new different coordinates
reference systems.  It is possible to write them, not only as cartesian
reference systems, but also referring to as Euler angles. All user
defined systems are automatically calculated and can be visualized one
by one or all together.

   There are several ways to define new local axes:

   * `3 Points XZ' User enter three points that corresponds to the
     origin, the X-direction and the Z-direction. The origin and the
     last introduced point define the Z-axis, whereas the second point
     indicates the side of the `x-z' plane where the point lies.

   * `X and angle' User enter 2 points and one angle. The first one is
     the center, the second one indicates the X-axe and the angle
     indicates the position of the Y and Z axes. In the graphical
     window, it is possible to set dynamically this angle by moving the
     mouse. It also indicates where the origin of the angle is. The
     angle can be either enter by pressing the mouse or by entering the
     exact value in degrees.

   When defining local axes, the definition mode is done through three
points `3PointsXZ', what

   Local axes can later be used when creating a point (*note Point
creation::.) or in some conditions that have a field related to these
axes (*note Conditions::.).


File: gid.info,  Node: Meshing,  Next: Calculate,  Prev: Data,  Up: Top

MESHING
*******

   Generating a mesh is the process where a finite element mesh is
calculated from the geometry definition. This mesh will be used for the
FEM analysis in a later step.  Conditions (*note Conditions::.) and
materials (*note Materials::.) assigned to geometric entities will be
transferred to the nodes and elements of the new mesh.

   What is meshed and how, is controlled by some default options which
can be changed with the commands described later.

   The generation does not depend on the state ON/OFF of the layers at
the moment of the generation (*note Layers::.), but frozen layers are
not meshed if the preference `NoMeshFrozenLayer' is selected (*note
Preferences::.).  Every node and element will be assigned to the layer
in which the original geometrical entity was defined.

   Defaults are:

   * An entity is meshed if does not belong to a higher level entity.

   * A line mesh is made of two-noded elements and a surface mesh is
     made of non-structured triangular elements. The default for
     structured meshes are quadrilateral elements.  Volume meshes are
     composed by non-structured tetrahedral elements.  Structured
     volume meshes are composed by hexahedra.

   All these default elements use linear interpolations for the unknown
variables.

* Menu:

* 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::


File: gid.info,  Node: Generate,  Next: Mesh view,  Prev: Meshing,  Up: Meshing

Generate
========

   When everything is ready for mesh generation, select this command.
If there is a previously generated mesh, GiD asks if this should be
deleted, i.e., make it disappear from memory, not from disk until the
next save (*note Save::.).

   The mesher or mesher combination, can be chosen in  (*note
Preferences::.).

   Next, GiD asks for a general element size which will be applied to
all lines, surfaces and volumes that do not have a previously defined
one (*note Assign unstruct sizes::.).  GiD offers to the user to
default possibilities:
   * One default size automatically calculated by the program to define
     a coarse mesh.

   * Last size given by the user in previus meshings.

   User can choose one of these or enter a new one.

   Size is given by the average side of the corresponding triangle or
quadrilateral.

   Progress in meshing is shown by one progress bar that indicates
number of generated surfaces or volumes related to total number of
surfaces or volumes.

   Meshing can be stopped at any time by pressing button `Stop'.
Sometimes it is necessary to press this button for some time to get the
action done.


File: gid.info,  Node: Mesh view,  Next: View boundaries,  Prev: Generate,  Up: Meshing

Mesh view
=========

   When a mesh has already been generated, this option changes the
visualization to mesh viewing. The reverse, the return to geometry, is
automatically performed either by the same command or when selecting
option `View geometry' (*note View geometry::.) or any command related
to geometry.


File: gid.info,  Node: View boundaries,  Next: Assign unstruct sizes,  Prev: Mesh view,  Up: Meshing

View boundaries
===============

   This option draws the boundaries of the mesh on the screen when
chosen.

   Boundaries for triangular or quadrilateral meshes are line-elements.
Boundaries for tetrahedra or bricks meshes are triangles or
quadrilaterals.  This option can be useful to render a volume mesh
(*note Render::.).


File: gid.info,  Node: Assign unstruct sizes,  Next: Draw Sizes,  Prev: View boundaries,  Up: Meshing

Assign unstruct sizes
=====================

   Size is given by the average side (edge) of the corresponding
triangle or quadrilateral.
Assign sizes to points, lines, surfaces or volumes:
It is possible to assign different sizes to different entities of the
mesh.  This means that in the vicinity of these entities, the generated
elements will be approximately of that size. All the entities that have
not an assigned size when meshing, take the default size. Points do not
take any size if none is given to them.

   To assign a size of 0.0 to an entity is the same as setting the
default size.  The transition between different sizes is controlled by
a parameter in preferences (*note Preferences::.).
Assign sizes by cordal error:
Option `By cordal error' asks the user for a minimum and a maximum size
and a cordal error (the maximum distance between the generated element
and the real geometry). GiD assigns the corresponding sizes to all the
entities to accomplish this condition. It will only change the current
sizes if the new one is smaller than the previously defined. In
structured surfaces, stretching is permitted. It means that if
necessary, elements can have very different size along both principal
directions.
Note: It is assigned to entities a size between the minimum and
maximum; however, when generating the mesh, GiD adapts the size of the
elements only if necessary, exceeding sometimes the minimum and maximum
limits.

   In this window the effect of different cordal error values over the
number of elements that will be created over a line can be viewed. Any
line of the geometry can be picked up and be used in this window.
Correct sizes:
When option `Correct sizes' is selected, a window appears. In this
window it is possible to enter a minimum and a maximum mesh size.

   If option `By geometry' is activated, sizes are assigned to all the
entities depending on the shape of the geometry. This means that
smaller surfaces will have smaller elements. It will only change the
existing sizes if the new size is smaller than that previously defined.

   If option `Correct incompatible sizes' is activated, some sizes are
reduced in order to control that the transitions between sizes in close
entities are not too fast. It will only change the current sizes if the
new one is smaller than that previously defined.
Note: Applying last two options with default values is exactly the same
than setting the preference `Automatic correct sizes' to on in the
preferences window (*note Preferences::.).

   Note: To mesh a difficult volume trying to adjust element sizes to
geometry detail, it may be useful to use `By geometry' and `Correct
incompatible sizes' options setting the larger size equal to the
default size for meshing, and the smaller size reflecting the details (
10 times smaller, for example).
Background Mesh:
With this option it's possible to assign sizes using a background mesh
of triangles or tetrahedrons. When the option is selected GiD asks for
a file; that file must contain the background mesh. The background mesh
must cover all the domain, so usually the background mesh will be a
previous mesh of the same model.
The format of the file containing the background mesh is the following:
   * First line: `BackgroundMesh V 1.0'

   * Description of the mesh. The format of that mesh is described in
     the Mesh read section (*note Mesh read::.).

   * Desired sizes in the following format:
          DesiredSize (Nodes or Elements)
            number of        size
            node/element
          ...

     Background mesh file example:
          BackgroundMesh V 1.0
          MESH dimension       2 ElemType Triangle  Nnode 3
          Coordinates
                1          5.61705         4.81504         0.00000
           ...
               51         -5.64191        -1.53335         0.00000
          end coordinates
          
          Elements
                1         24         16         26
                2         16         10         14
          ...
               76         34         31         28
          end elements
          
          DesiredSize Elements
                1         0.20000
                2         0.20000
          ...
               75         1.50000
               76         1.50000
          End DesiredSize

CAUTION: Be careful when assigning big sizes to entities close to
others where a small size has been given. It may be impossible to
obtain a mesh.

   CAUTION: When using contact elements (*note Contact creation::.),
the same size must be used for contact and for duplicate entities.


File: gid.info,  Node: Draw Sizes,  Next: Structured mesh,  Prev: Assign unstruct sizes,  Up: Meshing

Draw Sizes
==========

   When sizes are assigned to points, lines, surfaces or volumes using
the Assign Unstruct sizes option, it is possible to draw in different
colors the different assigned sizes.

EXAMPLE

   In the following example some different sizes are assigned to
surfaces. Sizes of 3, 5 and 6 are assigned depending on the surface.
After choosing the Draw Sizes option, (over surfaces) we get the
following result:

File: gid.info,  Node: Structured mesh,  Next: Structured concentrate,  Prev: Draw Sizes,  Up: Meshing

Structured mesh
===============

A structured mesh is defined as a mesh where all the nodes have the
same number of elements around it.

   The size of the elements is defined in a different way than for a
non-structured mesh. In this case, the mesh is not defined by the size
but by the number of elements that are required on every line. This
number must be the same for all lines that are opposite to each other
on each surface. When meshing volumes, this definition must be the same
for opposite surfaces.

   To create a structured mesh, choose `structured' and volumes,
surfaces or lines. Surfaces can be 4-sided or NURBS ones. Planar
surfaces meshes cannot be structured. After choosing `escape', the
number of elements per line is given.  Later, lines can be selected and
related lines (in option surface or volume), are added or deleted from
the group. This process can be repeated as many times as necessary
until all lines have a new value. By default, the generated elements
will be quadrilateral or hexahedra and the lines with no numbering
given will have two elements over them. All no selected lines will also
have two elements by default.

   Structured volumes must have 6 contour surfaces. Structured surfaces
must be 4-sided surfaces or NURBS surfaces.

   It is possible to mix some entities with structured meshes and
others with unstructured ones.

   To convert a structured entity to a non-structured one, select reset
(*note Reset mesh data::.) or assign a size to it (*note Assign
unstruct sizes::.).

   To change the default element type *Note Element type::.

   *Note 1:* One NURBS surface can be structured with any number of
contour lines but must have a good shape form. This means that it must
have 4 big angles and the other angles must be small. With this
criteria, the shape will be topologically similar to one quadrilateral.

   *Note 2:* When assigning structured divisions to one line or with
difficult topology, GiD may need to reassign some sizes to make the
structured mesh conformal. It will be done automatically. If it is
impossible to create compatibility between surfaces, a message is given.

   *Note 3:* It is possible to assign a number of structured divisions
to the boundary line of a surface or volume, and then create an
unstructured mesh for the surface/volume.


File: gid.info,  Node: Structured concentrate,  Next: Mesh criteria,  Prev: Structured mesh,  Up: Meshing

Structured concentrate
======================

   By default, all partitions in one structured line have the same
approximate length.  This command lets the user select one line. Then,
in the graphical window the sense of the line is shown with one arrow.
The user will enter a positive or negative weight.  If the weight is
positive the size of the elements will be concentrated at the extreme
of the line, if negative, the elements will be repelled.
As the magnitude of the weight increases, the diference between element
sizes will be bigger.


File: gid.info,  Node: Mesh criteria,  Next: Element type,  Prev: Structured concentrate,  Up: Meshing

Mesh criteria
=============

   GiD provides three different criteria to generate the mesh. The
`Default' option skips meshing the boundaries, that is, lines for
surface meshes and surfaces for volume meshes. The `Mesh' option allows
the user to choose the entities to be meshed, whilst the `No Mesh'
option does the opposite.


File: gid.info,  Node: Element type,  Next: Quadratic,  Prev: Mesh criteria,  Up: Meshing

Element type
============

   With this command, the type of element desired is selected. It is
only necessary to do this when the element type is different from the
default (*note Meshing::.).

   Types are:

   * Linear: for lines.

   * Triangle and Quadrilateral: for surfaces.

   * Tetrahedra and Hexahedra: for volumes.

   * Only points: Just for volumes. Point elements are generated.

   * Linear and  Quadrilateral: for contact surfaces.

   * Linear, Prism and Hexaedra: for contact volumes.

   By default, the elements are of minimum order: 3-noded triangle,
4-noded quadrilateral and so on. To increase the degree, use command
`Quadratic' (*note Quadratic::.). Option `Quadratic' applies to all the
elements of the problem.

   · `Point': 1 node,

   · `Linear': 2 or 3 nodes,

   · `Triangle': 3 or 6 nodes,

   · `Quadrilateral': 4, 8 or 9 nodes,

   · `Tetrahedra': 4 or 10 nodes,

   · `Hexahedra': 8, 20 or 27 nodes.

   The `Linear' option assures, not only the meshing of lines, but also
the creation of 2-node contact lines between surfaces or volumes, if
desired.

   At contact surfaces, GiD elements are:
   * Linear: 2 nodes.

   * Triangle: 3 nodes.

   * Quadrilateral: 4 nodes.

   At contact volumes (and separated contacts), elements are:
   * Linear: 2 nodes.

   * Prisma: 6 nodes.

   * Hexahedra: 8 nodes.

   To decide what parts of the geometry should be meshed use command:
*Note Mesh criteria::.


File: gid.info,  Node: Quadratic,  Next: Reset mesh data,  Prev: Element type,  Up: Meshing

Quadratic
=========

   Option `Quadratic' applies to all the elements of the problem. If
chosen, elements will be:

   * Linear: 3 nodes.

   * Triangle: 6 nodes.

   * Quadrilateral: 8 nodes.

   * Tetrahedra: 10 nodes.

   * Hexahedra: 20 nodes.

   Option `Quadratic9' is similar to option `Quadratic', but will
generate 9-noded Quadrilaterals and 27-noded Hexahedra.


File: gid.info,  Node: Reset mesh data,  Next: Cancel mesh,  Prev: Quadratic,  Up: Meshing

Reset mesh data
===============

   This command resets, all the sizes assigned to entities. This means
that all of them will be unassigned.

   To unassign only some entities, assign size 0.0 (*note Assign
unstruct sizes::.) to the entities where the default size is required.

   The information about element types, mesh criteria and quadratic
parameters is also reset.


File: gid.info,  Node: Cancel mesh,  Next: Mesh quality,  Prev: Reset mesh data,  Up: Meshing

Cancel mesh
===========

   If a mesh has been previously generated, this option erases the mesh
and makes it disappear.


File: gid.info,  Node: Mesh quality,  Next: Edit mesh,  Prev: Cancel mesh,  Up: Meshing

Mesh quality
============

   This option opens a window that shows graphics about the quality of
the mesh elements.

   There are four criteria in order to measure the quality of the
elements:
  1. Minimum angle: The quality criteria is the minimum angle in
     surface elements and the minimum dihedral angle for volume
     elements. This means that elements with a small angle are
     considered of a worse quality than the ones with bigger angles.

  2. Maximum angle: It gives the maximum angle for every element.
     Elements with bigger angles are considered worse.
     Typically, the Minimum angle criteria is good to qualify triangles
     or tetrahedra and the Maximum angle criteria is good for
     quadrilaterals and hexahedra
  3. Element vol: The quality criteria is the size of elements
     (distance for lines, area for surfaces and volume for volumes).
     Elements with little "volume" are considered worse.

  4. Minimum edge: The quality criteria is the size of the edges of
     elements. Elements with smaller edges are considered worse.

There are two visualization modes:
  1. Normal: the graph shows the number of elements that have an angle
     with a certain degree.

  2. Accumulated: the graph shows the number of elements which have an
     angle with a given degree or smaller.

   In the `MeshQuality' window, if you double click on a value, the
elements below this value are selected in red. These selected elements
can be sent to a layer using the `Send To Layer' button of the `Mesh
Quality' window.

EXAMPLE

   In this example we are studying the mesh using the minimum angle
criteria. We can see that 140 elements of our mesh have an angle of
smaller than 45,7 degrees. If we double click with the mouse on the
graphic, the 140 elements which have an angle smaller than 140 degrees,
will be selected.


File: gid.info,  Node: Edit mesh,  Prev: Mesh quality,  Up: Meshing

Edit mesh
=========

   These option let the user modify one mesh. All modification will be
lost when the mesh is generated again.

* Menu:

* Move node::
* Delete elements::
* Delete lonely nodes::


File: gid.info,  Node: Move node,  Next: Delete elements,  Prev: Edit mesh,  Up: Edit mesh

Move node
---------

   By using this command, an existing node is selected and moved. The
new position is entered in the usual way (*note Point definition::.).


File: gid.info,  Node: Delete elements,  Next: Delete lonely nodes,  Prev: Move node,  Up: Edit mesh

Delete elements
---------------

   To delete elements a selection is made (*note Entities
selection::.). After pressing `escape' (*note Escape::.), the elements
are erased.

   The deletion of entities can be done in two ways: at one level
(`point', `line', `surface' or `volume') or erasing all entities at
once. A selection is made (*note Entities selection::.) in both cases.
After pressing `escape' (*note Escape::.), the elements are erased.

   Nodes that do not belong to any element after the operation are also
erased.

   To avoid erasing the selected elements, press `break'.
Note: It is possible to filter the selection, for example, selecting
only triangles but not quadrilaterals (*note Selection window::.).


File: gid.info,  Node: Delete lonely nodes,  Prev: Delete elements,  Up: Edit mesh

Delete lonely nodes
-------------------

   After confirmation, all the nodes of the mesh that do not belong to
any element are erased.

   *Note:* This command is only necessary for meshes imported from
outside because internally generated or edited meshes, have this
problem implicitly corrected.


File: gid.info,  Node: Calculate,  Next: POSTPROCESS OPTIONS,  Prev: Meshing,  Up: Top

CALCULATE
*********

   Inside this window, the user can begin and manage the analysis of
the problem. Word `process' will be used to refer the running analysis
code. This word is used to show the possibility that several analysis
or processes can be run at the same time.

   Options for this window are:

   * `Start:' Begins the process module. Once it is pressed, user can
     continue working with GiD as usual.

   * `Kill:' After selecting a running process, this button stop its
     execution.

   * `Output view:' After selecting a running process, this button
     opens a window that shows process related information such as
     iterations, convergence, etc.

   * `Close:' Closes the window but does not stop the running processes.

   A list of all the running processes is shown, with some useful
information like name, starting time, etc.

   The various windows will differ in accordance to the specifications
of the problem (thermoelastic, impact, metal-forming, etc.), the
different types of elements (2D or 3D, beams, shells, plates, etc.) and
also the different requirements and specifications of the particular
solver.

   All the commands and facilities that are explained in this manual are
generally available for the different solvers. However, there may be
some commands and facilities that are only available to some of them
and therefore some displays can look slightly different from those
explained on these pages.


File: gid.info,  Node: POSTPROCESS OPTIONS,  Next: postprocessing results,  Prev: Calculate,  Up: Top

POSTPROCESS OPTIONS
*******************

* Menu:

* introduction - postprocess::
* files - postprocess::
* utilities - postprocess::
* Point and Line options::
* Display Style::
* Textures::
* Cover mesh::


File: gid.info,  Node: introduction - postprocess,  Next: files - postprocess,  Prev: POSTPROCESS OPTIONS,  Up: POSTPROCESS OPTIONS

Introduction
============

   This chapter describes some relevant aspects of the Postprocessing
step and the way to load results from a numerical analysis into GiD.

   In the GiD postprocess you can study the results obtained from a
solver program. The GiD postprocess receives mesh and results
information from the solver module. If the solver module doesn't create
any new mesh, the preprocess mesh is used.

   The communication between the solver and the GiD Postprocess is made
using files.

   The solver program has to write the results in a file that must have
the extension `.post.res', or the old `.flavia.res', and its name must
be the project name.  If the solver writes a mesh, the file must have
the extension `.post.msh', or the old `.flavia.msh'. ( *note
POSTPROCESS DATA FILES::. )

   The extensions `.msh' and `.res' are also allowed, but only the
files with the extensions `.post.msh', `.post.res' and  the old ones
`.flavia.msh' and `.flavia.res' will be automatically read by GiD when
postprocessing the GiD project.

   There are two ways to postprocess inside GiD:

   * Postprocess inside a GiD project: Starting GiD and open the GiD
     project (`ProjectName.gid') you want to postprocess, and then
     select the `postprocess' option from the `files' menu or click on
     the `pre/post' toolbar button. This way the
     `ProjectName.flavia.res', or the old `ProjectName.flavia.res',
     will automatically be read by GiD, and the `ProjectName.post.msh',
     or the old `ProjectName.flavia.msh', if present.

   * Postprocess other files: Starting GiD and, directly, select the
     `postprocess' option from the `files' menu or click on the
     `pre/post' toolbar button. Now open the pair files
     `OtherModel.msh' and `OtherModel.res'.

   Once inside the postprocessing section of GiD, all the visualization
features and management options of the preprocess section are available:
Zoom, Rotate (Rotate screen/object axes, Rotate trackball,etc.), Pan,
Redraw, Render, Label, Clip Planes, Perspective, etc.

   *Note:* There is no need to load a project into GiD to use its
Postprocessing; you can open directly the mesh and results information
directly from the GiD postprocess. ( *note files - postprocess::. )


File: gid.info,  Node: files - postprocess,  Next: utilities - postprocess,  Prev: introduction - postprocess,  Up: POSTPROCESS OPTIONS

Files menu
==========

   Several useful options has been added inside the `Files' menu:

   * New: Clears all postprocess information present in GiD.

   * Open: Read postprocess information into GiD.

   * Merge (ASCII): Reads mesh and results information from an ASCII
     file and add them to the current ones.

   * Import:
        - Cuts: to read cut planes, cut wires, iso-surface cuts into
          GiD so the same cuts can be used among several postprocess
          meshes.

        - Graphs: to add graphs to the already, or not, created ones
          inside GiD.

        - FEMAP / TECPLOT file: reads FEMAP Neutral ASCII files and
          TECPLOT ASCII files.

   * Export:
        - As ASCII files: saves meshes, sets and results into ascii
          files ( one for mesh information ".msh", and one for the
          results ".res") using the new PostProcess format *note File
          ProjectName.post.res - ProjectName.flavia.res::., *note File
          ProjectName.post.msh - ProjectName.flavia.msh::..

        - As one binary File: saves meshes, sets and results into one
          binary file.

        - Binary results: saves only results information, so the pass
          between pre and postprocess will be quicker.

        - ASCII boundaries: saves the boundaries of the meshes and
          sets, with its nodal results, into ascii files ( one for mesh
          information ".msh", and one for the results ".res"). The
          boundary of an hexaedra/tetrahedra mesh is a
          cuadrilateral/triangle mesh. The boundary of a
          cuadrilateral/triangle mesh is a line mesh. There is no
          boundary of a line/point mesh.

        - Cut: save cut planes, cut wires, iso-surface mesh cuts so the
          same cuts can be used among several postprocess meshes.

        - Graph: saves graphs in ascii ( gnuplot) format. If the option
          `All' is choosen, the user will be asked for a `prefix'.
          Then, GiD will create a file for each Graph with the names
          `prefix'-1.cur, `prefix'-2.cur, `prefix'-3.cur and so on . . .

        - Cover Mesh: after visualizing the cover mesh of the
          points/nodes, this mesh can be saved for other uses.

   * Preprocess: allows the user, after confirmation, to return to the
     pre-processing section of GiD.

   The rest of the options are the same on the preprocess part.


File: gid.info,  Node: utilities - postprocess,  Next: Point and Line options,  Prev: files - postprocess,  Up: POSTPROCESS OPTIONS

Utilities
=========

   Inside the `Utilities' menu, the options `Id', `Signal', `Distance'
and `Calculator' have the same funcionality as in the Preprocess (*note
Utilities::.). Other options of the `Utilities' menu are slightly
different:

   * `Status': a window appears showing the general postprocess status:
     number of meshes, elements, etc.

   * `List'
        - Nodes: a window appears showing information about selected
          nodes: its coordinates, the current visualized result, and
          all other nodal results defined over the selected nodes.

        - Elemets: a window appears showing information about selected
          elements: its connectivity, the gauss points defined on the
          selected elements, the current visualized result, and all
          other results defined over the gauss points of the selected
          elements.

   * `Colapse': to colapse nodes that are together in a set.

   * `Join': to join several sets into one.

   * `Delete': to delete meshes, sets and cuts.

   * `Texture': to add textures to sets *note Textures::..

   The Copy utility introduces some changes:

   When choosing the Copy utility the `Transformations' window appears.
This window allows the user to repeat the the visualization using
translation, rotation and mirror transformations, so that GiD can draw
a whole model when only a part of it was analyzed:

   Transformations types are:

   * Translation: It is defined by two points. Relative movements can
     be obtained defining the first point as 0,0,0 and considering the
     second point as the translation vector (*note Point definition::.).

   * Rotation: It is necessary to either enter two points in 3D or one
     point in 2D.  These two points define the rotation axis and its
     orientation. In 2D, the axis goes from the defined point towards z
     positive. Enter the angle of rotation in degrees. It can be
     positive or negative. The sense is defined by the right hand rule.
     In 2D, the sense is counter-clockwise.

   * Mirror: It is defined by three points that cannot be aligned.
     These points form a plane that is the mirror plane. In 2D, the
     mirror line is defined by two points.

   Available options are:
   * Copies: Giving the number of repetitions, the operation selected
     is performed this number of times.

   * View: The trasformation is only for viewing porposes. `Show/Hide',
     `Undo' and `Clear' options are enabled.

   * Create: All the Post information (meshes & results) will be
     duplicated when doing the transformation.  The options
     `Show/Hide', `Undo' and `Clear' are disabled.

   * Show/Hide Transform.: allows the user wether to see the original
     model, or the one with the transformations active.

   * Undo: Deletes last transformation done. It can be used repeadly to
     clear all the transformations done.

   * Clear: Clear all the transformations at once.

   Button DoIt tells the program to do the transformation selected.


File: gid.info,  Node: Point and Line options,  Next: Display Style,  Prev: utilities - postprocess,  Up: POSTPROCESS OPTIONS

Point and Line options
======================

   As points and lines can be viewed, there are several interesting
options for each of them.

   * Point options:

     Here the user can select whether to draw the points `Quick',
     `Nice' or with the center of a `Texture' glued to the point.
     `Quick': points will be drawn as big dots.
     `Nice': points will be drawn as little spheres (quadrilateral
     meshes).
     For every draw style, the `Point Size' can be changed, but ranges
     varies between `Quick', which depends on the graphics library, and
     `Nice' and `Texture'.
     When the `Nice' style is selected, the `Nice detail' level can be
     adjusted. The number represents the number of vertical and
     horizontal subdivision of a sphere.
     *Note:* The changes affect all the points representation: point
     elements and the arrow head of vectors when using the `Point'
     detail level *note Display vectors::..
   * Line options:

     Here the user can select whether to draw the lines with a `Quick'
     style or a `Nice' one.
     Selecting a `Line Size' of 0.0 in the `Nice' style, will cause the
     lines to be not drawn.
     `Quick': lines are drawn as 3-point thick lines. The line size is
     fixed.
     `Nice': lines are drawn as long 4-sided or 8-sided prismas. The
     size, width, of the lines can be changed.
     When the lines are drawn nicely, the number of `sides of the
     prisma' used to draw them can be changed between 4 and 8 sides.
     *Note:* Line options no longer affect the stream lines as before,
     but only the line elements.  For stream lines otions *note Stream
     Lines::..


File: gid.info,  Node: Display Style,  Next: Textures,  Prev: Point and Line options,  Up: POSTPROCESS OPTIONS

Display Style
=============

   There is a `View Style' window, where almost all the interesing
visualization options can be adjusted which only deals with meshes,
sets or cuts, and not with results.


File: gid.info,  Node: Textures,  Next: Cover mesh,  Prev: Display Style,  Up: POSTPROCESS OPTIONS

Textures
========

   In GiD it is also possible to assign a texture to a Set. Inside the
menu Utilities->Texture there are several options:

   * View No / Fast / Nice: to switch whether to view the textures over
     the sets or not. When the texture is small, so that a pixel of the
     textures must be drawn over several pixels on the screen, the
     `Fast' mode just draws the pixels using the 'nearest neighbor'
     policy, and the `Nice' tries to interpolate the colours of the
     pixels from the original.

   * Add Screen Map / To 4 Sided / BoundImg to BoundSet: to map a
     texture to a set. `ScreenMap': by picking four points over the
     screen, GiD projects the texture, parallel to the screen, over the
     underlying sets.  `4 sided': tries to match the 4 sides of the
     texture to the 4 sides of the set. The best results are achieved
     using quadrilateral sets which are more or less flat, at least in
     one direction.  `BoundImg to BoundSet': looks for the border of
     the texture inside the image file and tries to glue it to the
     border of the set, for instance a texture circle to a circle set.

   * Change Flip Horiz. / Vert.: changes the orientation of the texture
     once it is applied to the Set.

   Note: When the display style of the visualization is changed, for
instance from `Body' to `Body Boundaries' the visualization of the
texture is switched off. To view the texture, just select
Utilities->Texture->View->Fast/Nice.

   Once the texture is applied to a Set, when the Set is deformed, the
texture is deformed accordingly, so the deformed texture can be
visualized.


File: gid.info,  Node: Cover mesh,  Prev: Textures,  Up: POSTPROCESS OPTIONS

Cover mesh
==========

   Another feature in GiD is the calculation of the involving mesh of a
set of points or nodes. To switch the visualization of this mesh on and
off just select Options->Geometry->Covering mesh.  After saying 'Yes'
to the visualization of the covering mesh, the user will be asked for a
number. This number is the distance between the covering mesh and the
points.

   This option is not only available for points, but also for every
mesh/set present in GiD.

   Note: This covering mesh is recalculated when the mesh is deformed.
So in a particle movement system, the covering mesh will also move along
with the particles.

   This mesh can also be saved through Files->Export->Cover mesh.


File: gid.info,  Node: postprocessing results,  Next: Customization,  Prev: POSTPROCESS OPTIONS,  Up: Top

POSTPROCESSING RESULTS
**********************

* Menu:

* Contour Fill::
* Smooth 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::

   The possible results to be displayed can be grouped into five major
categories:
   * Scalar view results: Show Minimum & Maximum, Contour Fill, Contour
     Text Ranges, Contour Lines, Iso Surface and its configuration
     options.

   * Vector view results: Mesh deformation, Display Vectors, Stream
     Lines (Particle Tracing)

   * Line diagrams: Scalar line diagram and vector diagrams.

   * Graph lines: XY plots.

   * Animation: animation of the current result visualization.

   The View Results menu and the View Results window are used to manage
the visualization of the different type of results.

   The View Results menu lets you select any type of result:

   - Contour fill

   - Contour ranges

   - Contour lines

   - Diplay vectors

   - Show min/max

   - Iso surfaces

   - Stream lines

   - Graphs

   - Deformation

   - Line diagrams

   The View Results window manages the visualization of the following
type of results:

   - Contour fill

   - Contour ranges ( if `Result Range Table's are present)

   - Contour lines

   - Diplay vectors

   - Show min/max

   - Scalar and Vector line diagram ( if Linear elements are present)

   As the results are grouped into steps and analysis, GiD must know
which analysis and step is the currently selected for displaying
results.  The `Analysis' menu of the View Results window is used to
select the current analysis and step to be used for the rest of the
results options. If some of the results view requires another analysis
or step, the user will be asked for it.

   *Note:* To stop viewing a result, the user can select `No Result' in
this window or in the View results menu.

* Menu:

* Contour Fill::
* Contour Lines::
* Show Minimum and Maximum::
* Display vectors::
* Iso Surface::
* Stream Lines::
* Line Diagrams::
* Legends::


File: gid.info,  Node: Contour Fill,  Next: Smooth Contour Fill,  Prev: postprocessing results,  Up: postprocessing results

Contour Fill
============

   This option allows the visualization of colored zones, in which a
variable, or a component, varies between two defined values. GiD can
use as many colors as allowed by the graphical capabilities of the
computer. When a high number of colors is used, the variation of these
colors looks continuous, but the visualization becomes slower unless
the Fast-Rotation option is used.  A menu of the variables to be
represented will be shown, from which the one to be displayed will be
chosen, by using the default analysis and step selected.

   Vectors will be unfolded into X, Y, and Z components and its module.
Symmetric matrix values will be unfolded into Sxx component, Syy
component, Szz component, Sxy component, Syz component and Sxz
component of the original matrix and also into Si component, Sii
component and Siii component in 3D problems or angular variation in 2D
problems. Any of these components can be selected to be visualized.

   When using results defined over gauss points, they are extrapolated
to the nodes.  So discontinuities can appear between adjacent elements.
If the gauss points results can not be extrapolated to the nodes, they
are drawn as coloured spheres.  The radius and detail level of these
spheres can be configured too (*note Point and Line options::.).

   Several configuration options can be accessed via the Options menu.

   * Number Of Colors: Here the number of colors of the results color
     ramp can be specified.

   * Width Intervals: fixes the width of each color zone. For instance,
     if a `width interval' of 2 is set, each color will represent a
     zone where the results differ at the most in two units.

   * Set Limits: this option is used to tell the program which contour
     limits should use when there are no user defined limits: the
     absolute minimum and maximum of all sets or shown sets, for the
     actual step or for all steps.

   * Define limits: when choosing this option the `Contour Limits'
     window appears (this option is also avalaible in the postprocess
     toolbar). With this window the user can set the minimum/maximum
     value that Contour Fill should use. Outliers will be drawn with
     the color defined in the `Out Min Color/Out Max Color' option.

   * Reset Limit Values: this option resets the values defined in the
     `Define limits' option.

   * Reset All: this option sets all Contour Fill options by default.

   * Max/Min Options: Inside this group, several options for the
     minimum or maximum value can be defined:

        - *ResetValue:* here the user can reset the maximum/minimum
          value, so that the default value is used.

        - *OutMaxColor / OutMinColor:* with this option the user can
          specify how the outliers values should be drawn: `Black',
          `Max/Min Color', `Transparent' or `Material'.

        - *Def. MaxColor / Def. MinColor:* this option lets the user
          define the color for the minimum or maximum value for the
          color scale to start with.

   * Color scale: Specifies the propertyes of the color scale:

        - *Standard:* the color scale will be the default: starting
          from blue (minimum) through green until red (maximum).

        - *Inverse Standard:* the color scale will just be the inverse
          of the default: starting from red (minimum) through green
          until blue (maximum).

        - *Terrain Map:* a physical-map like color ramp will be used.

        - *Black White:* Black for Minimum and White for Maximum, the
          scale will be a grey ramp.

        - *Scale Ramp:* this option lets the user specify how should
          the ramp change from minimum color to the maximum color:
          `Tangent', `ArcTangent' or `Linear'. The default is
          `ArcTangent'.

        - *Scale Type:* tells GiD how the colors between the minimum
          color and the maximum color should change: `RGB' or `HSV'.

   * *Color window:* a window is poped up to let the user configure the
     colour scale of the contours easily


File: gid.info,  Node: Smooth Contour Fill,  Next: Contour Ranges,  Prev: Contour Fill,  Up: postprocessing results

Smooth Contour Fill
===================

   This option displays a Contour fill, explained in the previous
section, of a local smoothing of the results defined over gauss points.

   With the `Smoothing type' option inside the menu `Options->Contour'
the user can choose between these types of local smoothing:

   * Minimum value: as nodal results the minimum of the extrapolated
     gauss points results of the adjacent elements are used.

   * Maximum value: as nodal results the maximum of the extrapolated
     gauss points results of the adjacent elements are used.

   * Mean value: as nodal results the mean value of the extrapolated
     gauss points results of the adjacent elements are used.


File: gid.info,  Node: Contour Ranges,  Next: Contour Lines,  Prev: Smooth Contour Fill,  Up: postprocessing results

Contour Ranges
==============

   This is the same as the `Contour Fill' visualization type, but the
coloured areas are created following a `'Result range table'' specified
in the results file, *note Result Range Table::., and the name of these
areas are also visualized as text labels.


File: gid.info,  Node: Contour Lines,  Next: Show Minimum and Maximum,  Prev: Contour Ranges,  Up: postprocessing results

Contour Lines
=============

   This display option is quite similar to contour fill (*note Contour
Fill::.), but here, the isolines of a certain nodal variable are drawn.
In this case, each color ties several points with the same value of the
variable chosen.

   Here the configurations options are almost the same than the ones
for Contour Fill (*note Contour Fill::.), with the only difference that
the number given in the `Number of Colors' option will be used as the
number of lines for this contour lines representation.


File: gid.info,  Node: Show Minimum and Maximum,  Next: Display vectors,  Prev: Contour Lines,  Up: postprocessing results

Show Minimum and Maximum
========================

   With this option the user can see the minimum and maximum of the
chosen result.

   *Note:* This minimum and maximum can be absolute, for all the
meshes/sets/cuts, or relative (local) to the shown ones.  This can be
selected from the top menu `Options' -> `Contour' -> `Set Limits'.


File: gid.info,  Node: Display vectors,  Next: Iso Surface,  Prev: Show Minimum and Maximum,  Up: postprocessing results

Display vectors
===============

   This option displays a menu with results from vectors and matrices
(where the principal values are previously evaluated by the program). A
menu of variables to be represented will be shown, from which the one
to be seen should be chosen, using the default analysis and step
selected. Once a vector is chosen, the program will display the nodal
vectors of the chosen result. The drawn vectors can be scaled
interactively. The factor can be applied several times and every time it
changes to the new input value.

   The user can modify the colour of the vectors, which, by default,
are drawn in green, so that all the vector are drawn with the same
colour, or let the vectors colour vary according to the result module.

   When drawing a matrix result, such as the stress tensor, only a
single color representation of principal values is available: blue when
negatives (also drawn as >-< representing compressions), and red when
positives (also drawn as <-> representing tensions).

   Vectors will be unfolded into X, Y, and Z components and its module.
So only the X, Y or Z component can be drawn or the whole vector, which
is represented by the module menu option.  Symmetric matrices will be
unfolded into Si component, Sii component, Siii component and 'All'
components. Any of these components can be selected to be visualized.
Si, Sii and Siii represent the eigen values & vectors of the matrix
results which are calculated by GiD, and which are ordered according to
the eigen value.

   Several configuration options can be accessed via the Options menu.

   Color Mode: This option lets the user choose if vectors are drawn in
one color `(Mono Color)' or in several colors `(Colour Modules)'.

   Number of Colors: If the user uses `Colour Modules' to draw vectors,
it is possible to choose the number of colors.

   Offset: With this option, the user controls where the vector should
be in relation of the node, ranging from 0, to tie the tail of the
arrow to the node, to 1, to tie the tip of the arrow to the node.

   *Note:* These options have no effect when viewing a matrix result.

   *Colour (mono):* When vectors are drawn in `(Mono Color)' `Color
Mode', they are drawn in green. The user can change this green colour
selectiong this entry.

   Detail: The level of detail can be adjusted to draw the vectors
quicker or nicer.  The different options are:
   - Point: the arrow head will be drawn as a point. The style used to
     draw these point like arrow heads can be modified through the
     point options window described before, *note Point and Line
     options::..

   - Lines: the arrow head will be drawn as four lines.

   - 2 Triangles: the arrow head will be drawn with 2 self intersecting
     triangles.

   - 4 Triangles: the arrow head will be drawn as cones of 4 triangles.

   - 8 Triangles: the arrow head will be drawn as cones of 8 triangles.

   *Note:* This last option affects also matrix and local axes results.


File: gid.info,  Node: Iso Surface,  Next: Stream Lines,  Prev: Display vectors,  Up: postprocessing results

Iso Surfaces
============

   Here a surface is drawn that ties a fixed value inside a volume mesh.
A line is drawn for surface meshes.  To create iso-surfaces there are
several options:
   * Exact: After choosing a result, or a result component, of the
     current analysis and step, the user can input several fixed values
     and then for each given value a iso-surface is drawn.

   * Automatic: Similarly, after choosing a result, or a result
     component, the user is asked for the number of iso-surfaces to be
     created. GiD calculates the values between the Minimum and the
     Maximum (these not included).

   * Automatic Width: After choosing a result, or result component, the
     user is asked for a width. This width is used to create as many
     iso-surfaces as needed between the Minimum and the Maximum (these
     included) values defined.

   Several configuration options can be accessed via the Options menu.

   * Display Style: For Iso-Surfaces there is also a `Display Style'
     option, like for Volumes/Surfaces/Cuts. The options `All Lines',
     `Hidden Lines', `Body', `Body Lines' are avalaible. (*note Display
     Style::.)

   * Render: The `render' option for Iso-Surfaces renders that surfaces
     `Flat' or `Normal'. (*note Display Style::.)

   * Transparency: The Iso-Surfaces can be set to `Transparent' or
     `Opaque'. (*note Display Style::.)

   * Convert to cuts: Another interesting option is `Convert To Cuts'.
     With this options all the Iso-Surfaces drawn will be turn into
     cuts, so that they can be saved, read, and used to drawn results
     over them.


File: gid.info,  Node: Stream Lines,  Next: Line Diagrams,  Prev: Iso Surface,  Up: postprocessing results

Stream Lines
============

   With this option the user can display a stream line, or, in fluid
dynamics, a particle tracing, in a vector field.  After choosing a
vector result, using the default analysis and step selected, the
program asks the user for a point to start with the plotting of the
stream line. This point can be given in several ways:
   - just clicking on the screen: the point will be the intersection
     between the line orthogonal to the screen and the plane parallel
     to the screen and containing the `Rotation center',

   - joining a node: the selected node will be used as a start point,

   - select nodes: here several nodes can be selected to start with,

   - along line: with this option the user can define a segment, along
     which several start points will be chosen. The number of points
     will also be asked for, including the ends of the segment. In case
     of just one point start, this  will be the center of the segment.

   - in a quad: the user can enter here four lines that define a
     quadrilateral area which will be used to create a N x M matrix of
     points. These points will be the start for the stream lines. When
     giving N x M, N lies on the first and third line, and M on the
     second and fourth.  So, points ( 0, 0..N), ( M, 0..N), ( 0..M, 0)
     and ( 0..M, N) will lie just on the lines. But in case of N=1 or
     M=1, this will be the center of the line, and if N = 1 and M = 1,
     this will be the center of the Quad.

   - intersectset  the point will be the intersection between the line
     orthogonal to the screen and the current viewed sets nearest the
     view point.

   When viewing `Stream Lines', labels can be drawn to show the times
at start and end points of the stream line.

   Stream lines can also be deleted, and its, by default, green colour
can be changed too.

   Following options can be chosen for `Stream Lines':

   Color: the colour of the stream lines.

   Delete: this option lets the user select stream lines to be deleted.

   Label: this option lets the user select the kind of label:
   - `None': no labels are drawn.

   - `0_End': labels are drawn with the following convention: 0 at the
     start of the stream line and the total time taken for the particle
     to travel at the end.

   - `Ini_End': labels are drawn with the following convention: 0 at
     the chosen point, and `- time before' at the begin of the stream
     line and `time after' at the end.

   Size & detail: here the user can adjust the wise, width, and detail
of the stream lines using a window ( *note Point and Line options::.).


File: gid.info,  Node: Line Diagrams,  Next: Legends,  Prev: Stream Lines,  Up: postprocessing results

Line diagrams
=============

   This result visualization option is only active when line elements
are used in the mesh, and only will be represented over these line
elements.  When using this result visualization option, graph-style
lines will be drawn over the line elements.

   When drawing a Scalar Diagrams the graph-style lines are drawn on a
plane paralel to the screen ( with its normal vector pointing to the
user) when this result view is selected.  The positive 'axis' will be
the vector resulting of the cross product between this normal vector
and the one that the line defines.

   When drawing a Vector Diagrams the graph-style lines are drawn on a
plane that withholds the result vector and the one that the line
defines.  The graph-style line represent the module of this vector.
The positive 'axis' is also defined by the result vector.  As modules
are positive, to allow negative values, the input format for vector
results allows the introduction of a fourth component: the signed
vector module (*note File ProjectName.post.res -
ProjectName.flavia.res::.).

   There is a `Show Elevations' option only accesible through the
`Right buttons' menu under 'Results / LineDiagram / Options'.
Elevations are lines that connect the nodes and the gauss points of the
line element and the graph style line that represents the result.  The
options are:

   * None: to switch the elevations off,

   * Nodes only: to draw the elevation lines only on the nodes,

   * Whole line: to draw the elevation lines along the whole line,
     using nodes and gauss points,

   * Filled line: to draw orange filled elevations,

   * Contour filled line: the colours used to draw the filled
     elevations will be the same as of a contour fill done along the
     line.


File: gid.info,  Node: Legends,  Next: Graphs,  Prev: Line Diagrams,  Up: postprocessing results

Legends
=======

   Legends appear when Contours visualization, iso-surfaces or color
vector visualization are used:

   - Show: legends can be switched on and of.

   - Opaque: legends can be transparent, showing the result
     visualization behind them, or not.

   - Show title: with this option the result name of the current
     visualization appears on the top of the legend.

   - Outside: activating this option, the legend is shown on a separate
     window, thus freeing precious graphical surface on GiD's windows.

   - Automatic comments: if this option is activated, information about
     the type of analysis, the actual step and the kind of result, is
     added at the bottom of the screen *note Automatic comments::..


File: gid.info,  Node: Graphs,  Next: Deform Mesh,  Prev: Legends,  Up: postprocessing results

Graphs
======

* Menu:

* Graph Lines Description::
* Graph Lines Options::
* Graph Lines File Format::


File: gid.info,  Node: Graph Lines Description,  Next: Graph Lines Options,  Prev: Graphs,  Up: Graphs

Graph Lines description
-----------------------

   Here the user can draw graphs in order to have a closer look to the
results.  Several graphs types are available: point analysis against
time, result 1 vs.  result 2 over points and result along a boundary
line.  The user can also save or read a Graph (*note files -
postprocess::.). The format of the file will be described later. (*note
Graph Lines File Format::.)

   Under the Graphs option of the View Results menu there are the
following options:
   * `Show': here the user can switch between the graphs view and the
     post-processing view.

   * `ClearGraphs': to reset all the graphs and do a new start.

   * `Point Analysis': this graph shows the evolution of a result on a
     point along all the steps in the current analysis.

   * `Point Graph': after choosing a point or points, the user can
     contrast a result against another.

   * `Border Graph': after selecting a border, the user can see how the
     results varies along this boundary. You can also use the `Border
     Graph' window (`Windows' menu) to configure this type of graphs.

   The user can also view the labels of the points of the graphs, not
only the Graph points number, but also theirs X and Y values. If some
points of the Graphs are labeled, when turning into the normal results
view, the labels also appear on the results view.


File: gid.info,  Node: Graph Lines Options,  Next: Graph Lines File Format,  Prev: Graph Lines Description,  Up: Graphs

Graph Lines options
-------------------

   * `Grids': here the user tells whether to drawn grids or not.

   * `Current Style': the user can choose how the new graphs should
     look like. The possible styles are `Dot', `Line' and `Dot-Line'.

   * `Change Style Graph': the user can change the style of the
     selected graph.

   * `Change Colour Graph': herewith the colour of the selected graph
     can be changed.

   * `Change Line Width Graph': the width of the graph lines can be
     changed too.

   * `Change Line Pattern Graph': this option is useful to switch
     between different line patters for a b/w printer.

   * `Change Point Size Graph': also the point size can be changed for
     the `Dot' and `Dot-Line' styles.

   * `Change Style Graph': the user can change the style of the
     selected graph.

   * `Change Title Graph': the user can change the title of the
     selected graph.

   * `Title': the user can change the title, its position or reset its
     value.

   * `X_Axis': here the user can set min and max values and divisions
     for the X axis, reset them, and change its Label.

   * `Y_Axis': here the user can set min and max values and divisions
     for the Y axis, reset them, and change its Label.


File: gid.info,  Node: Graph Lines File Format,  Prev: Graph Lines Options,  Up: Graphs

Graph Lines File Format
-----------------------

   The Graph file that GiD uses is an standard ASCII file. Every line
of the file is a point of the Graph with X and Y coordinates separated
by a space.  Comment lines are also allowed and should begin with a
'`#''. The title of the Graph and the labels for the X and Y axis can
also be configured. If a comment line contains the Keyword '`Graf:''
the string between quotes that follows this keyword will be used as
title of the graf. The string  between quotes that follows the Keyword
'`X:'' will be used as label for the X axis. The same is also true for
the Y axis, but for the Keyword '`Y:''.

   Here an example:

             # Graf: "Nodes 26, 27, 28, ... 52 Graf."
             #
             # X: "Szz-Tensiones_Nods." Y: "Sxz-Tensiones_Nods."
             -3055.444 1672.365
             -2837.013 5892.115
             -2371.195 666.9543
             -2030.643 3390.457
             -1588.883 -4042.649
             -1011.5 1236.958
             # End


File: gid.info,  Node: Deform Mesh,  Next: Do Cuts,  Prev: Graphs,  Up: postprocessing results

Deform Mesh
===========

   Volumes, surfaces and cuts can be deformed according to a nodal
vector and a factor. When doing so all the results are drawn on the
deformed volumes, surfaces and cuts. This is called in GiD: `Main
Geometry'. Thus, when the `Main Geometry' is deformed, results are also
drawn deformed; and when `Main geometry' is in its original state,
results are also drawn in its original state.

   In GiD there is a `Deform Mesh' window to allow this.

   On the upper part of this window, the user can choose between the
`Original' state of the `Main Geometry' and the `Deformed' state, for
which a nodal vectorial result, and an anlysis and step, must be
selected and a factor entered.

   There is also a so-called `Reference Geometry' option. This allows
to visualize volumes, surfaces or cuts like `Main Geometry' but NO
results can be displayed over these volumes, surfaces or cuts.  It is
merely provided as a reference, to contrast several deformation or
changes of the original geometry. Remember that the current Mesh
`Display Style' will be used for the `Reference Geometry' and it can be
only changed when redoing it.

   On the lower part of the `Deform Mesh' window, this `Reference
Geometry' can be configured. The user can choose between:

   `Off', so this reference visualization is not displayed.

   ` Original', if `Main Geometry' is deformed and the user wants to
compare it with its original state without loosing a results
representation.

   `Deformation', where, after providing an analysis, step, result and
factor, the user can use it to contrast two deformation states, or a
deformed state and an original geometry.

   `Color', the colour of the `reference mesh'es can be the same as the
original meshes, or can be specified here.


File: gid.info,  Node: Do Cuts,  Next: Animation,  Prev: Deform Mesh,  Up: postprocessing results

Do Cuts
=======

   Here the user can cut and divide volumes, surfaces and cuts. A cut
of a volume mesh results into a cut plane. The cut is done for all the
meshes, despite that some of them are switched off.  When cutting
surfaces, a line set will be created. Here only those surfaces that are
switched on are cut.

   Another feature is that a cut can be deformed, if meshes are also
told to do so (*note Deform Mesh::.). A cut of a deformed mesh, when
changing to the original shape, will be deformed accordingly.

   When dividing volumes/surfaces only those elements of the
volumes/surfaces switched on that lie on one side of a specified plane
will be used to create another volume/surface.

   * Cut Plane: the user specifies a plane which cuts the
     volumes/surfaces. Several options can be used to enter this plane.
     With `Two Points' ( the default), the plane is defined by the
     corresponding line and the orthogonal direction to the screen.
     With `Three Points', the plane is defined by this three points.
     When choosing the points, the nodes of the mesh can also be used.
     All the volume meshes are cut, whether they are drawn or not.

   * Divide Volume Sets: the user specifies a plane which is used to
     divide the meshes. Several options can be used to enter this
     plane. With `Two Points' ( the default), the plane is defined by
     the corresponding line and the orthogonal direction to the screen.
     With `Three Points', the plane is defined by these three points.
     When choosing the points, the nodes of the mesh can also be used.
     After defining the plane, the user should choose which section of
     the mesh should be saved by select the side of the plane to use.
     Only those elements that lie entirely on this side are selected.
     Only those volume meshes that are shown are divided.

   * Divide Surface Sets: the user specifies a plane which is used to
     divide the sets. Several options can be used to enter this plane.
     With `Two Points' (the default), the plane is defined by the
     corresponding line and the orthogonal direction to the screen.
     With `Three Points', the plane is defined by these three points.
     When choosing the points, the nodes of the mesh can also be used.
     After defining the plane, the user should choose which section of
     the mesh should be saved by select the side of the plane to use.
     Only those elements that lie entirely on this side are selected.
     Only those surface meshes that are shown are divided.

     When doing a division, clicking with the right button mouse,
     inside the Contextual menu, there are several useful options:
        - exact: to do a exact division, i.e. elements are cut to
          create the division.

        - parallel planes: the remaining elements will be ones between
          two paralel planes, a `distance' can also be entered, after
          choosing this option from the same contextual menu

   * Divide lines: the user specifies a plane which is used to get the
     lines at one side of this plane

   * Succession: This option is an enhancement of `Cut Plane'. Here the
     user specifies an axis that will be used to create cut planes
     orthogonal to this axis. The number of planes is also asked for.

   * Cut Wire: Here the user can define a 'wire' tied to the edges of
     the elements of the volumes/surfaces. So when the volumes/surfaces
     are deformed, the wire is deformed too. And viceversa, if a wire
     is defined while the volumes/surfaces are deformed, when turning
     them into its original shape, the cut-wire is "undeformed" with
     them.

   * Convert cuts to surface sets: With this options cuts can be
     converted to surface sets so they can be saved, or cut again.

   Cuts can also be read and write from/to a file. The information
stored into the file from a 'Cut Plane' is the plane equation that
defines the plane ( Ax + By + Cz + D = 0), so it can be used with
several models.  The information stored into the file from a 'Cut Wire'
is the points list of the cut-wire, i.e. the interseccion between the
wire and the edges of the meshes/sets.  These files are standard ASCII
files. A line of a 'Cut Plane' archive contains the four coeficients of
the cut defining plane separated by spaces. A line of a 'Cut Wire'
archive contains the three coordinates of a point of the wire. Comment
lines are allowed and should begin with a '`#''.

   An example of a 'Cut Plane' archive where three planes were written:

             # planes created of a 'cut succesion'
             -10.82439 0.5740206 0 51.62557
             -10.82439 0.5740206 0 12.45994
             -10.82439 0.5740206 0 -26.70569

   An example of a 'Cut Wire' archive:

             -2.444425 3.883427 2.487002
             2.130787 2.762815 3.885021
             0.8411534 4.458836 3.215301
             4.270067 3.795048 2.037187
             5.66561 3.414776 0.8219391
             2.945865 3.600701 3.29012
             0.4487007 3.764661 3.574121


File: gid.info,  Node: Animation,  Next: Automatic comments,  Prev: Do Cuts,  Up: postprocessing results

Animation
=========

   With this window a little bit of automatization has been done to
create animations inside GiD.  Nowadays, almost all the results
visualization are animated. Only stream-lines are not automatized along
all the steps of the current analysis.

   This window lets the user create an animation of the current
`Results View', where the limits can be fixed along the animation with
`Automatic Limits', and/or of the `Deformation' of the meshes.
On the right of the `Step:' label, the step value is shown. On the
slide bar, the step number is shown.

   The four buttons under the slide bar are autoexplicative, they
should 'Rewind', 'Stop', 'Play' and 'Step' the animation. Also clicking
on the slide bar the animation can be stepped down or up. The green led
will change to red when an animation is beign stored on a file, after
pressing the 'Play' button. This led wil change back to green when the
animation is finished, or the 'Stop' button is pressed.

   Options are:

   * `Automatic Limits': here GiD searches for the minimum and maximum
     values of the results along all the steps of the analysis and uses
     them to draw the results view through all the steps.

   * `Endless': to do the animation forever.

   * `Delay': here the user can specify a delay time between steps in
     miliseconds.

   * `Save TIFF/GIFs on': with this option the user can save snapshots,
     in TIFF or GIF format, of each step, when the '`Play'' button is
     pushed. Here the filename given will be used as a prefix to create
     the TIFF/GIFs, for instance, if the user writes `MyAnimation',
     TIFF/GIF files will be created with names
     `MyAnimation-01.tif'/`MyAnimation-01.gif',
     `MyAnimation-02.tif'/`MyAnimation-02.gif', and so on.

   * `Save MPEG/AVI True Color/AVI 15bpp/GIF on': giving here a
     filename, a MPEG/AVI/GIF file will be created when 'Play' button
     is pushed.
     *Note:* To avoid problems when trying to view an MPEG format
     animation in Microsoft Windows, it is strongly recommended to use
     the Default menu to select a 'standard' size and press the Resize
     button. The graphical window will change to this 'standard' size.
     After finishing the animation, just selecting Default on the menu
     and pressing the Resize button, the previous size will be restored.

   * `Static analysis animation profile': if the project has only one
     step, it's possible to simulate an animation by generating
     intermediate steps. Use this option to automatically generate
     several frames, following a lineal, cosine, triangular or
     sinusoidal interpolation between the normal state and the deformed
     state.


File: gid.info,  Node: Automatic comments,  Next: Several results,  Prev: Animation,  Up: postprocessing results

Automatic comments
==================

   While displaying results, comments can be automatically generated by
switching on the `Automatic' checkbox in the Comments window, which
appears selecting `Utilities->Graphical->Comments'.

   If this option is selected and the comment lines are empty, the
program will create its own automatic comments, like these ones:


     Load Analysis, step 3
     Display Vectors of Desplacements, |Desplacements| factor 68095.4.
     Deformation ( x127.348): Desplacements of Load Analysis 2, step 8.

   in bold, the fields which will change when the visualization changes.

   The user can also create its own automatic comments, just filling
the comment lines.  To tell the program where the result name, analysis
name, etc., should be placed, following fields can be used:

   * %an: for analysis name of the current visualized result

   * %sv: for step value of the current visualized result

   * %vt: for result visualization type of the current visualized result

   * %vf: for vectors factor used in the current visualized result ( if
     any)

   * %rn: for result name of the current visualized result

   * %cn: for component name of the current visualized result

   * %da: for analysis name of the current deformation ( if any)

   * %ds: for step value of the current deformation ( if any)

   * %dr: for result name of the current deformation ( if any)

   * %df: for factor of the current deformation ( if any)

   GiD will substitute the fields by the values of the current
visualization.  Fields which can not be fulfilled will be empty.


File: gid.info,  Node: Several results,  Prev: Automatic comments,  Up: postprocessing results

Several results
===============

   With this window, which appears under `Windows->Several Results',
the user can select whether to view the results one by one, as usual,
or to view some results visualization types at once, for instace a
contour fill of preassure and velocity vectors at the same time.  From
this window the user can also delete not desired results visualization.
After selecting the desired behaviour, the user should press the
`Apply' button


File: gid.info,  Node: Customization,  Next: POSTPROCESS DATA FILES,  Prev: postprocessing results,  Up: Top

CUSTOMIZATION
*************

* Menu:

* Introduction - ProblemType::
* Configuration Files::
* Template File::
* Executing an external program::


File: gid.info,  Node: Introduction - ProblemType,  Next: Configuration Files,  Prev: Customization,  Up: Customization

Introduction
============

   When GiD is to be used for a particular type of analysis, it is
necessary to predefine all the information required from the user and
to define the way the final information is given to the solver module.
To do so, some files are used to describe conditions, materials,
general data, units systems, symbols and the format of the input file
for the solver. We call Problem Type to this this collection of files
used to configure GiD for a particular type of analysis.

   *Note:* You can also learn how to configure GiD for a particular
type of analysis, following the Problem Type Tutorial; this tutorial is
included with the GiD package you've bought. You can also download it
from the GiD web page. (http://gid.cimne.com/support)

   Due to the vocation of GiD as  general purpose pre and post
processor, the configuration for the different analysis must be
performed according to the particular specifications of every solver.
This implies the necessity of creating specific data input files for
every solver. However, GiD allows to perform this configuration process
inside itself without any change in the solver and without having to
program any independent utility.

   To configure these files means to define the data that must be input
by the user, as well as the materials to be implemented and other
geometrical and time-dependent conditions. It is also possible to add
some symbols or drawings to represent the defined conditions. GiD gives
the oportunity of working whith units when defining the properties of
the mentioned data, but there must be a configuration file where it
could be found the definition of the units systems.It must be also
defined the way that all this data must be written inside a file that
will be the input file to be read by the corresponding solver.

   The creation of a Problem Type implies the creation of a directory
with the Problem's Type name and the extension `.gid'. This directory
can be located in the current working directory or in the main GiD
executable directory.  The first case, the creation inside the current
working directory, can be useful during the development of the project.
Once it is finished, it can be advisable to move the directory to the
one where GiD is stored; like this, your Problem Type will be added to
those included in the system and it will appear in the GiD menu (*note
Problem type::.). In both cases, the series of files must be inside the
problem type directory. The name for most of them will be composed by
the same problem type's name and an extension referring to their
function. Considering `problem_type_name' to be the name of the Problem
Type and `project_name' the name of the project, the diagram of the
file configuration is the following:


   * directory name: `problem_type_name.gid'


   * directory location: `c:\a\b\c\GiD_directory\problemtypes'

     Note: In versions previous to 6.0 the `problemtypes' directory
     does not exist, so your problem type must reside in the
     `GiD_directory'. In versions later to 6.0 it's recommended to put
     your problem type inside the `problemtypes' directory.


   * Configuration files
        - `problem_type_name.cnd  Conditions definitions'

        - `problem_type_name.mat  Materials properties '

        - `problem_type_name.prb  Problem and intervals data'

        - `problem_type_name.uni  Units Systems'

        - `problem_type_name.sim  Conditions symbols '

        - `                   ***.geo  Symbols geometrical definitions'

        - `                   ***.geo  Symbols geometrical definitions'
          ...


   * Template files
        - `problem_type_name.bas  Information for the data input file'

        - `                  ***.bas  Information for additional files'

        - `                  ***.bas  Information for additional files'
          ...


   * TCL extension files
        - `problem_type_name.tcl  Extensions to GiD written in the
          TCL-TK programming language'


   * Command execution files
        - `problem_type_name.bat  Operating system shell that executes
          the analysis process'

   Files `problem_type_name.sim', `***.geo' and `***.bas' are not
mandatory and can be added to facilitate the visualization (files
`problem_type_name.sim' and `***.geo') or to prepare the data input for
the restart in additional files (files `***.bas').


File: gid.info,  Node: Configuration Files,  Next: Template File,  Prev: Introduction - ProblemType,  Up: Customization

Configuration Files
===================

   These files generate the conditions and material properties, as well
as the proper general problem and intervals data to be transferred to
the mesh, giving at the same time the chance to define geometrical
drawings or symbols to represent some conditions on the screen.

* Menu:

* Conditions file::
* Materials file::
* Problem and intervals data file::
* Conditions symbols file ::
* Unit System file::
* Special fields::


File: gid.info,  Node: Conditions file,  Next: Materials file,  Prev: Configuration Files,  Up: Configuration Files

Conditions file (.cnd)
----------------------

   The file with extension's name `.cnd' contains all the information
about the conditions that can be applied to different entities. The
condition can adopt different field values for every entity. This type
of information includes, for instance, all the displacement constraints
and applied loads in a structural problem or all the prescribed and
initial temperatures in a thermical analysis.

   An important characteristic of the `conditions' is that they must
define over what kind of entity are going to be applied, i.e., over
points, lines, surfaces, volumes or layers and over what kind of entity
will be transferred, i.e., over nodes, over face elements or over body
elements.

   * over nodes means that the condition will be transferred to the
     nodes contained in the geometrical entity where condition is
     assigned.

   * over face elements If this condition is applied to a line that is
     the boundary of a surface or to a surface that is the boundary of a
     volume, this condition is transferred to the higher elements,
     marking the affected face.

   * over body elements If this condition is applied to lines, it will
     be transferred to line elements. If it is assigned to surfaces, it
     will be transferred to surface elements. If in volumes, to volume
     elements.

   *Note:* For backwards compatibility, it is accepted the possibility
`over elements', that will transfer either to elements or to faces of
higher level elements.

   Another important feature is that all the conditions can be applied
to different entities with different values for all the defined
intervals of the problem.

   Therefore, a condition can be considered as a group of fields
containing the name of the referred condition, the geometric entity
over which it is applied, the mesh entity over which it will be
transferred, its corresponding properties and their values.

   The format of the file is as follows:

     NUMBER: condition_number CONDITION: condition_name
     CONDTYPE: 'over' ('points', 'lines', 'surfaces', 'volumes', 'layer')
     CONDMESHTYPE: 'over' ('nodes', 'face elems', 'body elements')
     QUESTION: field_name['#CB#'(...,optional_value_i,...)]
     VALUE: default_field_value
       ...
     QUESTION: field_name['#CB#'(...,optional_value_i,...)]
     VALUE: default_field_value
     END CONDITION
     NUMBER: condition_number CONDITION: condition_name
       ...
     END CONDITION

   Note: `#CB#' means Combo Box.

   Note that this file format does not permit to put blank lines between
the last line of a condition definition, `END CONDITION', and the first
one of the next condition definition.

Local Axes

     QUESTION: field_name['#LA#'('global', 'automatic', 'automatic alternative')]
     VALUE: default_field_value

   This type of field makes reference to the local axes system to be
used. The position of the values indicates the kind of local axes.

   If it only has a single default value, this will be the name of the
global axes. If two values are given, the second one will reference a
system that will be automatically computed for every node and that will
depend on the geometric constraints, like tangencies, orthogonalities,
etc.  If a third value is given, it will be the name of the automatic
alternative axes, which are the automatic axes rotated 90 degrees.

   All the different user defined systems will be added automatically
to these default possibilities.

   To enter only a specific kind of local axes it's possible to use the
modifiers `#G#',`#A#',`#L#'.
   - `#G#': global axes

   - `#A#': automatic axes

   - `#L#': automatic alternative axes

   When using these modifiers the position of the values doesn't
indicate the kind of local axes.

   Example
     QUESTION: Local_Axes#LA#(Option automatic#A#,Option automatic_alt#L#)
     VALUE: -Automatic-

Note: All the fields must be fulfilled with words, considering as a
word a character string without any blank space amongst them. The
strings signaled between quotes are literal and the ones inside
brackets are optional. The interface is case-sensitive, so the
uppercase letters must be maintained. `Default_field_value' and
different `optional_value_i' can be alphanumeric, integers or reals. GiD
treats them as alphanumeric until the moment that are written to the
solver input files.

   Note: The numbers of the conditions must be consecutive, beginning
with number 1.  There is no need to point out the overall number of
conditions or the respective number of fields for each one. This last
one can be variable for each condition.

   One optional flag to add to a condition is:

     CANREPEAT: yes

   It is written after CONDMESHTYPE and means that user can assign one
condition several times to the same entity.

   Another type of field that can be included inside a condition is:

     QUESTION: Surface_number#FUNC#(NumEntity)
     VALUE: 0
   Where the key `#FUNC#', means that the value of this field will be
calculated just when the mesh is generated. It can be considered a
function that evaluates when meshing. In the example above, `NumEntity'
is one of the possible variables of the function. It will be
substituted by the label of the geometry entity from where the node or
element is generated.

     QUESTION: X_preass#FUNC#(Cond(3,REAL)*(x-Cond(1,REAL))/(Cond(2,REAL)-Cond(1,REAL)))
     VALUE: 0
   In this second example, `x' variable is used, which means the
x-coordinate of the node or of the center of the element. Others fields
of the condition can also be used in the function. Variables `y' and
`z' give the y ans z-coordinate of this point.

   Note: There are other available options to expand the capabilities
of the conditions window. (*note Special fields::.)

* Menu:

* Example Conditions File creation ::


File: gid.info,  Node: Example Conditions File creation,  Prev: Conditions file,  Up: Conditions file

Example: Creating the conditions file
.....................................

   Next is an example of a condition file creation, explained step by
step:
  1. First, you have to create the folder or directory where all the
     problem type files are located, `problem_type_name.gid/' on this
     case.

  2. Then create and edit the file (`problem_type_name.cnd' on this
     example) inside the recently created directory (where all your
     problem type files are located).  As you can see, except for the
     extension, the name of the file and the directory are the same.

  3. Create the first condition, which starts with the line

          NUMBER: 1 CONDITION: Point-Constraints

     where the first number is used to index the condition. Each
     condition will be refered  with one unique number (two conditions
     can not share the same number). The second parameter is the name
     of the condition. Again, a unique condition name into this
     condition file is required.

  4. This first line is followed by the next pair:

          CONDTYPE: over points
          CONDMESHTYPE: over nodes

     which declare over what entity is going to be applied the
     condition. The first  line, `CONDTYPE:...' refers to the geometry,
     and may take as parameters the sentences "over points", "over
     lines", "over surfaces" or "over volumes".

     The second line refers to the type of condition applied to the
     mesh, once generated.  GiD does not force to provide this second
     parameter, but if it is present, the treatment  and evaluation of
     the problem will be more acurate.  The available parameters for
     this statement are "over nodes" and "over elements".

  5. Then, you'll have to declare a set of questions and values applied
     to this condition.

          QUESTION: Local-Axes#LA#(-GLOBAL-)
          VALUE: -GLOBAL-
          QUESTION: X-Force
          VALUE: 0.0
          QUESTION: X-Constraint:#CB#(1,0)
          VALUE: 1
          QUESTION: X_axis:#CB#(DEFORMATION_XX,DEFORMATION_XY,DEFORMATION_XZ)
          VALUE: DEFORMATION_XX
          
          END CONDITION

     After the QUESTION: word you have the choice of put:
        * An alphanumeric field name followed by the #LA# statement,
          and then the single or double parameter.

        * An alphanumeric field name.

        * An alphanumeric field name followed by the #CB# statement,
          and then the optional values between parenthesis.

     The VALUE: word must be followed by one of the optional values, if
     you  have declared them in the previous QUESTION: line. If you
     don't follow this statement, the program may not work correctly.
     In the previous example, the `X-Force' QUESTION takes the value
     0.0. Also in the example, the `X-Constraint' QUESTION includes a
     combo box statement (`#CB#'), followed by the declaration of the
     choices 1 and 0. In the next line, the value takes the parameter
     1. The `X_axis' QUESTION declares three items for the combo box
     `DEFORMATION_XX,DEFORMATION_XY,DEFORMATION_XZ', with the value
     `DEFORMATION_XX' choosen.  Beware of leaving blank spaces between
     parameters. If in the first question, you put  the optional values
     `(-GLOBAL, -AUTO-)', (note the blank space after the comma),
     there will be an error when reading the file. Take this precaution
     specially in  the Combo Box question parameters, to avoid
     inpredictable parameters.

  6. The management of the conditions defined in the `.cnd' file, is
     done in the Conditions window (found in the Data menu), in the
     preprocess of GiD.



File: gid.info,  Node: Materials file,  Next: Problem and intervals data file,  Prev: Conditions file,  Up: Configuration Files

Materials file (.mat)
---------------------

   This file `NAME.mat' include originally the definition of different
materials through their properties. These are base materials as they
can be used as templates during the pre-processing step for the
creation of newer ones.

   The user can define as many materials as desired and with a variable
number of fields.  All the unused materials will not be taken in
consideration when writing the data input files for the solver.
Alternatively, they can be useful to generate a materials library.

   Conversely to the case of conditions, the same material can be
assigned to different geometrical entities levels (lines, surfaces or
volumes) and even can be assigned directly to the mesh elements.

   In a similar way as a condition was defined, a material can be
considered as a group of fields containing its name, its corresponding
properties and their values.

   The format of the file is as follows:

     NUMBER: material_number MATERIAL: material_name
     QUESTION: field_name['#CB#'(...,optional_value_i,...)]
     VALUE: default_field_value
       ...
     QUESTION: field_name['#CB#'(...,optional_value_i,...)]
     VALUE: default_field_value
     END MATERIAL
     NUMBER: material_number MATERIAL: material_name
       ...
     END MATERIAL

   If a property of a material change depending on something (one
example would be one property depending on the temperature and defined
with several values for several temperatures), a table of changing
values may be declared for this property. When the solver evaluates the
problem, it reads the values and apply the suitable property value.

   The declaration of the table requires a pair of lines:

   First, a QUESTION line with a list of alphanumeric values between
parenthesis.
     QUESTION: field_name:(...,optional_value_i,...)
   This values are the name of each of the columns in the table, and
the number of values declared are the number of columns.

   This first line is followed by the actual data declaration: a line
started with the words `VALUE: #N#' is followed by a number that
indicates the quantity of elements in the matrix  and, finally, the
list of values.
     VALUE: #N# number_of_values ... value_number_i ...

   The number of values declared for the matrix, obviously, has to be
the multiplication of the number of columns by the number of rows to be
declared.

   The usual case of aplication of this declaration is on the
thermo-mechanical simulations, where the problem is exposed to a
temperature variation, and the properties of the materials change for
each temperature value.

   All the fields must be filled with words, considering a word as a
character string without any blank space amongst them. The strings
signaled between quotes are literal and the ones within brackets are
optional. The interface is case-sensitive, so the uppercase letters
must be maintained. `Default_field_value' and different
`optional_value_i' can be alphanumeric, integers or reals, depending on
the type.

   The numbers of the materials have to be consecutive, beginning with
number 1.  There is no need to point out the overall number of
materials or the respective number of fields for each one. This last
one can be variable for each material.

   Note that in this file it's not permitted the inclusion of blank
lines between material definitions neither between questions and values.

   Note: There are other available options to expand the capabilities
of the materials window. (*note Special fields::.)

* Menu:

* Example Materials File creation ::


File: gid.info,  Node: Example Materials File creation,  Prev: Materials file,  Up: Materials file

Example: Creating the materials file
....................................

   Next is an example of a materials file creation, explained step by
step:
  1. Create and edit the file (`problem_type_name.mat' on this example)
     inside the `problem_type_name' directory (where all your problem
     type files are located).  As you can see, except for the
     extension, the name of the file and the directory are the same.

  2. Create the first material, which starts with these lines:

          NUMBER: 1
          MATERIAL: Air
     The first number is used to index the material. Each material will
     be refered  with one unique number (two materials can not share
     the same number). The second parameter is the name of the
     material. Again, a unique material name into this  material file
     is required (do not use blank spaces in the name of the material.)

  3. The next two lines define a property of the material and its
     default value:

          QUESTION: Density
          VALUE: 1.0

     You can add as many properties as you want. To end the material
     definition, add the following line:

          END MATERIAL

  4. In this example we have introduced some materials; the `.mat' file
     would be as follows:
          NUMBER: 1 MATERIAL: Air
          QUESTION: Density
          VALUE: 1.01
          END MATERIAL
          NUMBER: 2 MATERIAL: Steel
          QUESTION: Density
          VALUE: 7850
          END MATERIAL
          NUMBER: 3 MATERIAL: Aluminium
          QUESTION: Density
          VALUE: 2650
          END MATERIAL
          NUMBER: 4 MATERIAL: Concrete
          QUESTION: Density
          VALUE: 2350
          END MATERIAL
          NUMBER: 5 MATERIAL: Water
          QUESTION: Density
          VALUE: 997
          END MATERIAL
          NUMBER: 6 MATERIAL: Sand
          QUESTION: Density
          VALUE: 1370
          END MATERIAL

  5. The management of the materials defined in the `.mat' file, is
     done in the Materials window (found in the Data menu), in the
     preprocess of GiD.



File: gid.info,  Node: Problem and intervals data file,  Next: Conditions symbols file,  Prev: Materials file,  Up: Configuration Files

Problem and intervals data file (.prb)
--------------------------------------

   The file `NAME.prb' contains all the information about the general
problem and intervals data.  The general problem data is all the
information required for performing the analysis and it does not
concern any particular geometrical entity. This differs from the
previous definitions of conditions and materials properties, which are
assigned to different entities. Example of general problem data can be
the type of solution algorithm used by the solver, the value of the
various time steps, convergence conditions and so on.

   Within this data, the user may consider the definition of specific
problem data (for the whole process) and intervals data (variable
values along the different solution intervals). An interval would be
the subdivision of a general problem that contains its own particular
data. Typically, one can define a different load case for every
interval or, in dynamic problems, not only variable loads, but also
changing the various time steps, convergence conditions and so on.

   The format of the file is as follows:

     PROBLEM DATA
     QUESTION: field_name['#CB#'(...,optional_value_i,...)]
     VALUE: default_field_value
       ...
     QUESTION: field_name['#CB#'(...,optional_value_i,...)]
     VALUE: default_field_value
     END PROBLEM DATA
     
     
     INTERVAL DATA
     QUESTION: field_name['#CB#'(...,optional_value_i,...)]
     VALUE: default_field_value
       ...
     QUESTION: field_name['#CB#'(...,optional_value_i,...)]
     VALUE: default_field_value
     END INTERVAL DATA

   All the fields must be filled with words, considering a word as a
character string without any blank space amongst them. The strings
signaled between quotes are literal and the ones inside brackets are
optional. The interface is case-sensitive, so the uppercase letters
must be maintained. `Default_field_value' and different
`optional_value_i' can be alphanumeric, integers or reals, depending on
the type.

   Note: There are other available options to expand the capabilities
of the Problem Data window. (*note Special fields::.)

* Menu:

* Example Problem and intervals data file creation::


File: gid.info,  Node: Example Problem and intervals data file creation,  Prev: Problem and intervals data file,  Up: Problem and intervals data file

Example: Creating the PRB data file
...................................

   Next is an example of a problem data file creation, explained step
by step:
  1. Create and edit the file (`problem_type_name.prb' on this example)
     inside the `problem_type_name' directory (where all your problem
     type files are located).  Except for the extension, the name of
     the file and the directory must be the same.

  2. Start the file with this line:

          PROBLEM DATA

  3. Then, add the following lines:

          QUESTION: Unit_System#CB#(SI,CGS,User)
          VALUE: SI
          
          QUESTION: Title
          VALUE: Default_title

     The first question defines a combo style menu called
     `Unit_System', which has the `SI' option selected by default. The
     second question defines a text field called `Title', and its
     default value is `Default_title'.

  4. To finish the file, add the following line:

          END PROBLEM DATA

  5. The whole file is as follows:

          PROBLEM DATA
          QUESTION: Unit_System#CB#(SI,CGS,User)
          VALUE: SI
          QUESTION: Title
          VALUE: Default_title
          END GENERAL DATA

  6. The management of the options defined in the `.prb' file, is done
     in the Problem Data window (found in the Data menu), in the
     preprocess of GiD.



File: gid.info,  Node: Conditions symbols file,  Next: Unit System file,  Prev: Problem and intervals data file,  Up: Configuration Files

Conditions symbols file (.sim)
------------------------------

   This file `NAME.sim' comprises different symbols to represent some
conditions during the pre-processing stage. The user may define these
symbols by creating, ad hoc, geometrical drawings and the appropriate
symbol will appear over the entity with the applied condition every
time the user asks for it.

   One or more symbols can be defined for every condition and the
selection will depend on the specified values in the file, which may be
obtained through mathematical conditions.

   Also the spatial orientation can be defined in this file, depending
on the values taken by the required data. For global definitions, the
user must input the three components of a vector to express its spatial
direction. GiD takes these values from the corresponding conditions
window. The orientation of the vector can be understood as the rotation
from vector (1,0,0) towards the new vector defined in the file.

   For line and surface conditions, the symbols may be considered as
local. In this case, GiD does not consider the defined spatial
orientation vector and it takes its values from the line or surface
orientation. The orientation assumes vector (1,0,0) to be the
corresponding entity's normal.

   These components, making reference to the values obtained from the
adequate conditions, may include C-language expressions. They express
the different field values of the mentioned condition as
`cond(type,i)', where `type' (`real' or `int') makes reference to the
type of variable (independent of the letters case) and `i' is the
number of the field for that particular condition.

* Menu:

* Example Symbols File creation ::


File: gid.info,  Node: Example Symbols File creation,  Prev: Conditions symbols file,  Up: Conditions symbols file

Example: Creating the Symbols file
..................................

   Next is an example of a symbol file creation.  Create and edit the
file (`problem_type_name.sim' on this example) inside the
`problem_type_name' directory (where all your problem type files are
located).  Except for the extension, the name of the file and the
directory must be the same.

   The contents of the `problem_type_name.sim' example should be the
following:

     cond Point-Constraints
     3
     global
     cond(int,5)
     1
     0
     0
     Support3D.geo
     global
     cond(int,1) && cond(int,3)
     1
     0
     0
     Support.geo
     global
     cond(int,1) || cond(int,3)
     cond(int,3)
     cond(int,1)*(-1)
     0
     Support-2D.geo
     cond Face-Load
     1
     local
     fabs(cond(real,2))+fabs(cond(real,4))+fabs(cond(real,6))>0.
     cond(real,2)
     cond(real,4)
     cond(real,6)
     Normal.geo

   This is a particular example of the file `.sim' where the user has
defined four different symbols. Each one is read from a file `***.geo'.
There is no indication of how many overall symbols are implemented. GiD
simply reads all the file long through the end.

   The files `***.geo' are obtained through GiD. The user may design a
particular drawing to symbolize a condition and this drawing will be
stored as `PROBLEMNAME.geo' when saving this project as
`PROBLEMNAME.gid'.  The user needs not to be concerned about the symbol
size but has to keep in mind that the origin corresponds to the point
(0,0,0) and the reference vector is (1,0,0). Subsequently, when these
files `***.geo' are invoked from `problem_type_name.sim', the symbol
drawing, appears scaled on the display, at the entities location.

   Nevertheless, the number of symbols and consequently, the number of
files `***.geo', can vary from a condition to another. In the previous
example, for instance, the condition called `Point-Constraints', which
is so declared by the use of `cond', comprises three different symbols.
GiD knows that from the number 3 written below the condition's name.
Next, GiD reads if the orientation is relative to the spatial axes
(global) or moves together with its entity (local). In the example, the
three symbols concerning point constraints are globally oriented.

   Let's imagine that this condition has six fields. First, third and
fifth field values express if there exist constraints along `X-axis',
`Y-axis' and `Z-axis', respectively.  These values are integers and in
case they were null, the concerned degree of freedom would be assumed
to be unconstrained.

   For the first symbol, got from the file `Support3D.geo', GiD reads
`cond(int,5)', or `Z-constraint'. If it is false, what means that the
field's value is zero, the C-condition will not be accomplished and GiD
will not draw it. Otherwise, the C-condition will be accomplished and
the symbol will be invoked. When this occurs, GiD skips the rest of
symbols related to this condition. Its orientation will be the same of
the original drawing because the spatial vector is (1,0,0).

   All the considerations are valid for the second symbol, got from the
file Support.geo, but now GiD has to check that both constraints
(`&&'), `X-constraint' and `Y-constraint' are fixed (values different
from zero).

   For the third symbol, got from the file `Support-2D.geo', only one
of them has to be fixed (`||') and the orientation of the symbol will
depend on which one is free and which one is fixed, showing on the
screen the corresponding direction for both degrees of freedom.

   Finally, for the fourth symbol, got from the file `Normal.geo', it
can be observed that the drawing of the symbol, related to the local
orientation will appear scaled according to the real-type values of the
second, fourth and sixth fields values. Different ways of C-language
expressions are available in GiD.  Thus, the last expression would be
equivalent to put '`(fabs(cond(real,2))>0. || fabs(cond(real,4))!=0. ||
fabs(cond(real,6))>1e-10)''.

   *Note:* As previously mentioned, GiD internally creates a
`PROJECTNAME.geo' when saving a project, where it keeps all the
information about the geometry in binary format. In fact, this is the
reason why the extension of these files is `.geo'. However, the file
`PROJECTNAME.geo' is stored in the `PROJECTNAME.gid' directory, whereas
these user-created files `***.geo' are stored in the
`problem_type_name.gid' directory, being `problem_type_name' the
problem's name.


File: gid.info,  Node: Unit System file,  Next: Special fields,  Prev: Conditions symbols file,  Up: Configuration Files

Unit System file (.uni)
-----------------------

   When GiD is installed, the file `units.gid' is copied within the GiD
directory.  In this file it's defined a table of magnitudes. For each
magnitude there is a set of units and a convertion factor between the
unit and the reference unit. Also are defined the units systems. An unit
system is a set of mangnitudes and the corresponding unit.

     BEGIN TABLE
      LENGTH : m {reference}, 100 cm, 1e+3 mm
      ...
      STRENGTH : kg*m/s^2 {reference}, N, 1.0e-1 kp
     END
     
     BEGIN SYSTEM(INTERNATIONAL)
      LENGTH : m
      MASS : kg
      STRENGTH : N
      ...
      TEMPERATURE : C
     END

   The syntax of the unit file (`problem_type_name.uni') within the
problem type is similar.  Besides, it could include the line:

     USER DEFINED: ENABLED
     (or DISABLED)

   meaning that the user is able (or not) to define it's own system unit
within the project. If the line does not appear in the file then, it's
assumed as having the value `ENABLED'

   Some magnitudes can be hidden to the user in the units window with
this order: `HIDDEN: 'magnitude', 'magnitude''
     HIDDEN: strength, pressure

   If the problem type uses a property which has a unit, then GiD
creates the file `project_name.uni' in the project directory. This file
includes the information related to the unit used in the geometric model
and the unit system used. The structure of this file is:

     MODEL: km
     
     PROBLEM: USER DEFINED
     
     BEGIN SYSTEM
      LENGTH: m
      PRESSURE: Pa
      MASS: kg
      STRENGTH: N
     END

   In this file, MODEL refers to the unit of the geometric model,
PROBLEM is the name of the units system used by GiD to convert all the
data properties in the output to the solver. If this name is USER
DEFINED, then the system is the one defined within the file. The block
     BEGIN SYSTEM
      ...
     END
   corresponds to the user defined system.


File: gid.info,  Node: Special fields,  Prev: Unit System file,  Up: Configuration Files

Special fields
--------------

   These fields are useful in order to organize the information within
the data files.  They make the information showed on the data windows
nicest and more readable. In this way the user can concentrate just on
the data properties concerning the current context.

   * Book: With the field Book it is possible to split the data windows
     in other windows. For example, we can have two windows for the
     materials, one for the steels and another for the concretes:
          BOOK: Steels
          ...
          All steels come here
          ...
          BOOK: Concretes
          ...
          All concretes come here
          ...

     The same applies to conditions. For general and interval data, the
     field book groups a set of properties.
   * Title: The Title field groups a set of properties on diferent tabs
     of one book. All properties appearing after this field will be
     included on this tab.

          TITLE: Basic
          ...
          Basics properties
          ....
          TITLE: Advanced
          ...
          Advanced properties
          ...

   * Help: With the Help field it's posible to assign a description to
     the data property preceding it. In this way the user can inspect
     the meaning of the property throught the help context function:
     staying for a while with the mouse on the property or clicking the
     right button.

          QUESTION: X_flag#CB#(1,0)
          VALUE: 1
          HELP: If this flag is set, movement is ...

   * Image: The Image field is useful to insert descriptive pictures on
     the data window. The value of this field is the file name of the
     picture relative to the problem type location.

          IMAGE: omega3.gif

   * Unit field: With this feature it's posible to define and work with
     properties having units. GiD is responsible for the convertion
     between units of the same magnitud.

          ...
          QUESTION: Elastic modulus XX axis:#UNITS#
          VALUE: 2.1E+11Pa
          ...

   * Dependencies: Depending on the value, we can define some behavior
     asociated to the property. For each value we can have a list of
     actions. The syntax is as follows:
     `















































     DEPENDENCIES:(<V1>,[TITLESTATE,<Title>,<State>],<A1>,<P1>,<NV1>,...,<An>,<Pn>,<NVn>)...(<Vm>,<Am>,<Pm>,<NVm>,...)'
     where:


       1. <Vi> is the value that triggers the actions. A special value
          is #DEFAULT#, which refers to all the values not listed.

       2.  [TITLESTATE,<Title>,<State>] this argument is optional.
          Titlestate should be used to show or hide book labels. Many
          Titlestate can be given. <Title> is the title defined for a
          book (TITLE: Title). State is the visualization mode:
          `normal' or `hidden'.

       3.  <Ai> is the action and can have one of these values: SET,
          HIDE, RESTORE.  All these actions change the value of the
          property with the following diferences: SET disables the
          property, HIDE hides the property and RESTORE brings the
          property to the enabled state.

       4. <Pi> is the name of the property to modify.

       5. <NVi> is the new value of <Pi>. A special value is #CURRENT#,
          which refers to the current value of <Pi>.


     Here is an example,
          ...
          TITLE: General
          QUESTION: Type_of_Analysis:#CB#(FILLING,SOLIDIFICATION)
          VALUE:  SOLIDIFICATION
          DEPENDENCIES: (FILLING,TITLESTATE,Filling-Strategy,normal,RESTORE,
          Filling_Analysis,GRAVITY,HIDE,Solidification_Analysis,#CURRENT#)
          DEPENDENCIES: (SOLIDIFICATION,TITLESTATE,Filling-Strategy,hidden,HIDE,
          Filling_Analysis,#CURRENT#,RESTORE,Solidification_Analysis,#CURRENT#)
          TITLE: Filling-Strategy
          QUESTION: Filling_Analysis:#CB#(GRAVITY,LOW-PRESSURE,FLOW-RATE)
          VALUE:  GRAVITY
          QUESTION: Solidification_Analysis:#CB#(THERMAL,THERMO-MECHANICAL)
          VALUE:  THERMAL
          ...

   * State: Defines the state of a field. The state of a field can be
     `disabled', `enabled' or `hidden'.
     Here is an example,
          ...
          QUESTION: Elastic modulus XX axis
          VALUE: 2.1E+11
          STATE: HIDDEN

   * #MAT#('BookName'): Defines the field as a material, to be selected
     from the list of materials of the book 'BookName'.
     Here is an example,
          QUESTION:Composition_Material#MAT#(BaseMat)
          VALUE:AISI_4340_STEEL


File: gid.info,  Node: Template File,  Next: Executing an external program,  Prev: Configuration Files,  Up: Customization

Template File
=============

   Once the user has generated the mesh, assigned the conditions and
the materials properties, as well as the general problem and intervals
data for the solver, it is necessary to produce the data input files to
be processed by that program.

   To manage this reading, GiD has the capability of interpret a file
called `problem_type_name.bas' (where `problem_type_name ' is the name
of the working directory of the Problem Type without the `.bas'
extension).

   This file (template file) describes the format and structure of the
required data input file for the solver that is used in a particular
case. This file must remain in  the `problem_type_name.gid' directory,
as well as the other files already described, `problem_type_name.cnd',
`problem_type_name.mat', `problem_type_name.prb' and also
`problem_type_name.sim' and `***.geo', if desired.

   In case more than one data input file is needed, GiD allows the
creation of more files by means of additional files `***.bas' (note
that while `problem_type_name.bas' creates an data input file named
`project_name.dat', successive files `***.bas', -where `***' can be any
name-, create successive files `project_name-1.dat',
`project_name-2.dat' and so on), the new files follow the same rules
than the ones explained next for `problem_type_name.bas'.

   These files work as interface from the GiD's standard results to the
specific data input for any individual solver module.  This allows to
complete the process of running the analysis (*note Calculate::.) as
one step more within the system.

   In case of an error in the preparation of the data input files, the
programmer has only to fix the corresponding file
`problem_type_name.bas' or `***.bas' and rerun the example, without
having to leave GiD, recompile or, even more, reassign any data or
remesh.

   This facility is due to the structure of the template files. They
are a group of macros (like an ordinary programming language) that can
be read, without need of any compiler, every time the corresponding
analysis file is to be written. This ensures a fast way to debug
mistakes.

* Menu:

* General description::
* Commands used in the .bas file::
* Detailed example::


File: gid.info,  Node: General description,  Next: Commands used in the .bas file,  Prev: Template File,  Up: Template File

General description
-------------------

   All the rules that apply to the file `NAME.bas' are also valid for
the rest of files with extension `.bas'. Thus, everything in this
section will refer explicitly to the file `NAME.bas'. Any information
written into this file, apart from the so-called commands, is
reproduced exactly in the output file (the data input file for the
numerical solver). The commands are words that begin with the character
*.  If the programmer wants to write an asterisk into the file he
should write **. The commands are inserted among the text to be
literally translated. Everyone of these commands returns one (*note
Single value return commands::.) or multiple (*note Multiple values
return commands::.) values obtained from the pre-processing. Other
commands mimic the traditional structures to do loops or conditionals
(*note Specific commands::.). It is also possible to create variables
to manage some data. Comparing it to a classic programming language,
the main differences will be the following:

   * The text is reproduced literally, without printing instructions,
     as it is writing-oriented.

   * There are no indices in the loops. When the program begins a loop,
     it already knows the number of iterations to perform. Furthermore,
     the inner variables of the loop change their values automatically.

     All the commands can be divided into three types:

        - Commands that return one single value. This value can be an
          integer, a real or a string. The value depends on certain
          values that are available to the command and on the position
          of the command, within the loop or after setting some other
          parameters.  These commands can be inserted within the text
          and write their value where it corresponds in it. They can
          also appear inside an expression, what would be the example
          of the conditionals. For this example, the user may specify
          the type of the variable, integer or real, except when using
          `strcmp' or `strcasecmp'. If these commands are within an
          expression, no * should precede the command.

        - Commands that return more than one value. Their use is
          similar to that of the previously indicated commands, except
          for the fact that they cannot be used in other expressions.
          They can return different values, one after the other,
          depending on some values of the project.

        - Commands that perform loops or conditionals, create new
          variables, or define some specifications. The latter include
          condition or type of element chosen and also serve to prevent
          line-feeding. These commands must start at the beginning of
          the line and nothing will be written into the calculations
          file. After the command, in the same line, there can be other
          commands or words to complement the definitions, so, in an end
          of a loop or conditional, after the command the user may
          write what loop or conditional was finished.

   The arguments that appear in a command are written immediately
behind it and inside parenthesis. If there are more than one, they will
be separated by commas. The parenthesis might be put without any
argument inside.  This is useful to write something just behind the
command without any separation in the middle. The arguments can be real
numbers or integers, meaning the word `REAL' or the word `INT' (both in
upper or lowercase) that the value to which it points has to be
considered as real or integer, respectively. Other types of arguments
are sometimes allowed, like the type of element, described by its name,
in the command `*set elem', or a chain of characters inserted between
double quotes " for the C-instructions `strcmp' and `strcasecmp'. It is
also possible, sometimes, to write the field's name instead of its
ordering number.

   EXAMPLE:

   Next it's showed a piece of what it could be a `.bas' file. There
are two commands (*nelem and *npoin) which return the total number of
elements and nodes of a project.
     %%%% Problem Size %%%%
     Number of Elements & Nodes:
     *nelem *npoin

   This `.bas' file will be converted into a `project_name.dat' file by
GiD. The contents of the `project_name.dat' file could be something
like this:

     %%%% Problem Size %%%%
     Number of Elements & Nodes:
     5379 4678

   (being 5379 the number of elements of the project, and 4678 the
number of nodes)


File: gid.info,  Node: Commands used in the .bas file,  Next: Detailed example,  Prev: General description,  Up: Template File

Commands used in the .bas file
------------------------------

* Menu:
* Menu:

* Single value return commands::
* Multiple values return commands::
* Specific commands::


File: gid.info,  Node: Single value return commands,  Next: Multiple values return commands,  Prev: Commands used in the .bas file,  Up: Commands used in the .bas file

Single value return commands
............................

   When writing a command, it is generally (if not explicitly mentioned)
independent of the letters case, even a mixture of uppercase or
lowercase would not affect the results.

   * *npoin, *ndime, *nnode, *nelem, *nmats. They return,
     respectively, the number of points, the dimension of the project
     being considered, the number of nodes of the element with the
     highest number, the number of elements and the number of materials.
     All of them are considered as integers and do not carry arguments
     (see `*format', `*intformat'), except `*nelem', which can bring
     different types of elements.  These elements are `Linear',
     `Triangle', `Quadrilateral', `Tetrahedra', `Hexahedra', depending
     on the number of edges of the element and `All', that comprises
     all the possible types. The command `*nmats' returns the number of
     materials effectively assigned to an entity, not all the defined
     ones.

   * *GenData. It must carry an argument of integer type that specifies
     the number of the field to be printed. This number is the order of
     the field inside the general data list. This must be one of the
     values that are fixed for all the problem, independently of the
     interval (*note Problem and intervals data file::.).  The field's
     name can also be the argument, instead, or even an abbreviation of
     it.

     The arguments `REAL' or `INT' to express the type of number for
     the field are also available (see `*format', `*intformat',
     `*realformat', `*if'). If they are not specified, the program will
     print a character string. It is mandatory to write one of them
     within an expression, except for `strcmp' and `strcasecmp'. The
     numeration must start with number 1.

   * *IntvData. The only difference with the previous one is that the
     field must be one of those fields varying with the interval (*note
     Problem and intervals data file::.).  This command must be within
     a loop over intervals (see `*loop') and the program will
     automatically update the suitable value for each iteration.

   * *MatProp. The only difference with the previous ones is that it
     must be within a loop over the materials (see `*loop'). It returns
     the property whose field's number or name is defined by its
     argument. It's recommended the use of names instead of field
     numbers.
     Note: If argument is 0, it returns the material's name.

     *Caution:* If there are materials with different number of fields,
     the user must ensure not to print non-existent fields, using
     conditionals.

   * *Cond. The same previous remarks apply here, although now the user
     must notify with the command `*set' (see `*set') which is the
     condition being processed. It can be within a loop (see `*loop')
     over the different intervals in case that the conditions vary for
     each interval.

   * *ElemsNum: returns the element's number.
     *NodesNum: returns the node's number.
     *MatNum: returns the material's number.
     *ElemsMat: returns the number of the material assigned to the
     element.
     All of this commands must be within a proper loop (see `*loop')
     and change automatically for each iteration. They are considered as
     integers and cannot carry any argument. The number of materials
     will be reordered numerically, to begin from number 1 and will
     increase up to the number of materials assigned to any entity.
   * *LayerNum: returns the layer's number.
     *LayerName: returns the layer's name.
     *LayerColorRGB: returns the layer's color in RGB (three integer
     numbers between 0 and 256). If parameter `(1)', `(2)' or `(3)' is
     specified, the command returns the only the value of one color.
     RED is 1, GREEN is 2 and BLUE is 3.
     Commands *LayerName, *LayerNum and *LayerColorRGB must be inside a
     loop over layers; you cannot use this commands in a loop over
     nodes or elements.
     Example:
          *loop layers
          *LayerName *LayerColorRGB
          *Operation(LayerColorRGB(1)/255.0) *Operation(LayerColorRGB(2)/255.0) *Operation(LayerColorRGB(3)/255.0)
          *end layers

   * *NodesLayerNum: returns the layer's number. Must be used in a loop
     over nodes.
     *NodesLayerName: returns the layer's name. Must be used in a loop
     over nodes.
     *ElemsLayerNum: returns the layer's number. Must be used in a loop
     over elems.
     *ElemsLayerName: returns the layer's name. Must be used in a loop
     over elems.
   * *CondNumEntities. The user must have previously selected a
     condition (see `*set'). It returns the number of entities that
     have a condition assigned over them.

   * *LoopVar. This command must be inside a loop and returns, as an
     integer, what is considered to be the internal variable of the
     loop. This variable takes the value 1 in the first iteration and
     increases a unit for each new iteration.

     The parameter `elems,nodes,materials,intervals', used as argument
     for the corresponding loop, allows the program know which one is
     being processed.  Otherwise, if there are nested loops, the
     program takes the value of the inner loop.

   * *Operation. It returns the result of an arithmetical expression
     what should be written inside parenthesis just immediately behind
     the command. This operation must be defined in C-format and can
     contain any of the commands that return one single value. The user
     can force the return of an integer or a real by means of the
     mentioned parameters `INT' or `REAL'. Otherwise, GiD returns the
     type according to the result.
     The valid C functions that can be used are:
        { } `+,-,*,/,(,),=,<,>,!,&,|, numbers and variables'

        { } `sin'

        { } `cos'

        { } `tan'

        { } `asin'

        { } `acos'

        { } `atan'

        { } `atan2'

        { } `exp'

        { } `fabs'

        { } `abs'

        { } `pow'

        { } `sqrt'

        { } `strcmp'

        { } `strcasecmp'
     The following are valid examples of operations:

          *operation(4*elemsnum+1)
          *operation(8*(loopvar-1)+1)

     *Note:* There cannot be blank spaces between the commands and the
     parenthesis that include the parameters.

     *Note:* Commands inside `*operation' do not need to put * at the
     beginning.

   * *LocalAxesNum. It returns the identification name of the local
     axes system, either when the loop is over the nodes or when it is
     over the elements, under a referenced condition.

   * *nlocalaxes. It returns the number of the defined local axes
     system.

   * *IsQuadratic. It returns the value 1 when the elements are
     quadratic or 0 when they are not.
   * *Time. It returns the number of seconds elapsed since midnight.

   * *Clock. It returns the number of clock ticks (aprox. milliseconds)
     of elapsed processor time.
     EXAMPLE:
          *set var t0=clock
          *loop nodes
            *nodescoord
          *end nodes
          *set var t1=clock
          ellapsed time=*operation((t1-t0)/1000.0) seconds

   * *Units('magnitude'). It returns current unit name for the selected
     magnitude.  (the curren unit is the unit showed inside the unit
     window)
     EXAMPLE
          *Units(LENGTH)

   * *BasicUnit('magnitude'). It returns basic unit name for the
     selected magnitude.  (the basic unit is the unit defined as {
     Basic } in the *.uni file)
     EXAMPLE
          *BasicUnit(LENGTH)

   * *FactorUnit('unit'). It returns the numeric factor to convert a
     magnitude from the selected unit to the basic unit.
     EXAMPLE
          *FactorUnit(PRESSURE)


File: gid.info,  Node: Multiple values return commands,  Next: Specific commands,  Prev: Single value return commands,  Up: Commands used in the .bas file

Multiple values return commands
...............................

   These commands return more than one value in a prescribed order,
writing them one behind another. All of them, but `LocalAxesDef', are
able to return one single value when a numerical argument giving the
order of the value is added to the command. In this way, these commands
can appear within an expression.  `LocalAxesDef' or the rest of the
commands without the numerical argument cannot be used inside
expressions. Following, it is displayed a list of the commands with the
appropriate description:

   * *NodesCoord. This command writes the node's coordinates. It must be
     inside a loop (see `*loop') over the nodes or elements. The
     coordinates are considered as real numbers (see `*realformat' and
     `*format').  It will write two or three coordinates according to
     the problem's dimension (see `*Ndime'). If *NodesCoord receives an
     argument inside a loop of nodes, this argument indicates which
     coordinate x, y or z must be written:
     Inside a loop of nodes:
     `*NodesCoord    ' writes three or two coordinates depending on the
     problem's dimension.
     `*NodesCoord(1) ' writes the x coordinate of the actual node of
     the loop.
     `*NodesCoord(2) ' writes the y coordinate of the actual node of
     the loop.
     `*NodesCoord(3) ' writes the z coordinate of the actual node of
     the loop.
     If the argument `real' is given, the coordinates will be treated
     as a real number.
     Example: using *NodesCoord inside a loop of nodes
          Coordinates:
            Node        X                Y
          *set elems(all)
          *loop nodes
          *format "%5i%14.5e%14.5e"
          *NodesNum *NodesCoord(1,real) *NodesCoord(2,real)
          *end nodes
     This command effects a rundown of all the nodes of the mesh,
     listing their identifiers and coordinates (x and y coordinates).

     The contents of the `project_name.dat' file could be something
     like this:
          Coordinates:
            Node        X                Y
              1  -1.28571e+001  -1.92931e+000
              2  -1.15611e+001  -2.13549e+000
              3  -1.26436e+001  -5.44919e-001
              4  -1.06161e+001  -1.08545e+000
              5  -1.12029e+001   9.22373e-002
              ...

     *NodesCoord can also be used inside a loop of elements. In this
     case, it needs an additional argument that gives the local number
     of the node inside the element. After this argument it's also
     possible to give which coordinate has to be written x, y or z.
     Inside a loop of elements:
     `*NodesCoord(4)   ' writes the coordinates of the 4th node of the
     actual element of the loop.
     `*NodesCoord(5,1) ' writes the x coordinate of the 5th node of the
     actual element of the loop.
     `*NodesCoord(5,2) ' writes the y coordinate of the 5th node of the
     actual element of the loop.
     `*NodesCoord(5,3) ' writes the z coordinate of the 5th node of the
     actual element of the loop.
   * *ElemsConec. This command writes the element's connectivities,
     i.e., the list of the nodes that belong to the element, keeping
     the proper sense for each case (anti-clockwise sense in 2D and
     depending on the standards in 3D).  For shells, the user must
     define the sense. However, this command accepts the argument
     `swap' and this implies that the ordering of the nodes in
     quadratic elements will be inverted. The connectivities are
     considered as integer numbers (see `*intformat' and `*format').

     *Note:* In the first versions of GiD, the optional parameter of the
     last command explained was `invert' instead of the present
     (`swap'). It was changed due to technical reasons. If you have an
     old `.bas' file prior to this specification, which contains this
     command in its previous form, when you try to export the
     calculation file, you will be warned about this change of use. Be
     aware that the output file will not be created as the user expects.

   * *GlobalNodes. This command returns the nodes that belong to an
     element's face where a condition has been defined (on the loop
     over the elements).  The sense is the same that the sense of the
     element's connectivities. The returned values are considered as
     integer numbers (see `*intformat' and `*format').
     So, the local numeration of the faces is:

          Triangle:       12  23  31
          Quadrilateral:  12  23  34  41
          Tetrahedra:     123 243 341 421
          Hexahedra:      1234  1562  2673  3784  1485  5876

   * *LocalNodes. The only difference with the previous one is that the
     returned value is the local node's numbering for the corresponding
     element (between 1 and `nnode)'.

   * *ElemsNnode. This command returns the number of nodes of the
     current element. (valid only inside a loop over elements)
     Note: This command is only available in GiD version 6.2.0b or
     newer.  Example:
          *loop elems
            *ElemsNnode
          *end elems

   * *ElemsNnodeCurt. This command returns the number of vertex nodes
     of the current element. (valid only inside a loop over elements)
     For example, for a quadilateral of 4, 8 or 9 nodes, it returns the
     value 4.
     Note: This command is only available in GiD version 7.2 or newer.

   * *ElemsType: returns the current element type as a integer value:
















     1=Linear,2=Triangle,3=Quadrilateral,4=Tetrahedra,5=Hexahedra,6=Prism,7=OnlyPoints.
     (valid only inside a loop over elements)
     Note: This command is only available in GiD version 7.2.2b or
     newer.

   * *ElemsTypeName: returns the current element type as a string
     value:


     Linear,Triangle,Quadrilateral,Tetrahedra,Hexahedra,Prism,OnlyPoints.
     (valid only inside a loop over elements)
     Note: This command is only available in GiD version 7.2.2b or
     newer.

   * *LocalAxesDef.  This command returns the nine numbers that define
     the transformation matrix of a vector from the local axes system
     to the global one.  Example:
          *loop localaxes
          *format "%10.4lg %* %* %10.4lg %* %* %10.4lg %* %*"
          x'=*LocalAxesDef
          *format "%* %10.4lg %* %* %10.4lg %* %* %10.4lg %*"
          y'=*LocalAxesDef
          *format "%* %* %10.4lg %* %* %10.4lg %* %* %10.4lg"
          z'=*LocalAxesDef
          *end localaxes

     Note: when `%*' is used in the `*format' command, the argument of
     that position is not printed.
   * *LocalAxesDef(EulerAngles). Last command with option `EulerAngles',
     returns three numbers that are the 3 Euler angles that define a
     local axes system.
   * *LocalAxesDefCenter. This command returns the origin of
     coordinates of the local axes defined by the user. The "Automatic"
     local axes do not have a center, so, the point (0,0,0) is
     returned. The index of the coordinate (from 1 to 3) can optionally
     be given to `LocalAxesDefCenter' to get the x, y or z value.

     Example:
          *LocalAxesDefCenter
          *LocalAxesDefCenter(1) *LocalAxesDefCenter(2) *LocalAxesDefCenter(3)


File: gid.info,  Node: Specific commands,  Prev: Multiple values return commands,  Up: Commands used in the .bas file

Specific commands
.................

   - *\ To avoid line-feeding, the user must write *\, so, the currently
     used line continues on the following line of the file `NAME.bas'.

   - *# Written at the beginning of the line, consider this line as a
     comment and does not write it.

   - *MessageBox. This command stops the execution of the `.bas' file
     and prints a message in a window; this command should be used only
     when a fatal error occurs.
     Example:
     `  *MessageBox error: Quadrilateral elements are not permitted.'
   - *WarningBox. is the same as `MessageBox' but without stoping the
     execution.
     Example:
     `WarningBox Warning: Exist Bad elements. A STL file is a
     collection of triangles bounding a volume.'
   The following commands must be written at the beginning of a line
and the rest of the line will serve for their modifiers. No additional
text should be written.

   * *loop, *end, *break. They are declared for the use of loops. A
     loop begins with a line that starts with `*loop' (no matter the
     letters case, as for the rest of commands) and contains another
     word to express the variable of the loop. There are some lines in
     the middle that will be repeated depending on the values of the
     variable and whose parameters will keep on changing through the
     iterations, if necessary. Finally, a loop will end with a line that
     finishes with `*end'. After `*end' the user may write any kind of
     comments in the same line. Command *break inside a *loop or *for
     block, will finish the execution of the loop and will continue
     after the *end line.

     The variables that are available for `*loop' are the following:

        - elems, nodes, materials, layers, intervals, localaxes. They
          mean, respectively, that the loop will iterate over the
          elements, nodes, materials, layers, intervals or local axes
          systems. The loops can be nested among them. The loop over
          the materials will iterate only over the effectively assigned
          materials to an entity, in spite of the fact that more
          materials had been defined. The number of the materials will
          begin with number 1. If a command that depends on the loop is
          located outside it, the number also will take, by default,
          the value 1.

     After the command `*loop', if the variable is `elems' or `nodes',
     the user may include a modifier `*all', `*OnlyInCond' or
     `*OnlyInLayer' . The first one signifies that the iteration is
     going to be performed over all the entities; the `*OnlyInCond'
     modifier implies that the iteration will only take place over the
     entities that accomplish the concerned condition. This condition
     must have been previously defined with `*set cond'. `*OnlyInLayer'
     implies that the iteration will only take place  over the entities
     that are in the specified layer; layers must be specified with the
     command `*set Layer'. By default, it is assumed that the iteration
     will affect all the entities.
     Example 1:
          *set elems(all)
          *loop nodes
          *format "%5i%14.5e%14.5e"
          *NodesNum *NodesCoord(1,real) *NodesCoord(2,real)
          *end nodes
     This command effects a rundown of all the nodes of the mesh,
     listing their identifiers and coordinates (x and y coordinates).

     Example 2:
          *Set Cond Point-Weight *nodes
          *loop nodes *OnlyInCond
          *NodesNum     *cond(1)
          *end
     This effects a rundown of all the nodes assigned the condition
     "Point-Weight" and provides a list of their identifiers and the
     first "weight" field of the condition in each case.

     Example 3:
          *Loop Elems
          *ElemsNum *ElemsLayerNum
          *End Elems
     This effects a rundown of all the elements and provides a list of
     their identifier and the identifier of the layer to which they
     belong.

     Example 4:
          *Loop Layers
          *LayerNum *LayerName
          *End Layers
     This effects a rundown of all the layers and for each layer it
     lists its identifier and its name.

   * *if, *else, *elseif, *endif. These commands create the
     conditionals.  The format is a line which begins with `*if'
     followed by an expression between parenthesis. This expression
     will be written in C-language syntax, value return commands, will
     not begin with `*' and its variables must be defined as integers
     or reals (see `*format', `*intformat', `*realformat)', with the
     only exception of `strcmp' and `strcasecmp'. It can include
     relational as well as arithmetic operators inside the expressions.

     The following are valid examples of the use of the conditionals:

          *if((fabs(loopvar)/4)<1.e+2)
          *if((p3<p2)||p4)
          *if((strcasecmp(cond(1),"XLoad")==0)&&(cond(2)!=0))

     The first example is a numerical example where the condition is
     accomplished for the values of the loop under 400, while the other
     two are logical operators where the condition is accomplished when
     `p3<p2' or `p4' is different from 0 in the first case and when the
     first field of the condition is called `XLoad' (with this
     particular writing) and the second is not null in the second case.

     If the checked condition is true, GiD will write all the lines
     until finding the corresponding `*else', `*elseif' or `*endif'
     (`*end' is equivalent to `*endif' after `*if'). `*else' or
     `*elseif' are optional and require the writing of all the lines
     until the corresponding `*endif', but only when the condition
     given by `*if' is false. If `*else' or `*elseif' exist, it must be
     written between `*if' and `*endif'. The conditionals can be nested
     among them.

     The behavior of `*elseif' is identical to the behavior of `*else'
     with the addition of a new condition:

          *if(GenData(31,int)==1)
            ...(1)
          *elseif(GenData(31,int)==2)
            ...(2)
          *else
            ...(3)
          *endif

     In the previous example, the body of the first condition (written
     as `1') will be written into the data file if `GenData(31,int)' is
     1, the body of the second condition (written as `2') will be
     written into the data file if `GenData(31,int)' is 2 and if none
     of both is true, the body of the third condition (written as `3')
     will be written into the data file.

     *Note:* A conditional can also be written in the middle of a line.
     To do this, the user will begin another line to write the
     conditional by means of the command *\.

   * *for, *end, *break. The syntax of this command is equivalent to
     `*for' in C-language.
          *for(varname=expr.1;varname<=expr.2;varname=varname+1)
          *end for
     The meaning of this statement is the execution of a controlled
     loop, since `varname' is equal to `expr.1' until it is equal to
     `expr.2', with an incremental value of 1 for each step. `varname'
     is any name and `expr.1' and `expr.2' are arithmetical expressions
     or numbers whose only restrictions are to express the range of the
     loop.  Command *break inside a *loop or *for block, will finish
     the execution of the loop and will continue after the *end line.

          *for(i=1;i<=5;i=i+1)
            variable i=*i
          *end for

   * *set. This command has the following purposes:
        - `*set cond.' To set a condition.

        - `*set Layer "layer name" *elems|nodes.' To set a layer.

        - `*set elems.' To indicate the elements.

        - `*set var.' To indicate the variables to use.

     For all of them it is not binding the use of lower case, so `*Set'
     will also be valid in all the examples.  *set cond.: In the case
     of the conditions, GiD allows the combination of a group of them
     via the use of `*add cond.' When a specific condition is about to
     be used, it must be defined first and afterwards, this will be
     used until the definition of another one. If this feature is
     performed inside a loop over intervals, the corresponding entities
     will be chosen. Otherwise, the entities will be those referred to
     the first interval.
     This is done in this way because when the user indicates to the
     program that a condition is going to be used, GiD creates a table
     that allows to know the number of entities over which this
     condition has been applied. It is necessary to specify if the
     condition takes place over the nodes or over the elements to
     create the table.

     So, a first example to check the nodes where there displacement
     constraints exist can be:

          *Set Cond Volu-Cstrt *nodes
          *Add Cond Surf-Cstrt *nodes
          *Add Cond Line-Cstrt *nodes
          *Add Cond Poin-Cstrt *nodes

     that allows the user to apply the conditions directly over any
     geometric entity.

     *Set Layer "layer name" *elems|nodes
     *Add Layer "layer name"
     *Remove Layer "layer name"
     This command set a group of nodes. In the following loops over
     nodes/elements with the modifier `*OnlyInLayer' the iterations
     will only take place over the nodes/elements of that group.

     Example 1:
          *set Layer example_layer_1 *elems
          *loop elems *OnlyInLayer
              Nº:*ElemsNum Name of Layer:*ElemsLayerName Nº of Layer :*ElemsLayerNum
          *end elems

     Example 2:
          *loop layers
          *set Layer *LayerName *elems
          *loop elems *OnlyInLayer
              Nº:*ElemsNum Name of Layer:*ElemsLayerName Nº of Layer :*ElemsLayerNum
          *end elems
          *end layers

     In this example the command `*LayerName' is used to get the layer
     name.
     There are some modifiers available to point out particular
     specifications on the conditions.

     If command `*CanRepeat' is added after `*nodes' or `*elems' in
     `*Set cond', one entity can be several times in the entities list.
     If command `*NoCanRepeat' is used, entities will be just once in
     the entities list. By default, `*CanRepeat' is off except for the
     case of one condition that have the `*CanRepeat' flag already set.

     A typical case not to use `*CanRepeat' would be:

          *Set Cond Line-Constraints *nodes

     In this case, when two lines share one endpoint, instead of two
     nodes in the list, only one is written.

     A typical case to use `*CanRepeat' would be:

          *Set Cond Line-Preassure *elems *CanRepeat

     in this case, if one triangle of quadrilateral has more than one
     face in the marked boundary, we want this element to appear
     several times in the elements list, one for each face.

     Other modifiers are used to inform the program that there are nodes
     or elements that can satisfy one condition more than once (for
     instance, a node that belongs to a certain number of lines with
     different prescribed movements) and that have to appear unrepeated
     in the data input file, or, in the opposite case, that have to
     appear only if they satisfy more than one condition. These
     requirements are achieved with the commands `*or(i,type)' and
     `*and(i,type)', respectively, after the input of the condition,
     where `i' is the number of the condition to be considered and
     `type' is the type of the variable (integer or real).

     For the previous example there can be nodes or elements in the
     intersection of two lines or maybe belonging to different entities
     where the same condition had been applied. To avoid the repetition
     of these nodes or elements, GiD has the  modifier `*or', and in
     the case that two or more different values were applied over a
     node or element, GiD only would consider one, being this value
     different from zero. The reason for that can be easily understood
     looking at the following example. Considering the previous commands
     transformed as:

          *Set Cond Volu-Cstrt *nodes *or(1,int) *or(2,int)
          *Add Cond Surf-Cstrt *nodes *or(1,int) *or(2,int)
          *Add Cond Line-Cstrt *nodes *or(1,int) *or(2,int)
          *Add Cond Poin-Cstrt *nodes *or(1,int) *or(2,int)

     where `*or(1,int)' means the assignment of that node to the
     considered ones satisfying the condition if the integer value of
     the first condition's field is different from zero (`*or(2,int)'
     means the same assignment if the integer value of the second
     condition's field is different from zero).  Let us imagine that a
     zero in the first field implies a restricted movement in the
     direction of the X-axis and a zero in the second field implies a
     restricted movement in the direction of the Y-axis. If a point
     belongs at the same time to an entity whose movement in the
     direction of the X-axis is constrained, whereas its movement in
     the direction of the Y-axis is released and to an entity whose
     movement in the direction of the Y-axis is constrained, whereas
     its movement in the direction of the X-axis is released, GiD would
     join both conditions in that point, appearing as a fixed point in
     both directions and as a node satisfying the four expressed
     conditions would be counted only once.

     The same considerations explained for adding conditions through
     the use of `*add cond' apply to the elements with the only change
     of putting `*add elems.' Moreover, sometimes it can be of interest
     to remove sets of elements from the assigned ones to the specific
     conditions. This can be done with the command `*remove elems.' So,
     for instance, GiD allows combinations of the type:

          *Set Cond Dummy *elems
          *Set elems(All)
          *Remove elems(Linear)

     to indicate that all dummy elements apart from the linear ones
     will be considered, as well as:

          *Set Cond Dummy *elems
          *Set elems(Hexahedra)
          *Add elems(Tetrahedra)
          *Add elems(Quadrilateral)
          *Add elems(Triangle)

     The format for `*set var' differs from the syntax for the other two
     `*set' commands. Its syntax is as follows:
          *Set var varname = expression

     where `varname' is any name and `expression' is any arithmetical
     expression, number or command, having the latter to be written
     without * and having to be defined as `Int' or `Real'.

     The following are valid examples for these assignments:

          *Set var ko1=cond(1,real)
          *Set var ko2=2
          *Set var S1=CondNumEntities
          *Set var p1=elemsnum()

   * *intformat, *realformat,*format. These commands explain how the
     output of different mathematical expressions will be written into
     the analysis file. The use of this command consist in a line which
     begins with the corresponding version, `*intformat', `*realformat'
     or `*format', (independently of the use of capital letters) and
     continues with the desired writing format, expressed in C-language
     syntax argument, between double quotes (").

     The integer definition of `*intformat' and the real of
     `*realformat' remain unchanged until another definition via
     `*intformat' and `*realformat', respectively, is provided.  The
     argument of these two commands is composed by an unique field.
     This is the reason why the `*intformat' and `*realformat' commands
     are usually invoked at the initial stages of the `.bas' file, to
     set the format configuration of the integer or real numbers to be
     output during the rest of the process.

     The `*format' command can include several fields definitions in
     its argument, mixing integer and real definitions, but it will only
     affect the line that follows the command's instance one. Hence, the
     `*format' command is typically  used when outputing a listing, to
     set a temporary configuration.

     In the next paragraphs, there is an explanation of the C format
     specification, refered to the fields specification to be included
     into the argument of these commands. Keep in mind that the type of
     argument that the `*format' command expects may be composed by
     several fields, and the `*intformat' and `*realformat' commands'
     arguments are composed by an unique field, declared as integer and
     real, respectively, all inside double quotes:

     The start of a field is signaled by the percentage symbol (%). for
     Each field specification is composed by the width of the integer
     field, and, in the case when the type is a float one, a separator
     point type(.) and the precision width of the field. This is
     followed by a letter which specifies the type of the data to be
     represented.

     You are allowed to add text between columns, just writting it
     after the field specification block, before the next `%' sign.
     Note that it is not possible to use the `%' character into this
     text, neither with the c format specification `%%'.

     The most usual representations are integers and floats. For the
     integers there are available the `d' and `i' letters, that force
     to read the data as signed decimal integer and `u' for unsigned
     decimal integer.

     For floating point representation, there are the `e', `f' and `g'
     letters, being used then a decimal point to separate the magnitude
     of the number and the precision.   The number of digits before the
     decimal point depends on the magnitude of the number, and the
     number of digits after the decimal point depends on the requested
     precision.

     The following are valid examples of the use of format:

          *Intformat "%5i"
     With this sentence, usually located on the start of the file, the
     output of an integer quantity is forced to be left alingned on the
     fifth column of the text format on the right side. This means that
     if the number of digits exceeds five, the representation of the
     number will be truncated.  on its left part.

          *Realformat "%10.3e"

     This sentence, that also is located frequently at the first lines
     of the template file, sets the output format for the real numbers
     as ten digits for the integer part, and three for the real part of
     the number. On that case, the truncation will be of the rightest
     digits for the real part of the number and the left part for the
     integer part.

          *format "%10i%10.3e%10i%15.6e"

     This complex command will specify a multiple assignment of formats
     to some output columns. These columns are generated with the line
     command that will follow the format line. The subsequent lines
     will not use this format, and will follow the general settings of
     the template file or the general formats: *IntFormat, *RealFormat.

   * *Tcl

     This command permmits to print information using the TCL extension
     language. The argument of this command must be a valid TCL command
     or expression that must return the string that will be printed.
     Typically, the TCL command is defined in the TCL file (.tcl). (see
     *note TCL-TK extension::. for details).
     Example: in this example the *tcl command is used to call a tcl
     function defined in the problem's type .tcl file.  That function
     receives an argument; we use the variable `num'.
     In the .bas file:
          *set var num=1
          *tcl(WriteSurfaceInfo *num)

     In the .tcl file:
          proc WriteSurfaceInfo { num } {
             return [.central.s info list_entities surfaces $num]
          }


File: gid.info,  Node: Detailed example,  Prev: Commands used in the .bas file,  Up: Template File

Detailed example - Template file creation
-----------------------------------------

   Next is an  example of template file creation, step by step:

   Note that this is a concrete file for a particular solver, so it's a
sure state that some or all of the commands that this solver program
expects, will be non standard or incompatible with the one that another
user owns.

   In this example, this particular solver treats a line like a comment,
inside the calculation input file, if its prefix is a `$' sign. In your
case, it can be another convention.

   Anyway, the actual target of this example is the comprehension of the
commands that GiD exposes to the user. This is the universal method to
access to GiD's internal database, and then output the desired data to
the solver.

   Also, it's assumed that the user will create the file or files with
`.bas' extension, inside the working directory where the problem type
file is located. The name must be `problem_type_name.bas' for the first
file and any other name for the additional .`bas' files. Each .`bas'
file will be read by GiD, and translated to a .`dat' file.

   It is very important to remark that any word in the `.bas' file
having no meaning as a GiD compilation command or not belonging to any
command instructions (parameters), will be verbatim written to the
output file.

  1. First, we create the header that the solver, on this particular
     case, needs.

     This is the name of the solver aplication and a brief description
     of its behavior.

          $-----------------------------------------------------
          CALSEF: PROGRAMA PARA CALCULO DE SOLIDOS Y ESTRUCTURAS

     Then, another particular sentence that may be incompatible in your
     case, although a similar one may exist for your solver. It's a
     commented line with the `ECHO ON' command. This line, when
     uncommented, is useful if you want to monitor the progress of the
     calculation.
          $-----------------------------------------------------
          $ECHO ON

     The next line specifies the type of calculation and the materials
     involved on the calculation, and it's not a GiD related command
     either.
          $-----------------------------------------------------
          ESTATICO-LINEAL, EN SOLIDOS
     As you can see, it's used a commented line with dashes to separate
     the different parts of the file improving the readability of the
     text.

  2. Here comes the initialitation of some variables. This is needed by
     the solver to start the calculating process.

     The following assignments take the first (parameter `(1)') and
     second (parameter `(2)') fields in the general problem, as the
     number of problems and the title of the problem.

     The actual position of a field is determined checking its order on
     the problem file, so you will guess this is a method that depends
     on a strict position.

     Assignment of the first (1) Field of the `Problem data' file, with
     the command `*GenData(1)':

          $-----------------------------------------------------
          $NUMBER OF PROBLEMS:
          NPROB = *GenData(1)
          $-----------------------------------------------------

     Assignment of the second (2) field assignment, `*GenData(2)':

          $ TITLE OF THE PROBLEM:
          TITULO= *GenData(2)
          $-----------------------------------------------------

     The next instruction takes the field where the starting time is
     saved.  On this case, it is on the 10th position of the general
     problem data file, but we will use another feature of the
     `*GenData' command, the parameter of the command will be the name
     of the field.

     This is a preferable method, because if the list is shifted due to
     the adding or substracting of a field, you will not loose the
     actual position. This command accepts an abbreviation, if there is
     no conflict with other field name.

          $-----------------------------------------------------
          $ TIME OF START:
          TIME= *GenData(Starting_time)
          $-----------------------------------------------------

     Here comes the init of some general variables refering to the
     project we are considering, as the number of points, the number of
     elements or the number of materials.

     The first line is a description of the section.

          $ DIMENSIONS OF THE PROBLEM:

     Then it is a line that introduces the next assignments
          DIMENSIONES :

     Which is followed by another one with the three assignments of
     variables.  `NPNOD' gets, from the `*npoin' function, the number
     of nodes of the model; `NELEM' gets, from `*nelem', or the total
     number of elements of the model or the number of elements of every
     kind of element and `nmats' is initialized with the number of
     materials:

           NPNOD= *npoin,   NELEM= *nelem,   NMATS= *nmats,   \

     Then comes a line where `NNODE' gets the maximum number of nodes
     per element and `NDIME' gets the variable `*ndime'. This variable
     must be a number that specifies if all the nodes are on the plane
     whose Z values are equal to 0 (`NDIME=2') or if they are not
     (`NDIME=3'):

          NNODE= *nnode,   NDIME= *ndime,                    \

     The next lines take data from the general data fields in the
     problem file.  `NCARG' gets the number of charge cases; `NGDLN'
     the number of degrees of freedom; `NPROP' the properties number;
     `NGAUSS' the gauss number; `NTIPO', is assigned dynamically:

          NCARG= *GenData(Charge_Cases), *\

     You could use `NGDLN= *GenData(Degrees_Freedom), *\', but because
     the length of the argument will make exceed a line, we have
     abbreviated its parameter (there is no conflict with other
     question name in this problem file), to simplify the command.

          NGDLN= *GenData(Degrees_Fre), *\
          NPROP= *GenData(Properties_Nbr), \
          NGAUS= *GenData(Gauss_Nbr) , NTIPO= *\

     Note that the last assignment is ended with the specific command
     `*\', to avoid the line feeding. This permits to include a
     conditional assignment of this variable, depending on the data in
     the General data problem.

     Inside the conditional it is used a C format like `strcmp'
     instruction. This instruction compares the two strings passed as
     parameter, and returns an integer number which express the
     relationship between the two strings. If the result of the
     operation is equal to `0', the two strings are identical; if it is
     a positive integer, the first argument is greater than the second,
     and otherwise, the second argument string is less.

     The script checks what problem type is declared in the general
     data file, and then it assigns the coded number for the this type
     to the `NTIPO' variable:

          *if(strcmp(GenData(Problem_Type),"Tens-Plana")==0)
          1 *\
          *elseif(strcmp(GenData(Problem_Type),"Def-Plana")==0)
          2 *\
          *elseif(strcmp(GenData(Problem_Type),"Sol-Revol")==0)
          3 *\
          *elseif(strcmp(GenData(Problem_Type),"Sol-Tridim")==0)
          4 *\
          *elseif(strcmp(GenData(Problem_Type),"Placas")==0)
          5 *\
          *elseif(strcmp(GenData(Problem_Type),"Laminas-Rev")==0)
          6 *\
          *endif

     You have to cover all the cases within the `if' sentences, or end
     the commands with an `else', if you don't want unpredictable
     results, like the next line raised to the place where the
     parameter will have to be:

          $ Default Value:
          *else
          0*\
          *endif

     Although in our case this last rule has not been followed, it
     could be a very good option, when the problem file has been
     modified or created by another user, and the new specification may
     differ from the one we expect.

     The next assignment is formed by a string compare conditional, to
     inform the solver about a setting of the configuration.

     First is the output of the variable to be assigned.

          , IWRIT= *\

     Then there is a conditional where it's compared the string
     contained on the value of the `Result_File' field with the string
     "Yes". If the result is `0', then the two strings are the same,
     and we output an `1', to declare a boolean TRUE.

          *if(strcmp(GenData(Result_File),"Yes")==0)
          1 ,\

     Then we compare the same value string with the string "No", to
     check the complementary option. If we find that the strings match,
     then we output a `0'.

          *elseif(strcmp(GenData(Result_File),"No")==0)
          0 ,\
          *endif

     The second last assignment is a simple output of the solver field
     contents into the INDSO variable:

                       INDSO= *GenData(Solver) , *\

     The last assign is a little more complicated. It requires the
     creation of some internal values, with the aid of the command
     *`set cond'.

     The first action to execute is to set the conditions, so we can
     access its parameters.  This setting may serve for several loops
     or instructions, as long as the parameters needed for the other
     blocks of instructions are the same.

     This line sets the condition `Point-Constraints' as an active
     condition.  The `*nodes' modifier means that the condition will be
     listed over nodes.  The `*or(...' modifiers are necessary when an
     entity shares some conditions, because it belongs to two or more
     elements.

     As an example, take a node which is part of two lines, and each of
     these lines have assigned a different condition. This node, a
     common point of the two lines, will have this two conditions into
     its list of properties. So declaring the `*or' modifiers, GiD will
     decide which condition to use, between the list of conditions of
     the entity.

     A first instruction will be this, where the parameters of the `*or'
     commands are an integer number (`(1,' and `(3,', respectively on
     this example)  and the specification `int', that forces GiD to
     read the condition whose number position is the integer number.

     In our case, we find that the first (1) field of the condition
     file is `X-constraint', and the third (3), is `Y-constraint':

     Gid still has no support for the substitution of the position of
     the condition in the file by its corresponding label, as succeeds
     in the case of the fields of the problem data file.

          *Set Cond Surface-Constraints *nodes *or(1,int) *or(3,int)

     Now we want to complete the setting of the loop, with the addition
     of new conditions.

          *Add Cond Line-Constraints *nodes *or(1,int) *or(3,int)
          *Add Cond Point-Constraints *nodes *or(1,int) *or(3,int)

     Observe the order in which the conditions have been included:
     first the surface constraints with the `*Set Cond' command, since
     it is the initial sentence. Then the pair of `*Add Cond'
     sentences, the line constraints and as the last one, the point
     constraints sentence.  This logical hierarchy forces the points as
     the most important items, due to the fact that the program takes

     Finally, we set a variable with the number of entities assigned to
     this particular condition.

     Note that the execution of this instruction is only possible if a
     condition has been set previously.

          NPRES= *CondNumEntities

     To end this section, we put a separator on the output file:

          $-----------------------------------------------------

     Thus, after the init of those variables, this part of the file
     ends up as:

          $ DIMENSIONS OF THE PROBLEM:
          DIMENSIONES :
           NPNOD= *npoin,  NELEM= *nelem,  NMATS= *nmats,     \
           NNODE= *nnode,  NDIME= *ndime,                     \
           NCARG= *GenData(Charge_Cases), *\
           NGDLN= *GenData(Degrees_Fre), *\
           NPROP= *GenData(Properties_Nbr), \
           NGAUS= *GenData(Gauss_Nbr) , NTIPO= *\
          *if(strcmp(GenData(Problem_Type),"Tens-Plana")==0)
          1 *\
          *elseif(strcmp(GenData(Problem_Type),"Def-Plana")==0)
          2 *\
          *elseif(strcmp(GenData(Problem_Type),"Sol-Revol")==0)
          3 *\
          *elseif(strcmp(GenData(Problem_Type),"Sol-Tridim")==0)
          4 *\
          *elseif(strcmp(GenData(Problem_Type),"Placas")==0)
          5 *\
          *elseif(strcmp(GenData(Problem_Type),"Laminas-Rev")==0)
          6 *\
          *endif
          , IWRIT= *\
          *if(strcmp(GenData(Result_File),"Yes")==0)
          1 ,\
          *elseif(strcmp(GenData(Result_File),"No")==0)
          0 ,\
          *endif
             INDSO= *GenData(Solver) , *\
          *Set Cond Surface-Constraints *nodes *or(1,int) *or(3,int)
          *Add Cond Line-Constraints *nodes *or(1,int) *or(3,int)
          *Add Cond Point-Constraints *nodes *or(1,int) *or(3,int)
          NPRES=*CondNumEntities
          $-----------------------------------------------------

     After creation or reading of our model, once generated the mesh
     and applied the conditions, we can export the file (file
     `project_name.dat') and send it to the solver.

     The command to create the `.dat' file can be found on the ` File'
     / `Import/Export' / `Write Calculation File'  GiD menu. It's also
     possible to use the keyboard shortcut `Control-x Control-c'

     This would be the contents of the `project_name.dat' file:

          $-----------------------------------------------------
          CALSEF: PROGRAMA PARA CALCULO DE SOLIDOS Y ESTRUCTURAS
          $-----------------------------------------------------
          $ECHO ON
          $-----------------------------------------------------
          ESTATICO-LINEAL, EN SOLIDOS
          $-----------------------------------------------------
          $NUMERO DE PROBLEMAS:
          NPROB = 1
          $-----------------------------------------------------
          $ TITULO DEL PROBLEMA
          TITULO= Title_name
          $-----------------------------------------------------
          $DIMENSIONES DEL PROBLEMA
          DIMENSIONES :
            NPNOD=    116 ,  NELEM= 176 ,   NMATS=  0 ,     \
            NNODE=      3 ,  NDIME=   2 ,                   \
            NCARG=      1 ,  NGDLN=   1 ,   NPROP=  5 ,     \
            NGAUS=      1 ,  NTIPO=   1 ,   IWRIT=  1 ,     \
            INDSO=     10 ,  NPRES=   0
          $-----------------------------------------------------

  3. Here begins the calculation input, the actual starting of data
     transfer

A) Elements, materials and connectivities listing
.................................................

     Now we want to output the desired results to the output file.
This first line, apparently a title or label, is the way that offers
the solver, in this example, to determine the beginning and end of a
loop section. This block of instructions ends with the next
`FIN_GEOMETRIA' sentence, also for this example.

          GEOMETRIA

     Here, we introduce an user informative couple of lines.

     A title of the first subsection, `CONECTIVIDADES ELEMENTALES':

          $ CONECTIVIDADES ELEMENTALES

     And here is the header that precedes the output list, a user
oriented data:

          $ ELEM. MATER.    SECUENCIA DE CONECTIVIDADES

     And then we travel trough the elements of the model, by the action
of the `*loop' instruction, followed in this case by the `elems'
argument.

          *loop elems

     For each element in the model, GiD will output: its element
number, by the action of the `*elemsnum' command, the material assigned
to this element, using the `*elemsmat' command, and the connectivities
associated to the element, with the command `*elemsConec':

            *elemsnum *elemsmat *elemsConec
          *end elems

     You can use the parameter `swap' if you are working with quadratic
elements and the listing modes of the nodes is not standard.  A non
standard nodes listing would be, for example, an anti-clockwise listing
of all the elements.

            *elemsnum *elemsmat *elemsConec(swap)
          *end elems

     Here finishes the first part of this section.

B) Formatted nodes and coordinates                                              listing
.......................................................................................

     And here starts the next section `COORDENADAS DE PUNTOS NODALES':

          $ COORDENADAS DE PUNTOS NODALES

     Next is the header of the output list:

          $  NODO  COOR.-X   COOR.-Y   COOR.-Z

     Now GiD will trace all the nodes of the model:
          *loop nodes

     For each node in the model, it will generate the output of the
number of node, `*NodesNum' and the coordinates for this node
`*NodesCoord'.

     The command executed before the output, `*format', will force that
the resulting output follow the guidelines of formatting specified.

     On this case, the `*format' command gets a string parameter with a
set of codes: %6i, which specify that the first word in the list is
coded as a integer and is printed six points from the left, the rest of
the three codes, `%15.5f', are ordering the printing of a real number,
represented on a floating point format, with a distance of 15 spaces
between columns (the number will be shifted to have the last digit in
the 15th position of the column) and the fractional part of the number
will be represented with five digits.

     Note that this is the C language format command.

          *format "%6i%15.5f%15.5f%15.5f"
            *NodesNum *NodesCoord
          *end

     And at the end of the section, it's the finishing mark sentence,
in this solver example.

          FIN_GEOMETRIA

     The full set of commands to make this part of the output is showed
the next lines.

          GEOMETRIA
          $ CONECTIVIDADES ELEMENTALES
          $ ELEM. MATER.    SECUENCIA DE CONECTIVIDADES
          *loop elems
            *elemsnum *elemsmat *elemsConec
          *end elems
          $ COORDENADAS DE PUNTOS NODALES
          $  NODO  COOR.-X   COOR.-Y   COOR.-Z
          *loop nodes
          *format "%6i%15.5f%15.5f%15.5f"
            *NodesNum *NodesCoord
          *end
          FIN_GEOMETRIA

     The result of the compilation, output to a file
(`project_name.dat') to be processed by the solver program.

     The first part of the section:

          $-----------------------------------------------------
          GEOMETRIA
          $ CONECTIVIDADES ELEMENTALES
          $ ELEM. MATER.    SECUENCIA DE CONECTIVIDADES
               1      1     73    89    83
               2      1     39    57    52
               3      1     17    27    26
               4      5      1     3     5
               5      5      3    10     8
               6      2     57    73    67
               .      .      .     .     .
               .      .      .     .     .
               .      .      .     .     .
             176      5     41    38    24

     And the second part of the section:

          $ COORDENADAS DE PUNTOS NODALES
          $     NODO       COOR.-X        COOR.-Y   COOR.-Z
                 1         5.55102        5.51020
                 2         5.55102        5.51020
                 3         4.60204        5.82993
                 4         4.60204        5.82993
                 5         4.88435        4.73016
                 6         4.88435        4.73016
                 .         .              .
                 .         .              .
                 .         .              .
               116        -5.11565        3.79592
          FIN_GEOMETRIA

  4. If the solver module you are using needs a list of the nodes that
     have assigned a condition, like for example, a neighborhood
     condition, you have to provide it as is explained in the next
     example:

C) Nodes listing declaration
............................

     First, we set the necessary conditions, as it was done in the
previous section.

          *Set Cond Surface-Constraints *nodes *or(1,int) *or(3,int)
          *Add Cond Line-Constraints *nodes *or(1,int) *or(3,int)
          *Add Cond Point-Constraints *nodes *or(1,int) *or(3,int)
          NPRES=*CondNumEntities

     After the data init and declarations, the solver requires a list
of nodes, with boundary conditions and the fields that have been
assigned

     In this example, all the selected nodes will be output, also
printing the 3 conditions. The columns will be output with no aparent
format:

     First, there is a line with the header of the section for the
solver program and a commentary line for the user

          CONTORNO CONDICIONES
          $ NODOS RESTRINGIDOS Y PRESCRIPCIONES

     Then comes the first line of the output list, the header:

          $ NODO CODIGO         VALORES PRESCRITOS

     Then the `loop' instruction, over nodes, and with the specification
argument `*OnlyInCond', to iterate only over the entities that have the
condition assigned. This is the condition that has been set on the
previous lines.

          *loop nodes *OnlyInCond

     The next line is the `format' command, followed by the lines with
the commands to fill the fields of the list.

          *format "%5i%1i%1i%f%f"
             *NodesNum *cond(1,int) *cond(3,int)  *\

     Also into the `*format' command influence there are the next couple
of `if' sentences. If the degrees of freedom field contains an integer
equal or greater than `3', the number of properties will be output.

          *if(GenData(Degrees_Freedom_Nodes,int)>=3)
          *cond(5,int) *\
          *endif

     And if the value of the same field is equal to `5' the output will
be a pair of zeros.

          *if(GenData(Degrees_Free,int)==5)
          0 0  *\
          *endif

     The next line ouputs the values contained in the second and fourth
fields, both real numbers.

          *cond(2,real) *cond(4,real) *\

     In a similar manner as done in the previous `if' sentences here
come a group of lines to output the sixth condition field value, if the
number of degrees of freedom is equal or greater than threee, and
output a pair of zeros if it's equal to five.

          *if(GenData(Degrees_Free,int)>=3)
          *cond(6,real) *\
          *endif
          *if(GenData(Degrees_Free,int)==5)
          0.0 0.0  *\
          *endif

     Finally, to end the section, the `*end' command closes the previous
`*loop'. The last line is the label of the end of the section.

          *end
          FIN_CONTORNO CONDICIONES
          $-------------------------------------------------------

     The full set of commands included in this section are the next:

          CONTORNO CONDICIONES
          $ NODOS RESTRINGIDOS Y PRESCRIPCIONES
          $ NODO CODIGO         VALORES PRESCRITOS
          *loop nodes *OnlyInCond
          *format "%5i%1i%1i%f%f"
             *NodesNum *cond(1,int) *cond(3,int)  *\
          *if(GenData(Degrees_Free,int)>=3)
          *cond(5,int) *\
          *endif
          *if(GenData(Degrees_Free,int)==5)
          0 0  *\
          *endif
          *cond(2,real) *cond(4,real) *\
          *if(GenData(Degrees_Free,int)>=3)
          *cond(6,real) *\
          *endif
          *if(GenData(Degrees_Free,int)==5)
          0.0 0.0  *\
          *endif
          *end
          FIN_CONTORNO CONDICIONES
          $-----------------------------------------------------

  5. If it is needed the output of a list of the materials

D) Materials listing declaration
................................

     As a must, the first lines are the title of the section and a
commentary.

          PROPIEDADES MATERIALES
          $ PROPIEDADES DE LOS MATERIALES PARA MULTILAMINADO

     Then there is the loop sentence, this time related to materials.

          *loop materials

     Then comes the line were the number of the material and its
different properties are output.

             *matnum() *MatProp(1) *MatProp(2) *MatProp(3) *MatProp(4)

     Finally comes the ending of the section.
          *end
          FIN_PROPIEDADES MATERIALES
          $-----------------------------------------------------

     The full set of commands is the next:

          PROPIEDADES MATERIALES
          $ PROPIEDADES DE LOS MATERIALES PARA MULTILAMINADO
          *loop materials
             *matnum() *MatProp(1) *MatProp(2) *MatProp(3) *MatProp(4)
          *end
          FIN_PROPIEDADES MATERIALES
          $-----------------------------------------------------

  6. If it is needed the output of a list of the elements

E) Elements listing declaration
...............................

     First, we set the loop to the interval of the data.
          *loop intervals

     The next couple of lines indicate the starting of one section and
the title of the example, taken from the first field in the interval
data with an abbreviation on the label.  They are followed by a comment
explaining the type of data we are using.

          FUERZAS
              TITULO: *IntvData(Charge_case)
          $ TIPO DE CARGA

     First, we set the condition as done before. If one condition is
assigned twice or more to the same element, without the include of the
`*CanRepeat' parameter in the `*Set Cond' the condition will appear
once, if exists the  `*CanRepeat' parameter, then the number of
conditions that will appear is the number of times is the number of
times it was assigned to the condition.

          *Set Cond Face-Load *elems *CanRepeat

     Then, a condition checks if exist any element into the condition.

          *if(CondNumEntities(int)>0)

     Next is a title of the next section, followed by a comment for the
user.

          DISTRIBUIDA UNIFORMEMENTE EN LADOS
          $ CARGAS UNIFORMEMENTE REPARTIDAS EN LADOS DE ELEMENTOS

     We assign the number of nodes to a variable.

          $ NUMERO DE NODOS EN LADO
          NODGE =  2

     Then comes the title of the next loop, followed by the start of
the loop, now applied over the elements and its operation restricted to
the group of elements selected into the condition.

          $ LADOS CARGADOS Y CARGAS ACTUANTES
          *loop elems *OnlyInCond

     The number of elements is written after `ELEMENTO='.  >From an
user point of view, this is treated like a variable assignment.  The
number of nodes that belong to the face of the loop's element is
written after the `CONECTIV' label. This means the number of adjacent
nodes to the face.

                ELEMENTO=*elemsnum(), CONECTIV *globalnodes

     The conditions that are output are the first and second.

                *cond(1) *cond(1)  *cond(2) *cond(2)

     Here ends the loop  and after it there's a label line to end the
section. The last `*endif' ends the `if' statement group.

          *end
          FIN_DISTRIBUIDA UNIFORME EN LADOS
          *endif

     The preceding section is compiled complete into the following
lines:

          $-----------------------------------------------------
          *loop intervals
          FUERZAS
              TITULO: *IntvData(1)
          $ TIPO DE CARGA
          *Set Cond Face-Load *elems *CanRepeat
          *if(CondNumEntities(int)>0)
          DISTRIBUIDA UNIFORMEMENTE EN LADOS
          $ CARGAS UNIFORMEMENTE REPARTIDAS EN LADOS DE ELEMENTOS
          $ NUMERO DE NODOS EN LADO
          NODGE =  2
          $ LADOS CARGADOS Y CARGAS ACTUANTES
          *loop elems *OnlyInCond
                ELEMENTO=*elemsnum(), CONECTIV *globalnodes
                *cond(1) *cond(1)  *cond(2) *cond(2)
          *end
          FIN_DISTRIBUIDA UNIFORME EN LADOS
          *endif

  7. Finally, output of a list of the nodes and conditions

F) Nodes and its conditions listing declaration
...............................................

     As ever, the first thing to do in the setting of the conditions.

          *Set Cond Point-Load *nodes

     As in the previous section, the next loop will be executed only if
exists any condition in the selection.

          *if(CondNumEntities(int)>0)

     Here starts the loop over the nodes.

          PUNTUAL EN NODOS
          *loop nodes *OnlyInCond
                *NodesNum *cond(1) *cond(2) *\

     The next `*if' sentences, condition the output writting of the end
of the line.

          *if(GenData(Degrees_Free,int)>=3)
          *cond(3) *\
          *endif
          *if(GenData(Degrees_Free,int)==5)
          0 0  *\
          *endif
          *end

     To end the section, here comes the label and the `if' closing.

          FIN_PUNTUAL EN NODOS
          *endif

     Finally, it is written an information label, if the value of the
second field in the interval data section, inside the problem file, is
equal to `"si"' (yes).

          *if(strcasecmp(IntvData(2),"Si")==0)
          PESO_PROPIO
          *endif

     After the end of this loop, it comes the label that identifies the
end of the forces section, but the actual end of the section will be
the next `*end' command, located some lines after.

          FIN_FUERZAS

     Before the end of the section, nevertheless, we indicate the
solver which will be the postproces file. This information is gathered
from the `*IntvData' command. The argument that this command receives
(`3') specifies that the name of the file is in the third field of the
loop iteration of the interval.

          $-----------------------------------------------------
          $ARCHIVO DE POSTPROCESO
          FEMV = *IntvData(3)

     To end the forces interval loop, finally comes the `*end' command:

          $-----------------------------------------------------
          *end

     Finally, the file is ended with the sentence required by the
solver:

          FIN_CALSEF
          $-----------------------------------------------------

     The preceding section is compiled complete into the following
lines:

          *Set Cond Point-Load *nodes
          *if(CondNumEntities(int)>0)
          PUNTUAL EN NODOS
          *loop nodes *OnlyInCond
                *NodesNum *cond(1) *cond(2) *\
          *if(GenData(Degrees_Free,int)>=3)
          *cond(3) *\
          *endif
          *if(GenData(Degrees_Free,int)==5)
          0 0  *\
          *endif
          *end
          FIN_PUNTUAL EN NODOS
          *endif
          *if(strcasecmp(IntvData(2),"Si")==0)
          PESO_PROPIO
          *endif
          FIN_FUERZAS
          $-----------------------------------------------------
          $ARCHIVO DE POSTPROCESO
          FEMV = *IntvData(3)
          $-----------------------------------------------------
          *end
          FIN_CALSEF
          $-----------------------------------------------------


   With this section ends the template file example.


File: gid.info,  Node: Executing an external program,  Prev: Template File,  Up: Customization

Executing an external program
=============================

   Once all the files of the problem type are finished (`.cnd, .mat,
.prb, .sim, .bas' files), you are able to run the solver. It may be
interesting to run it directly from inside GiD.

   To do so, it is necessary to create the file `problem_type_name.bat'
in the problem type directory.  This must be a shell script that can
contain any type of information and that will be different for every
operating system. When the user selects the option `CALCULATE' in the
GiD preprocess this shell script is executed. (*note Calculate::.)

   Because the `.bat' file will be different depending on the operating
system, it's possible to create two files: one for Windows and another
for Unix/Linux.
The Windows file has to be named as: `problem_type_name.win.bat'.
The Unix/Linux file has to be named as:  `problem_type_name.unix.bat'.
If GiD founds a `.win.bat' or `.unix.bat' file, the file
`problem_type_name.bat' will be ignored.

   If a `.bat' file exists in the problem type directory, when choosing
`Start' in the calculations window, GiD will automatically write the
analysis file inside the example directory assigning the name
`project_name.dat' to this file (if more files, names
`project_name-1.dat' ...  are used). Next, this shell script will be
executed. GiD will assign to this script 3 arguments:

   * 1st argument: `project_name' (name of the current project)

   * 2nd argument: `c:\a\b\c\project_name.gid' (path of the current
     project)

   * 3rd argument: `c:\a\b\c\problem_type_name.gid' (path of the
     problem type selected)

   Among other utilities, this script can move or rename files and
execute the process until it finishes.

   *Note1:* This file must have the executable flag set (see UNIX
command `chmod') in UNIX systems.

   *Note2:* GiD sets as current directory the model directory
(example: `c:\\examples\test1.gid') just before executing the `.bat'
    file. So, the lines (`cd $directory') are not necessary in the
scripts.

* Menu:

* Commands accepted by the GiD command.exe::
* showing feedback when runing the solver::
* Managing errors ::
* Shell script examples::


File: gid.info,  Node: Commands accepted by the GiD command.exe,  Next: showing feedback when runing the solver,  Prev: Executing an external program,  Up: Executing an external program

Commands accepted by the GiD command.exe
----------------------------------------

   The keywords are the following ones:
   - %

   - Shift

   - Rem

   - Chdir (Cd)

   - Del (Delete, Erase)

   - Copy

   - Rename (Ren, Move)

   - Mkdir (Md)

   - Set

   - Echo (@echo)

   - If

   - Call

   - Goto

   - :

   - Type

   Unknown instructions will be executed as if it was an external file.

   In the GiD command.exe are not implemented all the possible
parameters and modifiers available in the operating system.

   Note:
At the moment, command.exe is only used in Windows operating systems,
as an alternative to the command.com or cmd.exe. With the GiD
command.exe some of the disadvantages of Windows can be avoided (the
limited length of the parameters, temporary use of letters of virtual
units that sometimes are not possible to eliminate, fleeting appearance
of the console window, etc).

   If GiD finds the file command.exe, located next to gid.exe, it will
be used to interpret the `*.bat' file of the problem type; if the file
command.exe cannot be found, the `*.bat' file will be interpreted by
the windows command.com.

   If conflicts appear by the use of some instruction still
nonimplemented in the GiD command.exe, it's possible to rename the
command.exe file, so that GiD doesn't find it, and the operating system
command.com is used.

%
Returns the value of a variable.

   %number
%name%

   Parameters
number
The number is the position (from 0 to 9) of one of the parameters which
the *.bat file receives.

   name
Is the name of an environment variable. That variable has to be
declared with instruction "set".

   Note:
GiD sends to the `*.bat' file three parameters: `%1, %2, %3'
`%1' is the name of the current project `(project_name)'
`%2' is the path of the current project `(c:\a\b\c\project_name.gid)'
`%3' is path of the problem type `(c:\a\b\c\problem_type_name.gid )'

   For example, if GiD is installed in c:\gidwin, the "problemtype"
name is cmas2d.gid and the project is test.gid, located in c:\temp (the
project is a directory called c:\temp\test.gid with some files inside),
parameters will have the following values:

   `%1' test
`%2' c:\temp\test.gid
`%3' c:\gidwin\problemtypes\cmas2d.gid
Note: it's possible that the file and directory names of these
parameters are in the short mode Windows format. So, parameter %3 would
be: c:\GIDWIN\PROBLE~\CMAS2D.GID.

   Examples
     echo %1 > %2\%1.txt
     echo %TEMP% >> %1.txt

Shift
The shift command changes the values of parameters %0 to %9 copying
each parameter in the previous one.  That is to say, value %1 copy to
%0, value %2 copy to %1, etc.

   shift

   Parameter
None.

   Note:
The shift command can be used to create a batch program that accepts
more than 10 parameters.  If it specifies more than 10 parameters in
the command line, those that appear after tenth (%9) will move to
parameter %9 one by one.

Rem
Rem is used to include comments in a `*.bat' file or in a configuration
file.

   rem [coment]

   Parameter
coment
Any character string.

   Note:
Some comments are GiD commands.

Chdir (Cd)
Changes to a different directory.

   chdir [drive:path] [..]
-or-
cd  [drive:path] [..]

   Parameters
[drive:path]
Disk and path of the new directory.

   [..]
Goes back one directory. For example if you are within the
`C:\WINDOWS\COMMAND>' directory this would take you to `C:\WINDOWS>'.

   Note:
When GiD calls the `*.bat' file, the path of project is the current
path, so it's not necessary to use `cd %2' at the begining of the
`*.bat' file.

   Examples
     chdir e:\tmp
     cd ..

Delete (Del, Erase)
Command used to delete files permanently from the computer.

   delete [drive:][path] fileName [fileName]

   Parameters
[drive:][path] fileName [fileName]
Parameters specify the location and the name of the file that has to be
erased from disk. Several file names can be given.

   Note:
Files will be eliminated although they have the hidden or read only
flag.  Use of wildcards is not allowed. For example del *.* is not
valid.  File names must be separated by spaces and if the path contains
blank spaces, the path should be inside inverted commas (the short path
without spaces can also be used).

   Examples
     delete %2\%1\file.cal
     del C:\tmp\fa.dat C:\tmp\fb.dat
     del "C:\Program files\test 4.txt"

Copy
Copies one or more files to another location.

   copy  source  [+  source [+ ...]] destination

   Parameters
source
Specifies the file or files to be copied

   destination
Specifies the filename for the new file(s).

   To append files, specify a single file for destination, but multiple
files for source (using `file1 + file2 + file3' format).

   Note:
If the destination file already exists, it will be overwrited without
prompting if you wanted to overwrite the file or not.

   File names must be separated by spaces.  If destination only
contains the path but not the filename, the new name will be the same
as the source filename.

   Examples
     copy f1.txt f2.txt
     copy f1.txt c:\tmp
     rem if directory c:\tmp exists, c:\tmp\f1.txt will be created, if it doesn't exist, file c:\tmp will be created.
     copy a.txt + b.txt + c.txt abc.txt

Rename (Ren, Move)
Used to rename files and directories from the original name to a new
name.

   rename [drive:][path] fileName1 fileName2

   Parameter
[drive:][path] fileName1 Specifies the path and the name of the file
which has to be renamed.

   fileName2
Specifies the new name file.

   Note:
If the destination file already exists, it will be overwrited without
prompting if you wanted to overwrite the file or not.  Wildcards are
not accepted (`*',`?'), so only one file can be renamed every time.
Note that you cannot specify a new drive for your destination.  A
directory can be renamed in the same way as if it was a file.

   Examples
     Rename fa.txt fa.dat
     Rename "c:\Program Files\fa.txt" c:\tmp\fa.txt
     Rename c:\test.gid c:\test2.gid

Mkdir (md)
Allows you to create your own directories.

   mkdir [drive:]path
md [drive:]path
Parameter
drive:
Specifies the drive where the new directory has to be created.

   path
Specifies the name and location of the new directory. The maximum
length of the path is limited by the file system.

   Note:
mkdir can be used to create a new path with many new directories.

   Examples
     mkdir e:\tmp2
     mkdir d1\d2\d3

Set
Displays, sets, or removes Windows environment variables.

   set variable=[string]

   Parameters
variable
Specifies the environment-variable name.

   string
Specifies a series of characters to assign to the variable.

   Note:
The set command creates variables which can be used in the same way as
the variables `%0' to `%9'. Variables `%0' to `%9' can be assigned to
new variables using the set command.

   To get the value of a variable, the variable has to be written
inside two `%' symbols. For example, if the environment-variable name
is `V1', its value is `%V1%'.  Variable names are not case sensitive.

   Examples
     set basename = %1
     set v1 = my text

Echo (@echo)
Displays messages.

   echo [message]

   message
Specifies the text that will be displayed in the screen.

   Note:
The message will not be visible because the console is not visible, GiD
hides the console. So that this command it's only useful if the output
is redirected to a file (using > or >>). Symbol > sends the text to a
new file, and symbol >> sends the text to a file if it already exists.
Commands if and echo can be used in the same command line.

   Examples
     Echo %1 > out.txt
     Echo %path% >> out.txt
     If Not Exist %2\%1.flavia.res Echo "Program failed" >> %2\%1.err

If
Executes a conditional sentence. If the specified condition is true,
the command which follows the condition will be executed; if the
condition is false, next line is ignored.
     if [not] exist fileName command
     if [not] string1==string2 command
     if [not] errorlevel number command
   Parameters
not
Specifies that the command has to be executed only if the condition is
false.

   exist file
Returns true if `file' exists.

   comand
Is the command that has to be executed if the condition returns true.

   string1==string2
Returns true if string1 and string2 are equal. It's possible to compare
two strings, or variables (for example, `%1').

   errorlevel number
Returns true if the last program executed returned a code equal or
bigger to number.

   Note:
Exist can also be used to check if a directory exists.

   Examples
     if exist sphere.igs echo File exists >> out.txt
     if not exist test.gid echo Dir doesn't exist >> out.txt
     if %1 == test echo Equal %1 >> out.txt

Call
Executes a new program.

   call [drive:][path] file [parameters]

   Parameter
[drive:][path] file Specifies the location ant the name of the program
that has to be executed.

   parameters
Parameters required by the program executed.

   Note:
The program can be `*.bat' file, a `*.exe' file or a `*.com' file.  If
the program does a recursive call, some condition has to be imposed to
avoid an endless curl.

   Examples
     call test.bat %1
     call gid.exe -n -PostResultsToBinary %1.flavia.res %1.flavia.bin

Goto
The execution jumps to a line identified by a label.

   goto label

   Parameter
label
It specifies a line of the `*.bat' file where the execution will
continue. That label must exist when the Goto command is executed.  A
label is a line of the `*.bat' file and starts with (:).
Goto is often used with the command if, in order to execute conditional
operations.  The Goto command can be used with the label `:EOF' to make
the execution jump to the end of the `*.bat' file and finish.

   Note:
The label can have more than eight characters and cannot have spaces
between them. The label name is not case sensitive.

   Example
     goto :EOF
     
     if exist %1.err goto end
     ...
     :end

:
Declares a label.

   : labelName

   Parameter
labelName
Is a string which identifies a line of the file, so that the Goto
command can jump there.  The label line will not be executed.

   Note:
The label can have more than eight characters and cannot have spaces
between them. The label name is not case sensitive.

   Examples
     :my_label
     :end

Type
Displays the contents of text files.

   type [drive:][path] fileName

   Parameters
[drive:][path] fileName
Specifies the location ant the name of the file to be displayed. If the
file name contains blanc spaces it should be inside inverted commas
(`"').

   Note:
The text will not be visible because the console is not visible, GiD
hides the console. So that this command it's only useful if the output
is redirected to a file (using > or >>). Symbol > sends the text to a
new file, and symbol >> sends the text to a file if it already exists.
It's recommended to use the copy command instead of type.
In general, the type command should not be used with binary files.

   Examples
     type %2\%1.dat > %2\%1.txt


File: gid.info,  Node: showing feedback when runing the solver,  Next: Managing errors,  Prev: Commands accepted by the GiD command.exe,  Up: Executing an external program

Showing feedback when runing the solver
---------------------------------------

   The information about what is displayed when the user presses
`Output view:', is also given here. The way of doing so is to include a
commented line in the script of the form:

   `#    OutputFile: $1.log' or `rem    OutputFile: %1.log'

   where `$1.log' means to display in that window, a file whose name is:
`project_name.log' The name can also be and absolute name like
`output.dat'.  If this line is omitted, when the user presses `Output
view:', nothing will be displayed.


File: gid.info,  Node: Managing errors,  Next: Shell script examples,  Prev: showing feedback when runing the solver,  Up: Executing an external program

Managing errors
---------------

   A commented line like

   `# ErrorFile: $1.err' or `rem ErrorFile: $1.err'

   included in the `.bat' file, means to consider that the given
filename is the error file. At the end of the execution of the `.bat'
file, if the errorfile does not exist or is zero, execution is
considered to be successful. If not, an error window appears an the
contents of the error file are considered to be the error message. If
this line exists, GiD will delete this file just before calculating to
avoid errors with previus calculations.
A commented line like

   `# WarningFile: $1.err' or `rem WarningFile: $1.err'
included in the `.bat' file, means to consider that the given filename
is the warning file. This file stores the warnings that may appear
during the execution of the `.bat' file.


File: gid.info,  Node: Shell script examples,  Prev: Managing errors,  Up: Executing an external program

Examples
--------

   Two examples are given of easy scripts to do so. One of them is for
Unix machines and the other one is for ms-dos or Windows.

   * UNIX example:
          #!/bin/csh
          set basename = $1
          set directory = $2
          set ProblemDirectory = $3
          
          #    OutputFile: $1.log          IT IS USED BY GiD
          #    ErrorFile: $1.err           IT IS USED BY GiD
          
          rm -f $basename.flavia.res
          
          $ProblemDirectory/myprogram $basename
          
          mv $basename.post $basename.flavia.res

   * MS-DOS example:
          rem basename=%1                    JUST INFORMATIVE
          rem directory=%2                   JUST INFORMATIVE
          rem ProblemDirectory=%3            JUST INFORMATIVE
          
          rem    OutputFile: %1.log          IT IS USED BY GiD
          rem    ErrorFile: %1.err           IT IS USED BY GiD
          
          del %1.flavia.res
          
          %3\myprogram %1
          
          move %1.post %1.flavia.res


File: gid.info,  Node: POSTPROCESS DATA FILES,  Next: TCL-TK extension,  Prev: Customization,  Up: Top

POSTPROCESS DATA FILES
**********************

   In the GiD postprocess you can study the results obtained from a
solver program. The communication between the solver and the GiD
Postprocess is made using files.  The solver program has to write the
results in a file that must have the extension `.post.res', or the old
`.flavia.res', and its name must be the project name.

   The solver program can also (it is not mandatory) give to GiD the
postprocess mesh, and should have the extension `.post.msh', or the old
`.flavia.msh'.  If this mesh is not provided by the solver program, GiD
uses in the post-process, the preprocess mesh.

   The extensions `.msh' and `.res' are also allowed, but only the
files with the extensions `.post.res', or the old `.flavia.res', and
eventually `.post.msh', or the old `.flavia.msh', will be automatically
read by GiD when postprocessing the GiD project.

   So, post-processing data files are ASCII files, and can be separated
into two categories:

   * Mesh Data File: `project_name.post.msh' `project_name.flavia.msh'
     for volume and surface (3D or 2D) mesh information and

   * Results Data File: `project_name.post.res'
     `project_name.flavia.res' for results information.

   *Note:* `ProjectName.post.msh', or the old `ProjectName.flavia.msh',
handles meshes of different element types: points, lines, triangles,
quadrilaterals, tetrahedras and hexahedras.  The old format, which only
handles one type of element per file, is still supported inside GiD
(*note old mesh format::.).

   If a project is loaded into GiD, when changing to `PostProcess' it
will look for `ProjectName.post.res', or the olf
`ProjectName.flavia.res'. If a mesh information file with name
`ProjectName.post.msh', or the old `ProjectName.flavia.msh' is present,
it will also be read, regardless of the information available from
`PreProcess'.

   * ProjectName.post.msh: (or the old ProjectName.flavia.msh) The
     first file, which is named `ProjectName.flavia.msh', should
     contain nodal coordinates of the 3D, and its nodal connectivities
     and the material of each element. At the moment Only one set of
     nodal coordinates can be entered. Diferent kind of elements can be
     used but separated into diferent sets. If no material is supplied,
     GiD takes the material number equal to zero.

   * ProjectName.post.res: (or the old ProjectName.flavia.res) This
     second file must contain the nodal or gaussian variables. GiD
     allows the user to define as many nodal variables as desired, as
     well as several steps and analysis cases (limited only by the
     memory of the machine).  Gauss points and results on these gauss
     points should also be in this file.

   The files are created and read in the order that corresponds with
the natural way of solving a finite element problem: mesh, surface
definition and conditions and finally, evaluation of the results.  The
format of the read statements is normally free, i.e. it is necessary
only to separate them by spaces.

   Thus, the users can modify the files with any format, leaving spaces
between each field and can also write out the results with as many
decimals as desired. In case of error, the program warns the user about
the type of mistake found.

   GiD reads all the information directly from the pre-processing files
in order to gain efficiency, whenever possible.

* Menu:

* File ProjectName.post.msh - ProjectName.flavia.msh::
* File ProjectName.post.res - ProjectName.flavia.res::
* old results format::
* old mesh format::


File: gid.info,  Node: File ProjectName.post.msh - ProjectName.flavia.msh,  Next: File ProjectName.post.res - ProjectName.flavia.res,  Prev: POSTPROCESS DATA FILES,  Up: POSTPROCESS DATA FILES

New postprocess mesh format: ProjectName.post.msh, ProjectName.flavia.msh
=========================================================================

   Note: The new postprocess mesh format needs GiD version 6.0 or
higher.

   Comment are allowed and should begin with a '`#''.  Blank lines are
also allowed.

   Inside this file one or more `MESH'es can be defined, each of them
should:

   * Begin with a header with this pattern:

          MESH "mesh_name" dimension my_dimension Elemtype my_type Nnode my_number
     being
        - `MESH', `dimension', `elemtype', `nnode': keywords that
          should be written as they are, case doesn't matter.

        - `"mesh_name"': an optional name for the mesh,

        - `my_dimension': 2 or 3 according to the geometric dimension
          of the mesh.

        - `my_type': one of `Point', `Linear', `Triangle',
          `Quadrilateral',     `Tetrahedra' or `Hexahedra', describing
          the element type of this `MESH'.

        - `my_number': the number of nodes of `my_type' element:

             · `Point': 1 node,

             · `Linear': 2 or 3 nodes,

             · `Triangle': 3 or 6 nodes,

             · `Quadrilateral': 4, 8 or 9 nodes,

             · `Tetrahedra': 4 or 10 nodes,

             · `Hexahedra': 8, 20 or 27 nodes.

     Note: On elements of order higher than linear, the connectivities
     must written in hierarchical order, i.e. first the vertex nodes,
     then the middle ones.

   * followed by the coordinates:

          coordinates
             1   0.0   1.0   3.0
          . . .
          
          1000  -2.5   9.3  21.8
          end coordinates
     being
        - the pair `coordinates' and `end coordinates' keywords that
          should be written as they are, case doesn't matter.

        - And between these keywords, the nodal coordinates of all the
          `MESH'es or the current one.
          *Note:* if each `MESH' specifies its own coordinates, the
          node number should be unique, for instance, if `MESH' "mesh
          one" uses nodes 1..100, and `MESH' "other mesh" uses 50
          nodes, they should be numbered up 100.

   * and followed by the elements conectivity

          elements
          #el_num node_1 node_2 node_3 material
             1      1      2      3      215
          . . .
          
          1000     32     48     23      215
          end elements
     being
        - the pair `elements' and `end elements' keywords that should be
          written as they are, case doesn't matter.

        - And in-between the nodal conectivities for the `my_type'
          elements,

          Note: On elements of order higher than linear, the
          connectivities must written in hierarchical order, i.e. first
          the vertex nodes, then the middle ones.

        - and an optional material number.

* Menu:

* Mesh example::


File: gid.info,  Node: Mesh example,  Prev: File ProjectName.post.msh - ProjectName.flavia.msh,  Up: File ProjectName.post.msh - ProjectName.flavia.msh

Mesh example
------------

   This example clarifies this description:


     #mesh of a table
     MESH "board" dimension 3 ElemType Triangle  Nnode 3
     Coordinates
     # node number   coordinate_x  coordinate_y  coordinate_z
         1             -5              3             -3
         2             -5              3              0
         3             -5              0              0
         4             -2              2              0
         5       -1.66667              3              0
         6             -5             -3             -3
         7             -2             -2              0
         8              0              0              0
         9             -5             -3              0
        10        1.66667              3              0
        11       -1.66667             -3              0
        12              2              2              0
        13              2             -2              0
        14        1.66667             -3              0
        15              5              3             -3
        16              5              3              0
        17              5              0              0
        18              5             -3             -3
        19              5             -3              0
     end coordinates
     
     #we put both material in the same MESH,
     #but they could be separated into two MESH
     
     Elements
     # element  node_1   node_2  node_3 material_number
         5         19      17      13     3
         6          3       9       7     3
         7          2       3       4     3
         8         17      16      12     3
         9         12      16      10     3
        10         12      10       4     3
        11          7       9      11     3
        12          7      11      13     3
        13          2       4       5     3
        14          5       4      10     3
        15         19      13      14     3
        16         14      13      11     3
        17          3       7       4     3
        18         17      12      13     3
        19         13      12       8     4
        20         13       8       7     4
        21          7       8       4     4
        22          4       8      12     4
     end elements
     
     MESH    dimension 3 ElemType Linear  Nnode 2
     Coordinates
     #no coordinates then they are already in the first MESH
     end coordinates
     
     Elements
     # element  node_1   node_2 material_number
         1          9       6     5
         2         19      18     5
         3         16      15     5
         4          2       1     5
     end elements


File: gid.info,  Node: File ProjectName.post.res - ProjectName.flavia.res,  Next: old results format,  Prev: File ProjectName.post.msh - ProjectName.flavia.msh,  Up: POSTPROCESS DATA FILES

New postprocess results format: ProjectName.post.res, ProjectName.flavia.res
============================================================================

   Note: The new postprocess results format needs GiD version 6.1.4b or
higher.

   The first line of the files with results written in this new
postprocess format should be:

   `GiD Post Results File 1.0'

   Comment lines are allowed and should begin with a '`#''.  Blank
lines are also allowed.

   Results files can also be included with the keyword include, for
instance:

   `include "My Other Results File"'

   This is usefull, for instance, to share several `GaussPoints'
definitions and `ResultRangeTable' among different analysis.

   This 'include' should be outside the Blocks of information.

   There are several types of Blocks of information, all of them
indentified by a keyword:

   * `GaussPoints' Information about gauss points: name, number of
     gauss points, natural coordinates, etc.

   * `ResultRangesTable' Information for the result visualization type
     Contour Ranges: name, ranges limits and ranges names.

   * `Result' Information about a Result: name, analysis, analysis/time
     step, type of result, location, values.

   * `ResultGroup' several results grouped in one block. These results
     share the same analysis, time step, and location ( nodes or gauss
     points).

* Menu:

* Gauss Points::
* Result Range Table::
* Result Block::
* Result Group::
* Results example::


File: gid.info,  Node: Gauss Points,  Next: Result Range Table,  Prev: File ProjectName.post.res - ProjectName.flavia.res,  Up: File ProjectName.post.res - ProjectName.flavia.res

Gauss Points
------------

   To include `Gauss points' they must be defined before the `Result'
which uses them.

   Each `Gauss points' block are defined between a pair of
`GaussPoints' and `End GaussPoints'.

   The structure is as follows:

   * Begin with a header with this pattern:

          GaussPoints "gauss_points_name" Elemtype my_type "mesh_name"

     being
        - `GaussPoints', `elemtype': keywords that should be written as
          they are, case doesn't matter.

        - `"gauss_points_name"': a name for the `gauss points' set,
          which will be used as reference by the results that are
          located on these `gauss points'.

        - `my_type': one of `Point', `Linear', `Triangle',
          `Quadrilateral',     `Tetrahedra' or `Hexahedra', describing
          which element type are these `gauss points' for.

        - `"mesh_name"': an optional field. If this field is missing,
          the `gauss points' are defined for all the elements of type
          `my_type'. If a mesh name is given, the `gauss points' are
          only defined for this mesh.

   * followed by `gauss points' properties:

          Number of Gauss Points: number_gauss_points_per_element
          Nodes included
          Nodes not included
          Natural Coordinates: Internal
          Natural Coordinates: Given
           natural_coordinates_for_gauss_point_1
           . . .
          
           natural_coordinates_for_gauss_point_n

     being
        - `Number of Gauss Points: number_gauss_points_per_element': a
          keyword that should be written as it is, case doesn't matter,
          followed by the number of gauss points per element that
          defines this set. If `Natural Coordinates:' is set to
          `Internal', `number_gauss_points_per_element' should be one
          of:

             · 1, 3, 6 for Triangles;

             · 1, 4, 9 for Quadrilaterals;

             · 1, 4 for Tetrahedras;

             · 1, 8, 27 for Hexahedras and

             · 1, ... n points equally spaced over lines.

          For triangles and quadrilaterals the order of the gauss
          points with Internal natural coordinates, will be this one:

          For tetrahedras and hexahedras the order of the Internal
          Gauss Points is this:

          Given natural coordinates for Gauss Points should range:
             · between 0.0 and 1.0 for Triangles and Tetrahedras, and

             · between -1.0 and 1.0 for Quadrilaterals and Hexahedras.

          *Note:* If the natural coordinates used are the internal ones
          almost all the Results visualization posibilities with some
          limitations for Tetrahedras and hexahedras with more than one
          gauss points.  If the natural coordinates are given, these
          limitations are extended to those elements with
          `number_gauss_points_per_element' not included in the list
          written above.

        - `Nodes Included' / `Nodes not Included': keywords that should
          be written as they are, case doesn't matter, only necessary
          for gauss points on `Linear' elemets which indicate whether
          the end nodes of the `Linear' elemet are included in the
          `number_gauss_points_per_element' count or not.

          Note: By now, Natural Coordinates for linear elements cannot
          be "`Given'"

        - `Natural Coordinates: Internal' / `Natural Coordinates:
          Given': keywords that should be written as they are, case
          doesn't matter, telling if the natural coordinates are
          calculated internally by GiD, or are given in the following
          lines.
          The natural coordinates should be written per line and gauss
          point.

   * Ending with this tail:

          End GaussPoints

     being
        - `End GaussPoints': a keyword that should be written as it is,
          case doesn't matter.

   Here comes an example of results on `Gauss Points':

     GaussPoints "Board gauss internal" ElemType Triangle "board"
       Number Of Gauss Points: 3
       Natural Coordinates: internal
     end gausspoints


File: gid.info,  Node: Result Range Table,  Next: Result Block,  Prev: Gauss Points,  Up: File ProjectName.post.res - ProjectName.flavia.res

Result Range Table
------------------

   To include a `Result Range Table' it must be defined before the
`Result' which uses it.

   Each `Result Range Table' is defined between a pair of
`ResultRangesTable' and `End ResultRangesTable'.

   The structure is as follows:

   * Begin with a header with this pattern:

          ResultRangesTable "ResultsRangeTableName"

     being
        - `ResultRangesTable': a keyword which should be written as it
          is, case doesn't matter.

        - `"ResultsRangeTableName"': a name for the `Result Ranges
          Table', which will be used as reference by the results that
          uses this `Result Ranges Table'.

   * followed by a list of `Ranges', each of them defined as follows:

          Min_Value - Max_Value: "Range Name"

     being
        - `Min_value' : the minimum value of the range, may be void if
          the `Max_value' is given. If void, the minimum value of the
          result will be used.

        - `Max_value' : the maximum value of the range, may be void if
          the `Min_value' is given. If void, the maximum value of the
          result will be used.

        - `"Range Name"' : the name of the range which will appear on
          legends and labels.

   * Ending with this tail:

          End ResultRangesTable

     being
        - `End ResultRangesTable': a keyword that should be written as
          it is, case doesn't matter.

   Several examples of results ranges table follows,

   * Ranges defined for the whole result

          ResultRangesTable "Mi tabla"
          # all the ranges are min <= res < max except
          # the last range is min <= res <= max
                - 0.3: "Less"
            0.3 - 0.7: "Normal"
            0.7 -    : "Too much"
          End ResultRangesTable

   * Just a couple of ranges

          ResultRangesTable "Mi tabla"
            0.3 - 0.7: "Normal"
            0.7 - 0.9: "Too much"
          End ResultRangesTable

   * or using the maximum of the result:

          ResultRangesTable "Mi tabla"
            0.3 - 0.7: "Normal"
            0.7 -    : "Too much"
          End ResultRangesTable


File: gid.info,  Node: Result Block,  Next: Result Group,  Prev: Result Range Table,  Up: File ProjectName.post.res - ProjectName.flavia.res

Result block
------------

   Each `Result' block is identified by a `Result' header, followed by
several optional properties: component names, ranges table, and the
result values, defined the pair of `Values' and `End Values'.

   The structure is as follows:

   * Begin with a header with this pattern:

          Result "result name" "analysis name" step_value my_result_type my_location "location name"

     being
        - `Result': a keyword that should be written as it is, case
          doesn't matter.

        - `"result name"': a name for the `Result', which will be used
          for menus.

        - `"analysis name"': the name of the analysis of this `Result',
          which will be used for menus.

        - `step_value': the value of the step inside the analysis
          `"analysis name"'.

        - `my_type': type of the `Result', should be one of ` Scalar',
          ` Vector', ` Matrix', ` PlainDeformationMatrix', `
          MainMatrix', ` LocalAxes'.

        - `my_location': where is the `Result' located, should be one
          of ` OnNodes', ` OnGaussPoints'. If the `Result' is `
          OnGaussPoints' a `"location name"' should be entered.

        - `"location name"': name of the `Gauss Points' on which the
          `Result' is defined.

   * followed by optional `result' properties:

          ResultRangesTable "Name of a result ranges table"
          ComponentNames "Name of Component 1", "Name of Component 2"

     being
        - `ResultRangesTable "Name of a result ranges table"': (
          optional) a keyword that should be written as it is, case
          doesn't matter, followed by the name of the previously
          defined `Tesult Ranges Table' which will be used if the
          `Contour Ranges' result visualization is choosen ( *note
          Result Range Table::.).

        - `ComponentNames "Name of Component 1", "Name of Component
          2"':  ( optional) a keyword that should be written as it is,
          case doesn't matter, followed by the names of the components
          of the results which will be used in GiD. The number of
          `Component Names' are these:
             · One for a `Scalar Result'

             · Three for a `Vector Result'

             · Six for a `Matrix Result'

             · Four for a `PlainDeformationMatrix Result'

             · Six for a `MainMatrix Result'

             · Three for a `LocalAxes Result'

   * and ending with the `result' values:

          Values
           result_number_1 component_1_value component_2_value
           . . .
          
           result_number_n component_1_value component_2_value
          End Values

     being
        - `Values': a keyword that should be written as it is, case
          doesn't matter, which indicates the beginning of the
          `result's values' section.

        - The lines
             · `result_number_1 component_1_value component_2_value'

             · ` . . .'

             · ` '

             · `result_number_n component_1_value component_2_value'
          are the values of the result.  The number of results values
          are limited to:
             · if the `Result' is located `OnNodes': the number of
               nodes defined in `ProjectName.flavia.msh'

             · if the `Result' is located `OnGaussPoints "My GP"': if
               the `Gauss Points "My GP"' are defined for the mesh `"My
               mesh"', the limit is the number of gauss points in `"My
               GP"' multiplied by the number of elements of the mesh
               `"My mesh"'.  Holes are allowed. The nodes, elements,
          with no result defined will not be drawn, i.e. they will
          appear transparent.
          The number of components for each `Result Value' are:
             · for `Scalar' results: one component ` result_number_i
               scalar_value'

             · for `Vector' results: three components, with an
               optional fourth component for signed modules

               ` result_number_i x_value y_value z_value'

               ` result_number_i x_value y_value z_value
               signed_module_value'

             · for `Matrix' results: three components ( 2D models) or
               six components (3D models)

               2D: ` result_number_i Sxx_value Syy_value Sxy_value'

               3D: ` result_number_i Sxx_value Syy_value Szz_value
               Sxy_value Syz_value Sxz_value'

             · for `PlainDeformationMatrix' results: four components

               ` result_number_i Sxx_value Syy_value Sxy_value
               Szz_value'

             · for `MainMatrix' results: twelve components

               ` result_number_i Si_value Sii_value Siii_value
               Vix_value Viy_value Viz_value Viix_value Viiy_value
               Viiz_value Viiix_value Viiiy_value Viiiz_value'

             · for `LocalAxes' results: three components describing
               the Euler angles

               ` result_number_i euler_ang_1_value euler_ang_2_value
               euler_ang_3_value'

        - `End Values': a keyword that should be written as it is, case
          doesn't matter., which indicates the end of the `result's
          values' section.

   *Note:* for `Matrix' and `PlainDeformationMatrix' results, the Si,
Sii and Siii components are calculated by GiD, which represents the
eigen values & vectors of the matrix results, and which are ordered
according to the eigen value.


File: gid.info,  Node: Result Group,  Next: Results example,  Prev: Result Block,  Up: File ProjectName.post.res - ProjectName.flavia.res

Result group
------------

   Results canbe grouped into on block. These results belongs to the
same time step of the same analysis and are located in the same place.
So all the results in the group are nodal results or are defined over
the same gauss points set.

   Each Result group is identified by a `ResultGroup' header, followed
by the results descriptions and its optional properties, such as
components names and ranges tables, and the results values, between the
pair `Values' ... `End values'.

   The structure is as follows:

   * Begin with a header with this pattern

          ResultGroup "analysis name" step_value my_location "location name"

     being
        - `ResultGroup': a keyword that should be written as it is,
          case doesn't matter.

        - `"analysis name"': the name of the analysis of this
          `ResultGroup', which will be used for menus.

        - `step_value': the value of the step inside the analysis
          `"analysis name"'.

        - `my_location': where is the `ResultGroup' located, should be
          one of ` OnNodes', ` OnGaussPoints'. If the `ResultGroup' is
          ` OnGaussPoints' a `"location name"' should be entered.

        - `"location name"': name of the `Gauss Points' on which the
          `ResultGroup' is defined.

   * followed by, at least one, the results descriptions of the group:

          ResultDescription "result name" my_result_type
            ResultRangesTable "Name of a result ranges table"
            ComponentNames "Name of Component 1", "Name of Component 2"

     being
        - `ResultDescription': a keyword that should be written as it
          is, case doesn't matter.

        - `"result name"': a name for the `Result', which will be used
          for menus.

        - `my_type': type of the `Result', should be one of ` Scalar',
          ` Vector', ` Matrix', ` PlainDeformationMatrix', `
          MainMatrix', ` LocalAxes'.

     and optionally

        - `ResultRangesTable "Name of a result ranges table"': (
          optional) a keyword that should be written as it is, case
          doesn't matter, followed by the name of the previously
          defined `Tesult Ranges Table' which will be used if the
          `Contour Ranges' result visualization is choosen ( *note
          Result Range Table::.).

        - `ComponentNames "Name of Component 1", "Name of Component
          2"':  ( optional) a keyword that should be written as it is,
          case doesn't matter, followed by the names of the components
          of the results which will be used in GiD. The number of
          `Component Names' are these:
             · One for a `Scalar Result'

             · Three for a `Vector Result'

             · Six for a `Matrix Result'

             · Four for a `PlainDeformationMatrix Result'

             · Six for a `MainMatrix Result'

             · Three for a `LocalAxes Result'

   * and ending with the results values:

          Values
           location_1 result_1_component_1_value result_1_component_2_value result_1_component_3_value result_2_component_2_value result_2_component_2_value result_2_component_3_value
           . . .
          
           location_n result_1_component_1_value result_1_component_2_value result_1_component_3_value result_2_component_2_value result_2_component_2_value result_2_component_3_value
          End Values

     being
        - `Values': a keyword that should be written as it is, case
          doesn't matter, which indicates the beginning of the
          `result's values' section.

        - The lines
             · `location_1 result_1_component_1_value
               result_1_component_2_value result_1_component_3_value
               result_2_component_2_value result_2_component_2_value
               result_2_component_3_value'

             · ` . . .'

             · ` '

             · `location_n result_1_component_1_value
               result_1_component_2_value result_1_component_3_value
               result_2_component_2_value result_2_component_2_value
               result_2_component_3_value' are the values of the
          several result described with `ResultDescription' for each
          location. All the results values for the location 'i' should
          be written in the same line 'i'.
          The number of results values are limited to:
             · if the `Result' is located `OnNodes': the number of
               nodes defined in `ProjectName.post.msh', or the old
               `ProjectName.flavia.msh'.

             · if the `Result' is located `OnGaussPoints "My GP"': if
               the `Gauss Points "My GP"' are defined for the mesh `"My
               mesh"', the limit is the number of gauss points in `"My
               GP"' multiplied by the number of elements of the mesh
               `"My mesh"'.  Holes are allowed. The nodes, elements,
          with no result defined will not be drawn, i.e. they will
          appear transparent.
          The number of components for each `ResultDescription' are:
             · for `Scalar' results: one component ` result_number_i
               scalar_value'

             · for `Vector' results: three components

               ` result_number_i x_value y_value z_value'

             · for `Matrix' results: six components (3D models)

               3D: ` result_number_i Sxx_value Syy_value Szz_value
               Sxy_value Syz_value Sxz_value'

             · for `PlainDeformationMatrix' results: four components

               ` result_number_i Sxx_value Syy_value Sxy_value
               Szz_value'

             · for `MainMatrix' results: twelve components

               ` result_number_i Si_value Sii_value Siii_value
               Vix_value Viy_value Viz_value Viix_value Viiy_value
               Viiz_value Viiix_value Viiiy_value Viiiz_value'

             · for `LocalAxes' results: three components describing
               the Euler angles

               ` result_number_i euler_ang_1_value euler_ang_2_value
               euler_ang_3_value'

        - `End Values': a keyword that should be written as it is, case
          doesn't matter., which indicates the end of the `result's
          group values' section.

   Note: `Vectors' in a `ResultGroup' have always three components.

   Note: `Matrix' in a `ResultGroup' have always six components.

   Note: all the result of one node or gauss point, should be written
in the same line.

   *Note:* for `Matrix' and `PlainDeformationMatrix' results, the Si,
Sii and Siii components are calculated by GiD, which represents the
eigen values & vectors of the matrix results, and which are ordered
according to the eigen value.

   Nodal ResultGroup example:


     ResultGroup "Load Analysis" 1 OnNodes
       ResultDescription "prueba rangos" Scalar
         ResultRangesTable "Mi tabla"
       ResultDescription "ESCALAR DE PRUEBA" Scalar
         ResultRangesTable "pepito"
       ResultDescription "Desplacements" Vector
         ComponentNames "X-DESPL", "Y-DESPL" "Z-DESPL"
       ResultDescription "Nodal Stresses" Matrix
         ComponentNames "Sx", "Sy", "Sz", "Sxy", "Syz", "Sxz"
     Values
         1 0.0           0.00000E+00 0.00000E+00  0.00000E+00 0.0 0.55014E+00  0.97276E-01 -0.15427E+00 0.0 0.0 0.0
         2 6.4832835e-01 0.20855E-04 0.20855E-04 -0.19174E-04 0.0 0.50676E+00  0.33886E-01 -0.10559E+00 0.0 0.0 0.0
         3 0.0           0.35517E-04 0.35517E-04 -0.37637E-04 0.0 0.37765E+00  0.44121E-02 -0.54703E-01 0.0 0.0 0.0
     ...
     
       115 7.8873599e-01 0.42781E-04 0.42781E-04 -0.17594E-03 0.0 0.15692E-01 -0.15847E-01 -0.30077E-01 0.0 0.0 0.0
       116 7.4978158e-01 0.24357E-04 0.24357E-04 -0.18974E-03 0.0 0.21668E-02 -0.96841E-02 -0.23115E-01 0.0 0.0 0.0
     End Values

   Gauss Points ResultGroup example:


     GaussPoints "Mis Gauss" ElemType Triangle "Mensula 2D"
       Number Of Gauss Points: 3
       Natural Coordinates: Internal
     End gausspoints
     
     ResultGroup "Load Analysis" 1 OnGaussPoints "Mis Gauss"
       ResultDescription "GAUSS DE PRUEBA"  Scalar
       ResultDescription "Vector Gauss" Vector
       ResultDescription "GAUSS Points Stresses" PlainDeformationMatrix
     Values
       1 1.05   1 0                      0.0     -19.4607 -1.15932 -1.43171 -6.18601
         2.1	   0 1                      0.0     -19.4607 -1.15932 -1.43171 -6.18601
         3.15   1 1                      0.0     -19.4607 -1.15932 -1.43171 -6.18601
       2 1.2	   0 0                      0.0     -20.6207 0.596461 5.04752 -6.00727
         2.25   0 0                      0.0     -20.6207 0.596461 5.04752 -6.00727
         3.3	   2.0855e-05 -1.9174e-05   0.0     -20.6207 0.596461 5.04752 -6.00727
       3 1.35   2.0855e-05 -1.9174e-05   0.0     -16.0982 -1.25991 2.15101 -5.20742
         2.4	   2.0855e-05 -1.9174e-05   0.0     -16.0982 -1.25991 2.15101 -5.20742
         3.45   2.0855e-05 -1.9174e-05   0.0     -16.0982 -1.25991 2.15101 -5.20742
     ...
     
     191 29.55  4.2781e-05 -0.00017594   0.0     -0.468376 12.1979 0.610867 3.51885
         30.6   4.2781e-05 -0.00017594   0.0     -0.468376 12.1979 0.610867 3.51885
         31.65  4.2781e-05 -0.00017594   0.0     -0.468376 12.1979 0.610867 3.51885
     192 29.7   4.2781e-05 -0.00017594   0.0     0.747727 11.0624 1.13201 3.54303
         30.75  4.2781e-05 -0.00017594   0.0     0.747727 11.0624 1.13201 3.54303
         31.8   2.4357e-05 -0.00018974   0.0     0.747727 11.0624 1.13201 3.54303
     End Values


File: gid.info,  Node: Results example,  Prev: Result Group,  Up: File ProjectName.post.res - ProjectName.flavia.res

Results example
---------------

   Here comes an example of results for the table of the previous
example (*note Mesh example::.):


     GiD Post Results File 1.0
     
     GaussPoints "Board gauss internal" ElemType Triangle "board"
       Number Of Gauss Points: 3
       Natural Coordinates: internal
     end gausspoints
     
     GaussPoints "Board gauss given" ElemType Triangle "board"
       Number Of Gauss Points: 3
       Natural Coordinates: Given
           0.2 0.2
           0.6 0.2
           0.2 0.6
     End gausspoints
     
     GaussPoints "Board elements" ElemType Triangle "board"
       Number Of Gauss Points: 1
       Natural Coordinates: internal
     end gausspoints
     
     GaussPoints "Legs gauss points" ElemType Linear
       Number Of Gauss Points: 5
       Nodes included
       Natural Coordinates: Internal
     End Gausspoints
     
     ResultRangesTable "Mi tabla"
     # el ultimo rango es min <= res <= max
           - 0.3: "Poco"
       0.3 - 0.9: "Normal"
       0.9 - 1.2: "Mucho"
     End ResultRangesTable
     
     Result "Gauss element" "Load Analysis" 1 Scalar OnGaussPoints "Board elements"
     Values
         5     0.00000E+00
         6     0.20855E-04
         7     0.35517E-04
         8     0.46098E-04
         9     0.54377E-04
        10     0.60728E-04
        11     0.65328E-04
        12     0.68332E-04
        13     0.69931E-04
        14     0.70425E-04
        15     0.70452E-04
        16     0.51224E-04
        17     0.32917E-04
        18     0.15190E-04
        19    -0.32415E-05
        20    -0.22903E-04
        21    -0.22919E-04
        22    -0.22283E-04
     End Values
     
     Result "Displacements" "Load Analysis"  1  Vector OnNodes
     ResultRangesTable "Mi tabla"
     ComponentNames "X-DESPL", "Y-DESPL", "Z-DESPL"
     Values
         1    0.0   0.0   0.0
         2   -0.1   0.1   0.5
         3    0.0   0.0   0.8
         4   -0.04  0.04  1.0
         5   -0.05  0.05  0.7
         6    0.0   0.0   0.0
         7   -0.04 -0.04  1.0
         8    0.0   0.0   1.2
         9   -0.1  -0.1   0.5
        10    0.05  0.05  0.7
        11   -0.05 -0.05  0.7
        12    0.04  0.04  1.0
        13    0.04 -0.04  1.0
        14    0.05 -0.05  0.7
        15    0.0   0.0   0.0
        16    0.1   0.1   0.5
        17    0.0   0.0   0.8
        18    0.0   0.0   0.0
        19    0.1  -0.1   0.5
     End Values
     
     Result "Gauss displacements" "Load Analysis" 1 Vector OnGaussPoints "Board gauss given"
     Values
         5    0.1  -0.1   0.5
              0.0   0.0   0.8
              0.04 -0.04  1.0
         6    0.0   0.0   0.8
             -0.1  -0.1   0.5
             -0.04 -0.04  1.0
         7   -0.1   0.1   0.5
              0.0   0.0   0.8
             -0.04  0.04  1.0
         8    0.0   0.0   0.8
              0.1   0.1   0.5
              0.04  0.04  1.0
         9    0.04  0.04  1.0
              0.1   0.1   0.5
              0.05  0.05  0.7
        10    0.04  0.04  1.0
              0.05  0.05  0.7
             -0.04  0.04  1.0
        11   -0.04 -0.04  1.0
             -0.1  -0.1   0.5
             -0.05 -0.05  0.7
        12   -0.04 -0.04  1.0
             -0.05 -0.05  0.7
              0.04 -0.04  1.0
        13   -0.1   0.1   0.5
             -0.04  0.04  1.0
             -0.05  0.05  0.7
        14   -0.05  0.05  0.7
             -0.04  0.04  1.0
              0.05  0.05  0.7
        15    0.1  -0.1   0.5
              0.04 -0.04  1.0
              0.05 -0.05  0.7
        16    0.05 -0.05  0.7
              0.04 -0.04  1.0
             -0.05 -0.05  0.7
        17    0.0   0.0   0.8
             -0.04 -0.04  1.0
             -0.04  0.04  1.0
        18    0.0   0.0   0.8
              0.04  0.04  1.0
              0.04 -0.04  1.0
        19    0.04 -0.04  1.0
              0.04  0.04  1.0
              0.0   0.0   1.2
        20    0.04 -0.04  1.0
              0.0   0.0   1.2
             -0.04 -0.04  1.0
        21   -0.04 -0.04  1.0
              0.0   0.0   1.2
             -0.04  0.04  1.0
        22   -0.04  0.04  1.0
              0.0   0.0   1.2
              0.04  0.04  1.0
     End Values
     
     Result "Legs gauss displacements" "Load Analysis" 1 Vector OnGaussPoints "Legs gauss points"
     Values
         1   -0.1  -0.1   0.5
             -0.2  -0.2   0.375
             -0.05 -0.05  0.25
              0.2   0.2   0.125
              0.0   0.0   0.0
         2    0.1  -0.1   0.5
              0.2  -0.2   0.375
              0.05 -0.05  0.25
             -0.2   0.2   0.125
              0.0   0.0   0.0
         3    0.1   0.1   0.5
              0.2   0.2   0.375
              0.05  0.05  0.25
             -0.2  -0.2   0.125
              0.0   0.0   0.0
         4   -0.1   0.1   0.5
             -0.2   0.2   0.375
             -0.05  0.05  0.25
              0.2  -0.2   0.125
              0.0   0.0   0.0
     End Values


File: gid.info,  Node: old results format,  Next: old mesh format,  Prev: File ProjectName.post.res - ProjectName.flavia.res,  Up: POSTPROCESS DATA FILES

Old postprocess results format
==============================

   This file is a complete list of the dumped results, where each
result will be organized as follows:

Set 1: Header. Results description

   The total number of lines in this set is 1, composed by 1 character
string, 1 integer, 1 real, 1 optional character string what depends on
the first integer, plus 3 integers:

`descr_menu' ` load_type' `step_val' [`load_desc'] `data_type'
`data_loc' `desc_comp' [`"gauss_points_name"']

   where:
   * `descr_menu' = results title that will appear on the menus
     (maximum 15 characters without any blank spaces inside).

   * `load_type' = type of analysis effectuated to obtain this result:

        - 1 - time analysis (Time Step).

        - 2 - load analysis (Load Step).

        - 3 - frequency analysis (Frequency).

        - 4 - user defined analysis (User Step).

   * `step_val' = number of steps inside the analysis.

   * `load_desc' = description, without any blank spaces inside, of the
     analysis that will appear on the menus. This field must only be
     specified when the analysis is defined by the user (`load_type' =
     4).

   * `data_type' = kind of results:

        - 1 - scalar.

        - 2 - vector.

        - 3 - matrix.

        - 4 - 2D plane deformation matrix

        - 5 - Main stresses ( 3 modules and 3 vectors)

        - 6 - Euler angles ( for local axes)

   * `data_loc' = position of the data:

     1 - on the nodes.  2 - on the Gauss points.

   * `desc_comp' = specification of the existence of a description of
     each component that will be displayed as a menu's button:

        - 0 - no description (inside GiD, the program itself creates
          the description for the corresponding components).

        - 1 - there will be a description, without any blank spaces
          inside, of the components, with one component per line.

   * `"gauss_points_name"': optional field that specifies the set of
     gauss points to be used (new gauss point format *note Gauss
     Points::.). If not specified the general gauss points definition
     will be used (old format).

Set 2: Description of the components

   The description of each one of the result's components, without any
blank spaces inside, should be described here if needed, one per line.
The number of lines will be as follows:
   * One line if it is a scalar.

   * Three lines if it is vector.

   * Six lines if it is a matrix.

   * Four lines if it is a 2D plane deformation matrix.

   * Six lines if it is Main Stresses.

   * Three lines if it is a Euler angles result.  This description will
appear in different menus to select the variable to be displayed at
each stage.

   *Note:* GiD also supports 2D results types, so description
components can be two for vectors, and three or four for matrix and
plane strain analysis, respectively.

Set 3: Results

   The total number of lines in this set is the total number of points
if `data_loc' = 1 or the total number of elements multiplied by the
number of Gauss points per element if `data_loc' = 2. The definition of
the results is itemized below.

   * *Scalar*: Each line is composed by one integer plus one real
     number:

   `i' `result[i]'

     where:
        - `i' = node or Gauss point number.

        - `result[i]' = value of the result on the node or Gauss point
          number `i'.

   * *Vector*: Each line is composed by 1 integer plus 3 reals:

   `i' `result_x[i]' `result_y[i]' `result_z[i]' `result_m[i]'

     where:
        - `i' = node or Gauss point number.

        - `result_x[i]' = value of the x_component of the result on the
          node or Gauss point number `i'.

        - `result_y[i]' = value of the y_component of the result on the
          node or Gauss point number `i'.

        - `result_z[i]' = value of the x_component of the result on the
          node or Gauss point number `i'. Optional if a 2D result type
          is specified. Should be specified if `result_m[i]' is given.

        - `result_m[i]' = value of the signed module of the vector (to
          allow negative values for the vector diagram result view).
          This component is optional, if not specified, GiD calculates
          the module of the entered vector. But if it is defined,
          `result_z[i]' should be defined too.

   * *Matrix*: Each line is composed by 1 integer plus 6 reals: `i'
`result_Sxx[i]' `result_Syy[i]' `result_Szz[i]' `result_Sxy[i]'
`result_Syz[i]' `result_Sxz[i]'

     where:
        - `i' = node or Gauss point number.

        - `result_Sxx[i]' = value of the xx_component of the result on
          the node or Gauss point number `i'.

        - `result_Syy[i]' = value of the yy_component of the result on
          the node or Gauss point number `i'.

        - `result_Szz[i]' = value of the zz_component of the result on
          the node or Gauss point number `i'. Optional if a 2D result
          type is specified that is not a plane deformation matrix.

        - `result_Sxy[i]' = value of the xy_component of the result on
          the node or Gauss point number `i'.

        - `result_Syz[i]' = value of the yz_component of the result on
          the node or Gauss point number `i'. Optional if a 2D result
          type is specified.

        - `result_Sxz[i]' = value of the xz_component of the result on
          the node or Gauss point number `i'. Optional if a 2D result
          type is specified.

   * *Main Stresses*: Another way to give Stresses to GiD is entering
     modules and vectors of these main stresses, so each line is
     composed by 1 integer plus 12 reals:

   `i' `result_Si[i]' `result_Sii[i]' `result_Siii[i]' `result_Vi_x[i]'
`result_Vi_y[i]' `result_Vi_z[i]' `result_Vii_x[i]' `result_Vii_y[i]'
`result_Vii_z[i]' `result_Viii_x[i]' `result_Viii_y[i]'
`result_Viii_z[i]'

     where:
        - `i' = node or Gauss point number.

        - `result_Si[i]' = value of the Si_module of the result on the
          node or Gauss point number `i'.

        - `result_Sii[i]' = value of the Sii_module of the result on
          the node or Gauss point number `i'.

        - `result_Siii[i]' = value of the Siii_module of the result on
          the node or Gauss point number `i'. Optional if a 2D result
          type is specified.

        - `result_Vi_x[i]' = value of the X_component of the vector Si
          on the node or Gauss point number `i'.

        - `result_Vi_y[i]' = value of the Y_component of the vector Si
          on the node or Gauss point number `i'.

        - `result_Vi_z[i]' = value of the Z_component of the vector Si
          on the node or Gauss point number `i'. Optional if a 2D
          result type is specified.

        - `result_Vii_x[i]' = value of the X_component of the vector
          Sii on the node or Gauss point number `i'.

        - `result_Vii_y[i]' = value of the Y_component of the vector
          Sii on the node or Gauss point number `i'.

        - `result_Vii_z[i]' = value of the Z_component of the vector
          Sii on the node or Gauss point number `i'. Optional if a 2D
          result type is specified.

        - `result_Viii_x[i]' = value of the X_component of the vector
          Siii on the node or Gauss point number `i'.

        - `result_Viii_y[i]' = value of the Y_component of the vector
          Siii on the node or Gauss point number `i'.

        - `result_Viii_z[i]' = value of the Z_component of the vector
          Siii on the node or Gauss point number `i'. Optional if a 2D
          result type is specified.

   * *Local Axes*: Local Axes are entered using the Euler angles that
     define them, so each line is composed by 1 integer plus 3 reals:

   `i' `euler_ang_1[i]' `euler_ang_2[i]' `euler_ang_3[i]'

     where:
        - `i' = node or Gauss point number.

        - `euler_ang_1[i]' = value of the 1st. angle of Euler of the
          local axis on the node or Gauss point number `i'.

        - `euler_ang_2[i]' = value of the 2nd. angle of Euler of the
          local axis on the node or Gauss point number `i'.

        - `euler_ang_3[i]' = value of the 3rd. angle of Euler of the
          local axis on the node or Gauss point number `i'.

   *Note:* for `Matrix' and `PlainDeformationMatrix' results, the Si,
Sii and Siii components are calculated by GiD, which represents the
eigen values & vectors of the matrix results, and which are ordered
according to the eigen value.

   *Results on GaussPoints:* When defining results on Gauss Points
using the new Gauss points format, i.e. giving a `"gauss_points_name"'
on the Result's `Header' description, the results should be given on a
per element basis specifying the element number only once. For instance:

   assuming a three gauss points set named "GaussTriang" has been
defined over triangles, there are only two triangles, then a supposed
'Displacement' result will look like this:

     GaussDISPLAC.   2    1    2    2    0 "GaussTriang"
         5    0.1  -0.1   0.5
              0.0   0.0   0.8
              0.04 -0.04  1.0
         6    0.0   0.0   0.8
             -0.1  -0.1   0.5
             -0.04 -0.04  1.0

* Menu:

* Gauss Points - Old format::


File: gid.info,  Node: Gauss Points - Old format,  Prev: old results format,  Up: old results format

Gauss Points (Old format)
-------------------------

   Note: Next is described the old Gauss Points file format for the old
results file format. However, the new Gauss Points file format (*note
Gauss Points::.) is also compatible with the old results format.

*Gauss Points*: To include the Gauss points in the results, they must be
treated as if they were a type of result, but:

   - they must be inserted at the beginning of the file,

   - the header structure is the same as of the results ones, but the
meaning changes.

   *Note:* At the time only Gauss Points on Lines, Triangles and
Quadrilaterals, and one Gauss Point for Tetrahedras and Hexahedras are
supported inside GiD.

Set 1: Header. Gauss points

   The total number of lines in this set is also 1, but it is composed
always now by one character string, one integer, one real plus three
integers:

`descr_menu' `load_type' `step_val' `data_type' `data_loc' `desc_comp'

   where:
   * `descr_menu' will not be used.

   * `load_type' = 0, to indicate that they are Gauss points.

   * `step_val' = number of Gauss points per element:

        - 1, 3, 6 for Triangles;

        - 1, 4, 9 for quadrilaterals;

        - 1, 4, 10 for Tetrahedras;

        - 1, 8, 27 for hexahedras and

        - 1, ... points equally spaced over lines.

     *Note:* This must be constant for the whole geometry.  *Note:*
     Tetrahedras with 4 and 10 Gauss Points and Hexahedras with 8 and
     27 Gauss Points are not functional and still under development.

   * `data_type' = this field indicates whether the Natural coordinates
     for the Gauss points are the ones described below this header or
     are the ones defined inside GiD.

        - 0 - the Natural Coordinates for the Gauss points will be the
          ones which are described below, for Triangles and Tetrahedras
          they should be between 0.0 and 1.0, and for Quadrilaterals
          and Hexahedras should be between -1.0 and 1.0.

          For instance, the Natural Coordinates of three Gauss Points
          on Triangles will be:
                    Coords_P_Gauss     0    3    0    0    0
                    1     0.5     0.0
                    2     0.5     0.5
                    3     0.0     0.5
               These are also the ones that GiD uses internally to
          calculate Gauss Points for Triangles with three Gauss Points,
          when this field is set to `1'.

        - 1 - the program must calculate the Gauss Points and will be
          these ones:

     This field is meaningless to lines, and should be set to 1

   * `data_loc' = this option indicates whether the nodes are included
     inside the number of points over lines or not.

        - 1 - nodes are not included in the points count for lines, so
          points are placed at a distance from the nodes `i / (
          n_points + 1)' with `i = 1..n_points' and `n_points >= 1'.

        - 2 - nodes are included in the points count for lines, so
          points are placed at a distance from the nodes `( i - 1) / (
          n_points - 1)' with `i = 1..n_points' and `n_points >= 2'.

     This field is meaningless to triangles, quadrilaterals,
     tetrahedras and hexahedras.

   * `desc_comp' does not matter, but it must be specified.


File: gid.info,  Node: old mesh format,  Prev: old results format,  Up: POSTPROCESS DATA FILES

Old postprocess mesh format
===========================

   The old postproces mesh format is still compatible with this version
of GiD. The files containing the postprocess mesh (in the old file
format) can be separated into two categories:

   * 3D Data Files: `ProjectName.post.msh', or the old
     `ProjectName.flavia.msh', for volume mesh information and
     `ProjectName.post.bon', or the old `ProjectName.flavia.bon', for
     surface mesh information.

   * 2D Data Files: `ProjectName.post.dat', or the old
     `ProjectName.flavia.dat' for 2D mesh information.

   Postprocessing data files are ASCII files and must be in a specific
format, which is explained below. Each mesh information file can only
handle one type of element.

   * ProjectName.flavia.msh: The first file, which is named
     `ProjectName.flavia.msh', should contain the information relative
     to the 3D volume mesh. It contains the nodal coordinates of the 3D
     mesh, its nodal connectivities and the material of each element.
     The nodal coordinates must include those on the surface mesh. If
     no material is supplied, GiD takes the material number equal to
     zero.

   * ProjectName.flavia.bon: The second file, which is named
     `ProjectName.flavia.bon', should contain the information about 3D
     surface sets. It can be used to represent boundary conditions of
     the volumetric mesh and additional surfaces (for instance, sheets,
     beams and shells). At least, all the mesh points supplied in
     `ProjectName.flavia.msh' should be present in
     `ProjectName.flavia.bon' at the beginning of the file.

   * ProjectName.flavia.dat: This file contains information about 2D
     meshes. And only can be used if none of the two above are used. It
     should specify nodal coordinates of the meshes, its connectivities
     ( elements) and, if desired, its material number ( if not
     specified, GiD takes to be 0).

     The files are created and read in the order that corresponds with
     the natural way of solving a finite element problem: mesh, surface
     definition and conditions and finally, evaluation of the nodal
     results.  The format of the read statements is normally free, i.e.
     it is necessary only to separate them by spaces.  Thus, the users
     can modify the files with any format, leaving spaces between each
     field and can also write out the results with as many decimals as
     desired. In case of error, the program warns the user about the
     type of mistake found.

     GiD reads all the information directly from the pre-processing
     files in order to gain efficiency, whenever possible).

* Menu:

* File ProjectName.flavia.msh old::
* File ProjectName.flavia.bon old::
* File ProjectName.flavia.dat old::


File: gid.info,  Node: File ProjectName.flavia.msh old,  Next: File ProjectName.flavia.bon old,  Prev: old mesh format,  Up: old mesh format

Old format - File ProjectName.flavia.msh
----------------------------------------

Set 1: Header

   The total number of lines in this set is 6. All of them are free
lines for any use.  This will be the case of the first five lines,
which may have an information role, informing about the project name,
current version, as well as extra comments that can seem useful to add.
Although they can be skipped, they are kept as a particular option
inside GiD (comment lines) and as an utility to comment some additional
information, like the type of project, equations, conditions and others.

   *Note:* It is advisable, as it occurs in different solver modules
used by GiD, that the sixth line explains the contents of the seventh
line.

Set 2: General mesh data

   The total number of lines in this set is 1, composed by at least 3
integers, the 4th integer is optional:

`n_3D_mesh_elements' `n_3D_mesh_points' `n_element_type' [ `last_node']

   where:
   * `n_3D_mesh_elements' = number of mesh elements.

   * `n_3D_mesh_points' = number of mesh points.

   * `n_element_type' = type of elements.

   * `last_node' = number of the last node and required if nodes are
     not between 1 and `n_3D_mesh_points'.

   The third parameter is used by the program to recognize what kind of
finite element is being used. To do this in a standard way, GiD
considers the following finite element types:
   - number 1 corresponds to a hexahedra with eight nodes.

   - number 3 corresponds to a tetrahedra with four nodes.

Set 3: Free line for any use

   The total number of lines in this set is 1, which is a free line for
any use, though most modules inside GiD write here the word
'Coordinates' to point the meaning of the following lines.

Set 4: Coordinates

   The total number of lines in this set is `n_3D_mesh_points', one for
each nodal point, composed by 1 integer plus 3 reals numbers:

`i' `x_coord[i]' `y_coord[i]' `z_coord[i]'

   where:
   * `i' = node number.

   * `x_coord[i]' = x_coordinate of the node number `i'.

   * `y_coord[i]' = y_coordinate of the node number `i'.

   * `z_coord[i]' = z_coordinate of the node number `i'.

   All the points of the meshes of the domain have to appear in this
file.

Set 5: Free line for any use

   The total number of lines in this set is 1, which is a free line for
any use.  The same comments used for set number 3 are valid here, with
the change of including the word 'Connectivities' instead of
'Coordinates'.

Set 6: Connectivities

   The total number of lines in this set is `n_3D_mesh_elements',
composed by 1 integer plus `n_nodes/element' integers and 1 optional
integer more:

`j' `node[j][1]' `node[j][2]' ... `node[j][n_nodes/element]' `mat[j]'

   where:
   * `j' = element number.

   * `node[j][1]' = node number 1 for the element number `j'.

   * `node[j][2]' = node number 2 for the element number `j'.

     ...

   * `node[j][n_nodes/element]' = last node number for the element
     number `j'.

   * `mat[j]' = material index of the element number `j'.

   The nodal connections must follow some specifications, so, for each
tetrahedral element with four nodes, the rule is that the first three
nodes that form a triangular face must be so sorted in order to define
a normal which points towards the semi space containing the fourth node.

   The vector `mat[j]' holds the material index of the element number
`j'.


File: gid.info,  Node: File ProjectName.flavia.bon old,  Next: File ProjectName.flavia.dat old,  Prev: File ProjectName.flavia.msh old,  Up: old mesh format

Old format - File ProjectName.flavia.bon
----------------------------------------

Set 1: Header

   The total number of lines in this set is 6. All of them are free
lines for any use. All the comments relative to the header of
`ProjectName.flavia.msh' remain valid for the current file
`ProjectName.flavia.bon'.

   *Note:* It is advisable, as it occurs in different calculation
modules included in GiD, that the sixth line explains the contents of
the seventh line.

Set 2: General boundary data

   The total number of lines in this set is 1, composed by at least 3
integers, the 4th integer is optional:

`n_bound_elements' `n_bound_points' `n_element_type' [ `last_node']

   where:
   * `n_bound_elements' = number of boundary elements.

   * `n_bound_points' = number of boundary points.

   * `n_element_type' = type of elements.

   * `last_node' = number of the last node and required if nodes are
     not between 1 and `n_bound_points'.

   For the third parameter, GiD considers the following finite element
types:
   - number 7 corresponds to a triangle with three nodes.

   - number 9 corresponds to a quadrilateral with four nodes.

   - number 11 corresponds to a line with two nodes.

Set 3: Free line for any use

   The total number of lines in this set is 1, which is a free line for
any use, though most modules inside GiD write here the word
'Coordinates' to point the meaning of the following lines.

Set 4: Coordinates

   The total number of lines in this set is `n_bound_points', one for
each nodal point, composed by 1 integer plus 3 reals:

`i' `x_coord[i]' `y_coord[i]' `z_coord[i]'

   where:
   * `i' = node number.

   * `x_coord[i]' = x_coordinate of the node number `i'.

   * `y_coord[i]' = y_coordinate of the node number `i'.

   * `z_coord[i]' = z_coordinate of the node number `i'.

   All the points of the domain have to appear in this file, what
includes all the mesh points introduced in `ProjectName.flavia.msh' at
the beginning. Once all the volumetric mesh had been introduced, it is
possible to add surfaces that belong to a boundary of the domain but do
not belong to a volumetric mesh and by this reason they will not appear
in `ProjectName.flavia.msh' and only in `ProjectName.flavia.bon'.

Set 5: Free line for any use

   The total number of lines in this set is 1, which is a free line for
any use.  The same comments used for set number 3 are valid here, with
the change of including the word 'Connectivities' instead of
'Coordinates'.

Set 6: Connectivities

   The total number of lines in this set is `n_bound_elements',
composed by 1 integer plus `n_nodes/element' integers and 2 optional
integers more:

`j' `node[j][1]' `node[j][2]' ... `node[j][n_nodes/element]' `set[j]'

   where:
   * `j' = element number.

   * `node[j][1]' = node number 1 for the element number `j'.

   * `node[j][2]' = node number 2 for the element number `j'.

     ...

   * `node[j][n_nodes/element]' = last node number for the element
     number `j'.

   * `set[j]' = number of set to which the element number `j' belongs.

   The vector `set[j]' allows to distinguish groups of elements in
different sets.  It applies, for instance, in the case of defining the
different conditions that the element fulfills.

* Menu:


File: gid.info,  Node: File ProjectName.flavia.dat old,  Prev: File ProjectName.flavia.bon old,  Up: old mesh format

Old format - File ProjectName.flavia.dat
----------------------------------------

Set 1: Header

   The total number of lines in this set is 6. All of them are free
lines for any use.  The first five lines, which may have an information
role, informing about the project name, current version, as well as
extra comments that can seem useful to add. Although they can be
skipped, they are kept as a particular option inside GiD (comment
lines) and as an utility to comment some additional information, like
the type of project, equations, conditions and others.

   *Note:* It is advisable, as it occurs in different solver modules
used by GiD, that the sixth line explains the contents of the seventh
line.

Set 2: General mesh data

   The total number of lines in this set is 1, composed by at least 3
integers, the 4th integer is optional:

`n_2D_mesh_elements' `n_2D_mesh_points' `n_element_type' [ `last_node']

   where:
   * `n_2D_mesh_elements' = number of 2D mesh elements.

   * `n_2D_mesh_points' = number of 2D points.

   * `n_element_type' = type of elements.

   * `last_node' = number of the last node and required if nodes are
     not between 1 and `n_2D_mesh_points'.

   The third parameter is used by the program to recognize what kind of
finite element is being used. To do this GiD considers the number of
nodes that the finite element type uses. So,
   - number 2 corresponds to a line with two nodes.

   - number 3 corresponds to a triangle with three nodes.

   - number 4 corresponds to a quadrilateral with four nodes.

   - number 6 corresponds to a triangle with six nodes.

   - number 8 corresponds to a quadrilateral with eight nodes.

   - number 9 corresponds to a quadrilateral with nine nodes.

Set 3: Free line for any use

   The total number of lines in this set is 1, which is a free line for
any use, though most modules inside GiD write here the word
'Coordinates' to point the meaning of the following lines.

Set 4: Coordinates

   The total number of lines in this set is `n_2D_mesh_points', one for
each nodal point, composed by 1 integer plus 3 reals:

`i' `x_coord[i]' `y_coord[i]'

   where:
   * `i' = node number.

   * `x_coord[i]' = x_coordinate of the node number `i'.

   * `y_coord[i]' = y_coordinate of the node number `i'.

   All the points of the domain have to appear in this file, what
includes all the mesh points introduced in `ProjectName.flavia.msh' at
the beginning. Once all the volumetric mesh had been introduced, it is
possible to add surfaces that belong to a boundary of the domain but do
not belong to a volumetric mesh and by this reason they will not appear
in `ProjectName.flavia.msh' and only in `ProjectName.flavia.bon'.

Set 5: Free line for any use

   The total number of lines in this set is 1, which is a free line for
any use.  The same comments used for set number 3 are valid here, with
the change of including the word 'Connectivities' instead of
'Coordinates'.

Set 6: Connectivities

   The total number of lines in this set is `n_2D_mesh_elements',
composed by 1 integer plus `n_nodes/element' integers and 2 optional
integers more:

`j' `node[j][1]' `node[j][2]' ... `node[j][n_nodes/element]' `set[j]'

   where:
   * `j' = element number.

   * `node[j][1]' = node number 1 for the element number `j'.

   * `node[j][2]' = node number 2 for the element number `j'.

     ...

   * `node[j][n_nodes/element]' = last node number for the element
     number `j'.

   * `set[j]' = number of set to which the element number `j' belongs.

   The vector `set[j]' allows to distinguish groups of elements in
different sets.  It applies, for instance, in the case of defining the
different conditions that the element fulfills.

   Note: The numeration of quadratic elements is linear and not
hierarchical, i.e. nodes should be specified counterclockwise, without
jumping internal nodes.


File: gid.info,  Node: TCL-TK extension,  Next: INDEX,  Prev: POSTPROCESS DATA FILES,  Up: Top

TCL-TK EXTENSION
****************

   In this chapter, there are exposed the advanced features of GiD in
terms of expandability and total control. The TCL-TK extension is the
way to create script files to automatize any process created with GiD.
With this language it is possible to add new windows or new
functionalities to the program.

   For more information about the TCL-TK programming language look at
www.scriptics.com.

   If such TCL file exists, it must be in the problem type directory;
the name of the file has to be the problem type name with the `.tcl'
extension.

   The structure of `problem_type_name.tcl' is composed by seven
possible procedures (the syntax corresponds to TCL-language):

     proc InitGIDProject { dir } {
     ...body(1)...
     }
     proc InitGIDPostProcess {} {
     ...body(2)...
     }
     proc EndGIDProject {} {
     ...body(3)...
     }
     proc EndGiDPostprocess {} {
     ...body(4)...
     }
     proc LoadGIDProject { filespd } {
     ...body(5)...
     }
     proc SaveGIDProject { filespd } {
     ...body(6)...
     }
     proc proc LoadResultsGIDPostProcess { file } {
     ...body(7)...
     }
     proc BeforeMeshGeneration { elementsize } {
     ...body(8)...
     }
     proc AfterMeshGeneration { fail } {
     ...body(9)...
     }
	

   * InitGIDProject: will be called when the problem type is selected.
     It receives the `dir' argument, which is the absolute path to the
     `problem_type_name.gid' directory, which can be useful inside the
     routine to locate some alternative files.

   * InitGIDPostProcess: will be called when the postprocess starts. It
     has no arguments.

   * EndGIDProject: will be called when this project is about to be
     closed. It has no arguments.

   * EndGIDPostProcess: will be called when the user leaves postprocess
     and opens preprocess. It has no arguments.

   * LoadGIDProject: will be called when a GiD project is loaded. It
     receives the `filespd' argument, which is the path of the file
     which is being opened, but with a `.spd' extension (specific
     problemtype data). This path can be useful if you want to write
     specific information of the problem type in a new file.

   * SaveGIDProject: will be called when the current opened file is
     saved to disk. It receives the `filespd' argument, which is the
     path of the file which is being saved, but with a `.spd' extension
     (specific problemtype data). This path can be useful if you want
     to write specific information of the problem type in a new file.

   * LoadResultsGIDPostProcess: will be called when a results file is
     opened in the postprocess. It receives one argument, the name of
     the file being opened without its extension.

   * BeforeMeshGeneration: will be called before the mesh generation. It receives
     as argument 'elementsize' the user desired mesh size. This event can be used
     tipically to automatically assign some condition.

   * AfterMeshGeneration: will be called after the mesh generation. It receives
     as argument 'fail' a true value if the mesh is not created.


   *Note:* To use TCL to improve the capabilities of writing the
calculations file, it is possible to use the command `*tcl' in the
template file (.bas file); *note Specific commands::. for details.

* Menu:

* Control functions::
* Managing menus::
* HTML support::
* GiD version::
* Using EXEC in GiD::
* Detailed example - TCL-TK extension creation::


File: gid.info,  Node: Control functions,  Next: Managing menus,  Prev: TCL-TK extension,  Up: TCL-TK extension

Control functions
=================

   GiD offers the following TCL functions:

   * .central.s process command_1 command_2 ...: used to execute GiD
     commands

   * .central.s info option: used to obtain information about the
     actual GiD project

* Menu:

* process function::
* info function::
* special functions::


File: gid.info,  Node: process function,  Next: info function,  Prev: Control functions,  Up: Control functions

Process function
----------------

   .central.s process command_1 command_2 ...

   This is a simple function but really powerfull.  It is used to enter
commands directly inside the central event manager.  The format of the
comand has to be a string with the same style as if they were entered
by typing on the command line interface.

   You have to enter exactly the same sequence as you would do
interactively, including the escape sequences, using the word `escape',
and selecting the menus and operations used.

   It is possible to obtain the exact commands that GiD needs, by
checking the right buttons toolbar (Utilities > Graphical > Toolbars).
It's also possible to save a batch file (Utilities > Preferences >
Batch file) and check there the commands used during the GiD session.

   One simple example to create one line:
     .central.s process escape escape escape escape \
             geometry create line 0,0,0 10,0,0 escape


File: gid.info,  Node: info function,  Next: special functions,  Prev: process function,  Up: Control functions

Info function
-------------

   .central.s info option

   This function provides any information about GiD, the current data or
the state of any task inside the aplication. Depending on the arguments
introduced after the `.central.s info' sentence, GiD will output
different information:

   * .central.s info materials
     This command returns a list of the materials of the project.

     Also these options are avalaible:
        - ["material_name"]: If a material name is given, its
          properties are returned. If the material name is given it's
          also possible to add the option [OTHERFIELDS] to get the
          fields of that material, or the option [BOOK], to get the
          book of that material.

        - [BOOKS]: If this option is given, a list of the material
          books of the project is returned.

          Examples:
          in:  `.central.s info materials'
          out: `"Air Steel Aluminium Concrete Water Sand"'
          in:  `.central.s info materials Steel'
          out: `"1 Density 7850"'

   * .central.s info conditions ovpnt | ovline | ovsurf | ovvol
     This command returns a list of the conditions in the project.
     Argument ovpnt, ovline, ovsurf, ovvol must be given to indicate
     the type of condition: condition over points, lines, surfaces or
     volumes.

     Instead of ovpnt, ovline, ovsurf, ovvol, the following options are
     also avalaible:
        - [-interval "intv"] [-localaxes | localaxesmat]
          "condition_name" [geometry | mesh]: if a condition name is
          given, the command returns the properties of that condition.
          If the condition name is given, it's also possible to add the
          option geometry or mesh, and all mesh or geometry entities
          that have this condition assigned, will be returned.
          If -interval "intv" is set, then are returned the contitions
          on this interval ("intv"=1,...n) instead the current interval.
          If -localaxes is set, then also are returned three numbers
          that are the 3 Euler angles that define a local axes system
          (only for conditions with local axes, *Note Local axes::).
          Selecting -localaxesmat are returned the nine numbers that
          define the transformation matrix of a vector from the local
          axes system to the global one.
          Adding the number id of an entity ( ["entity_id"] ) after the
          options mesh or geometry, the command returns the value of
          the condition assigned to that entity.
          Other options avalaible if the condition name is given are
          [OTHERFIELD], to get the fields of that condition, and
          [BOOK], to get the book of the condition.

        - [BOOKS]: If this option is given, a list of the condition
          books of the project is returned.  Examples:
          in:  `.central.s info conditions ovpnt'
          out: `"Point-Weight Point-Load"'
          in:  `.central.s info conditions Point-Weight'
          out: `"ovpnt 1 Weight 0"'
          in:  `.central.s info conditions Point-Weight geometry'
          out: `"E 1 - 2334 , E 2 - 2334 , E 3 - 343"'
          in:  `.central.s info Conditions -localaxes
          Concrete_rec_section mesh 2'
          out: `{E 2 - {4.7123889803846897 1.5707963267948966 0.0} N-m
          0.3 0.3 HA-25}'
   * .central.s info layers
     This command returns a list of the layers of the project.

     Also these options are avalaible:
        - ["layer_name"]: If a layer name is given, the command returns
          the properties of that layer.

        - [-on]: returns a list of the visible layers.

        - [-off]: returns a list of the hidden layers.

        - [-hasbacklayers]: returns 1 if the project have entities
          inside back layers. .central.s info back_layers returns a
          list with the back layers
          Example:
          in:  `.central.s info back_layers'
          out: `Layer2_*back*'
        - [-bbox[-use geometry|mesh] ]: layer_name_1 layer_name_2 ...]:
          returns two coordinates (x1,y1,z1,x2,y2,z2) which define the
          bounding box of the entities that belong to the list of
          layers. If the option [-use geometry|mesh] is used, the
          command returns the bounding box of the geometry or the
          bounding box of the mesh. If the list of layers is empty, the
          maximum bounding box is returned.

        - [-entities]: One of the following arguments must be given:
          nodes, elements, points, lines, surfaces or volumes.A layer
          name must also be given. The command will return the nodes,
          elements, points, lines surfaces or volumes of that layer.

          Examples:
          in:  `.central.s info layers'
          out: `"layer1 layer2 layer_aux"'
          in:  `.central.s info layers -on'
          out: `"layer1 layer2"'
          in:  `.central.s info layers -entities lines layer2'
          out: `"6 7 8 9"'
   * .central.s info gendata
     This command returns the information entered in the Problem Data
     window (*note Problem and intervals data file::.).
     The following options are avalaible:
        - [OTHERFIELDS]: it is possible to add this option to get the
          additional fields of the Problem Data window.

        - [BOOKS]: If this option is given, a list of the Problem Data
          books of the project is returned.
          Example:
          in:  `.central.s gendata'
          out: `"2 Unit_System#CB#(SI,CGS,User) SI Title M_title"'
   * .central.s info intvdata
     This command returns a list of the interval data in the project
     (*note Problem and intervals data file::.).
     The following options are avalaible:
        - [OTHERFIELDS]: it is possible to add this option to get the
          additional fields of the Interval Data window.

        - [BOOKS]: If this option is given, a list of the Interval Data
          books of the project is returned.
        - [NUM]: if this option is given, a list of two naturals is
          returned. The first element of the list is the current
          interval and the second element is the total number of
          intervals.
   * .central.s info Project
     This command returns information about the project. More
     precisely, it is returned a list with:
        * Problem type name.

        * Current example name.

        * 'There are changes' flag.

        * Current layer.

        * Active part (GEOMETRYUSE,MESHUSE,POSTUSE or GRAFUSE).

        * Quadratic problem flag.

        * Drawing type (normal,polygons,render,postprocess).

        * NOPOST or YESPOST

        * debug or nodebug

        * GiD temporary directory.

        * Geometry changes since the mesh was created (0 or 1).

        * Last size of element used for meshing (`NONE' if there's no
          mesh).

          Example:
          in:  `.central.s Project'
          out: `"cmas2d e:\models\car_model 1 layer3 MESHUSE 0 normal
          YESPOST nodebug C:\TEMP\gid2 0 1.4"'
   * .central.s info Mesh
     This command gives to the user information about the selected mesh
     in the project. It returns a `1' followed by a list with all types
     of element used in the mesh.
     The following two options are avalaible:
        - [MaxNumElements]: returns the total number of elements of the
          mesh.

        - [MaxNumNodes]: returns the total number of nodes of the mesh.

        - [Elements Elemtype[First_id Last_id]]: returns a list with
          the element number, the connectivities and the material
          number, from 'first_id' to 'last_id, if they are specified.
          Elemtype can be:
          Linear/Triangle/Quadrilateral/Tetrahedra/Hexahedra/Prisma.

        - [Nodes[First_id Last_id]]: returns a list with the node
          number and x y z coordinates, from 'first_id' to 'last_id',
          if they are specified.

          Examples:
          in:  `.central.s info Mesh'
          out: `"1 Tetrahedra Triangle"'
          in:  `.central.s info Mesh MaxNumNodes'
          out: `"1623"'
   * .central.s info Coordinates point_id/node_id [geometry|mesh]
     This command returns the coordinates (x,y,z) of the given point or
     node.

   * .central.s info variables "variable_name"
     This command returns the value of the variable indicated. GiD
     variables can be found through the right buttons menu (*note
     Graphical::.), under the option utilities > variables.

   * .central.s info localaxes
     This command returns a list with all the user defined local axes.

   * .central.s info ortholimits
     This command returns a list of the limits of the geometry in the
     project.

   * .central.s info perspectivefactor
     This command returns which perspective factor is being currently
     used in the project.

   * .central.s info graphcenter
     This command returns the coordinates (x,y,z) of the center of
     rotation.

   * .central.s info MeshQuality
     This command returns a list of numbers. These naturals are the Y
     relative values of the graph showed in the option Meshing > Mesh
     quality (*note Mesh quality::.).

     This command has the following arguments:
        - MinAngle/MaxAngle: quality criteria.
        - Linear/Triangle/Tetrahedra/QuadrilateralHexahedra/Prisma:
          type of element
        - "min_degrees": number of minimum degrees accepted.
        - "max_degrees": number of maximum degrees accepted.
        - "num_divisions": number of divisions.

          Example:
          in:  `.central.s info MeshQuality MinAngle Triangle 20 60 4'
          out: `"13 34 23 0"'

   * .central.s info postprocess arewein
     This command returns `YES' if the user is in the GiD postprocess,
     and `NO', if the user is not.

   * .central.s info postprocess get
     This command returns information about the GiD postprocess. The
     following options are avalaible:
        - all_volumes: returns a list of all volumes.

        - all_surfaces: returns a list of all surfaces.

        - all_cuts: returns a list of all cuts.

        - all_graphs: returns a list of all graphs.

        - all_volumes_colors: returns a list of the volume colors used
          in the project. Colors are represented in RGB in hexadecimal
          format. Example: `#000000' would be black, and `#FFFFFF'
          would be white.

        - all_surfaces_colors: returns a list of the surface colors
          used in the project. Colors are represented in RGB in
          hexadecimal format. Example: `#000000' would be black, and
          `#FFFFFF' would be white.

        - all_cuts_colors :returns a list of the cut colors used in the
          project. Colors are represented in RGB in hexadecimal format.
          Example: `#000000' would be black, and `#FFFFFF' would be
          white.

        - cur_volumes: returns a list of the visible volumes.

        - cur_surfaces: returns a list of the visible surfaces.

        - cur_cuts: returns a list of the visible cuts.

        - all_display_styles: returns a list of all types of display
          styles avalaible.

        - cur_display_style: returns the current display style.

        - all_display_renders: returns a list of all types of render
          avalaible.

        - cur_display_render: returns the current rendering  method.

        - all_display_culling: returns a list of all types of culling
          avalaible.

        - cur_display_culling: returns the current culling
          visualization.

        - cur_display_transparence: returns `Opaque' or `Transparent'
          depending on the current transparency. Transparency is chosen
          by the user in the Select & Display Style window.

        - cur_display_body_type: returns `Massive' if the option
          Massive of the window Select & Display Style is selected. It
          returns `Hollow' if that option is not activated.

        - all_analisis: returns a list of all analisis in the project.

        - all_steps "analisis_name": returns the number of steps of
          "analisis_name".

        - cur_analisis: returns the name of the current analisis.

        - cur_step: returns the current step.

        - all_results_views: returns all avalaible result views.

        - cur_results_view: retuns the current result view.

        - cur_results_list: this option has one more argument: the kind
          of result visualization must be given. The avalaible kinds of
          result visualization are given by the option
          all_results_views. The comand returns a list of all the
          results that can be represented with that visualization in
          the current step of the current analysis.

        - results_list: this option has three arguments: the first
          argument is the kind of result visualization. The avalaible
          kinds of result visualization are given by the option
          all_results_views. The second argument the analysis name. The
          third argument is the number of step. The comand returns a
          list of all the results that can be represented with that
          visualization in the given step.

        - cur_result: returns the current selected result. The kind of
          result is selected by the user in the View results window.

        - cur_components_list "result_name": returns a list of all the
          components of the result "result_name".

        - cur_component: returns the current component of the current
          result.

        - main_geom_state: returns if the main geometry is `Deformed'
          or `Original'

        - main_geom_all_deform: returns a list of all the deformation
          variables (vectors) of the main geometry.

        - main_geom_cur_deform: returns the current deformation
          variable (vectors) of the main geometry.

        - main_geom_cur_step: returns the main geometry current step.

        - main_geom_cur_anal: returns the main geometry current
          analysis.

        - main_geom_cur_factor: returns the main geometry current
          deformation factor.

        - show_geom_state: returns if the reference geometry is
          `Deformed' or `Original'.

        - show_geom_cur_deform: returns the current deformation
          variable (vectors) of the reference geometry.

        - show_geom_cur_analisis: returns the reference geometry
          current analysis.

        - show_geom_cur_step: returns the reference geometry current
          step.

        - iso_all_display_styles: returns a list of all avalaible
          display styles for iso surfaces.

        - iso_cur_display_style: returns the current display style for
          iso surfaces.

        - iso_all_display_renders: returns a list of all types of
          render avalaible for iso surfaces.

        - iso_cur_display_render: returns the current rendering  method
          for iso surfaces.

        - iso_cur_display_transparence: returns Opaque or Transparent
          depending on the current transparency of iso surfaces.

        - contour_limits: returns the minimum and maximum value of the
          contour limits. Before each value, the word `STD' appears if
          the contour limit value is the default value, and `USER', if
          it's defined by the user.

        - animationformat: returns the default animation format.

        - cur_show_conditions: returns the option selected in the
          Conditions combo box of the Select & Display Style window.
          (Possible values: `Geometry Mesh None')

        - all_show_conditions: returns all the options avalaible in the
          Conditions combo box of the Select & Display Style window.
          (`Geometry Mesh None')

        - cur_contour_limits: returns the minimum and maximum value of
          the current value.

        - current_color_scale: returns a list of the colors used for
          the color scale; the first element of the list is the number
          of colors. Each color is represented in RGB in hexadecimal
          format. Example: `#000000' would be black, and `#FFFFFF'
          would be white.

   * .central.s info AutomaticTolerance
     This command returns the value of the Import Tolerance used in the
     project. This value is defined in the Preferences window under
     Import.

   * .central.s info RGBDefaultBackground
     This command returns the default background color in RGB. The
     format is three 8 bit numbers separated by #. Example:
     `255#255#255' would be white.

   * .central.s info list_entities status
     This command returns a list with general information about the
     current GiD project.
          Example:
          in:  `.central.s list_entities status'
          out:
          ` Project name: UNNAMED
          Problem type: UNKNOWN
          Changes to save(0/1): 1
          Necessary to mesh again (0/1): 1
          Using LAYER: NONE
          Interval 1 of 1 intervals
          Degree of elements is: Normal
          Using now mode(geometry/mesh): geometry
          number of points: 6
          number of points with 2 higher entities: 6
          number of points with 0 conditions: 6
          number of lines: 6
          number of lines with 1 higher entities: 6
          number of lines with 0 conditions: 6
          number of surfaces: 1
          number of surfaces with 0 higher entities: 1
          number of surfaces with 0 conditions: 1
          number of volumes: 0
          number of nodes: 8
          number of nodes with 0 conditions: 8
          number of Triangle elements: 6
          number of elements  with 0 conditions: 6
          Total number of elements: 6
          Last size used for meshing: 10
          Internal information:
          Total MeshingData:0   Active: 0   0%'
   * .central.s info list_entities
     This command returns information about entities.
     It has the following arguments:
        - Points/Lines/Surfaces/Volumes/Nodes/Elements: type of entity.
          Note: if the user is postprocessing in GiD, the information
          returned by Nodes/Elements is the relative to the nodes and
          elements in postprocess, including its results information.
          To access the preprocess information about the preprocess
          mesh the following entities keywords should be used
          PreNodes/PreElements.

        - entity_id: number of entity. It is also possible to enter a
          list of entities (example: `2 3 6 45') a range of entities
          (example: entities from 3 to 45, would be `3:45') or a layer
          (example: `layer:layer_name').
     With option -more returns more information about the entity.
     Option -more used with lines, returns the length of the line, its
     radius (arcs), and the list of surfaces which are higuer entities
     of that line; used with elements, it returns the type of element,
     its number of nodes and its volume.

          Example 1:
          in:  `.central.s info list_entities Points 2 1'
          out:
          `POINT
          Num: 2 HigherEntity: 1 conditions: 0 material: 0
          LAYER: car_lines
          Coord: -11.767595 -2.403779 0.000000
          END POINT
          POINT
          Num: 1 HigherEntity: 1 conditions: 0 material: 0
          LAYER: car_lines
          Coord: -13.514935 2.563781 0.000000
          END POINT'
          Example 2:
          in:  `.central.s info list_entities lines layer:car_lines'
          out:
          `STLINE
          Num: 1 HigherEntity: 0 conditions: 0 material: 0
          LAYER: car_lines
          Points: 1 2
          END STLINE
          STLINE
          Num: 13 HigherEntity: 0 conditions: 0 material: 0
          LAYER: car_lines
          Points: 13 14
          END STLINE'
          Example 3 (using -more):
          in:  `.central.s info list_entities -more Lines 2'
          out:
          ` STLINE
          Num: 2 HigherEntity: 2 conditions: 0 material: 0
          LAYER: Layer0
          Points: 2 3
          END STLINE
          LINE (more)
          Length=3.1848 Radius=100000
          Higher entities surfaces: 1 3
          END LINE'
   * .central.s info ListMassProperties
     This command returns properties of the selected entities. It
     returns the length if entities are lines, area, if surfaces,
     volume if volumes, or the gravity center if entities are nodes or
     elements.
     It has the following arguments:
        - Points/Lines/Surfaces/Volumes/Nodes/Elements: type of entity.
          entity_id: number of entity. It is also possible to enter a
          list of entities (example: `2 3 6 45') a range of entities
          (example: entities from 3 to 45, would be `3:45').

          Example:
          in:  `.central.s info ListMassProperties Lines 13 15'
          out:
          `LINES
          n. Length
          13 9.876855
          15 9.913899
          Selected 2 figures
          ________________________
          Total Length=19.790754'
   * .central.s info problemtypepath
     This command returns the absolute path to the current Problem Type.

   * .central.s info GiDVersion
     This command returns the GiD version number. For example 6.2.0b.


File: gid.info,  Node: special functions,  Prev: info function,  Up: Control functions

Special functions
-----------------

   It exists some special commands to control the redraw and wait state
of GiD:

   .central.s disable graphics 'value' The value 0/1 Enable/Disable
Graphics (GiD doesn't redraw)
EXAMPLE to disable the redraw:
     .central.s disable graphics 1

   .central.s disable graphinput 'value' The value 0/1 Enable/Disable
GraphInput (enable or disable peripherals: mouse, keyboard, ...)
EXAMPLE to disable the peripherals input:
     .central.s disable graphinput 1

   .central.s disable windows 'value' The value 0/1 Enable/Disable
Windows (GiD displays, or not, windows which require interaction with
the user)
EXAMPLE to disable the interaction windows:
     .central.s disable windows 1

   .central.s waitstate 'value' The value 0/1 Enable/Disable the Wait
state (GiD displays a hourglass cursor in wait state)
EXAMPLE to set the state to wait:
     .central.s waitstate 1

   Usually these command are used jointly:
EXAMPLE
     #deactivate redraws, etc wit a witget named $w
     $w conf -cursor watch
     .central.s waitstate 1
     update
     .central.s disable graphics 1
     .central.s disable windows 1
     .central.s disable graphinput 1
     
     ...
     
     #reactivate all and redraw
     .central.s disable graphics 0
     .central.s disable windows 0
     .central.s disable graphinput 0
     .central.s process "redraw"
     $w conf -cursor ""
     .central.s waitstate 0


File: gid.info,  Node: Managing menus,  Next: HTML support,  Prev: Control functions,  Up: TCL-TK extension

Managing menus
==============

   GiD offers some functions to change the GiD menus. With these
functions it is possible to add new menus or to change the existing
ones. If you are creating a problem type, these functions should be
called from the `InitGIDProject' or `InitGIDPostProcess' functions
(*note TCL-TK extension::.).

   Note: Menus and option menus are identified by its name.
Note: It is not necessary to restore the menus when leaving the problem
type, GiD already does it.

   The TCL functions are:
   * CreateMenu {new_menu_name prepost}
     Creates a new menu. New menus are inserted between the Calculate
     and Help menu.
        - `new_menu_name': name of the new menu.

        - `prepost' can have these values:
          `"PRE"' to create the menu only in the preprocess
          `"POST"' to create the menu only in the postprocess
          or `"PREPOST"' to create the menu in the pre and postprocess
   * InsertMenuOption {menu_name option_name position command prepost
     [insert/replace] }
     Creates a new option for a given menu in a given position
     (positions start at 0). By default, if it already exists an option
     in the given position, that option is substitued by the new one.
     If the `insert' argument is given, the new menu option is inserted.
        - `menu_name': name of the menu where you want to insert the
          new option.

        - `option_name': name of the new option you want to insert. If
          `option_name' is `"---"', then , a separator line is inserted
          in the menu. If you want to insert an option to a submenu,
          you have to specify the path with ">".
          Example: `Geometry>Create>MyOption'
        - `position': position in the menu where the option has to be
          inserted. Note that positions start at 0, and separator lines
          also count.

        - `command': is the command called when the menu option is
          selected.

        - `prepost': this argument can have the following values:
          `"PRE"' to insert the option in the preprocess menus
          `"POST"' to insert the option in the postprocess menus
          or `"PREPOST"' to insert the option in the pre and
          postprocess menus

        - `insert/replace': if this argument is `insert' the new option
          is inserted. If the argument is `replace' the new option
          replaces the option of the given position. This argument is
          optional, and by default the new option replaces the existing
          one.
   * GidAddUserDataOptions {option_name command position accelerator}
     Add a new entry to the data menu of GiD (this menu is special, it
     change loading a problem type).
        - `option_name': name of the new option you want to insert. If
          `option_name' is `"---"', then , a separator line is inserted
          in the menu.

        - `command': is the command called when the menu option is
          selected.

        - `position': position in the menu where the option has to be
          inserted: an integer or `end' (default) to indicate the last
          position in the menu. Note that positions start at 0, and
          separator lines also count.

        - `accelerator': Acceleration key combination (default "").
   * RemoveMenuOption {menu_name option_name prepost}
     Removes an option of a given menu.
        - `menu_name': name of the menu which has the option you want
          to remove.

        - `option_name': name of the option you want to remove. If you
          want to remove a submenu or a submenu option, you have to
          specify the path with ">". Example: `Geometry>Create>Point'
        - `prepost': this argument can have the following values:
          `"PRE"' to remove an option of the preprocess menus
          `"POST"' to remove an option of the postprocess menus
          or `"PREPOST"' to remove an option of the pre and the
          postprocess menus
     Note: `menu_name' and `option_name' are case sensitive.
   * UpdateMenus {}
     Updates changes made on menus. This function must be called when
     all calls to `CreateMenu', `InsertMenuOption' or
     `RemoveMenuOption', are done.

EXAMPLE: creating and modifying menus
In this example we create a new menu called "New Menu" and we modify
the GiD Help menu:

   The code to make these changes would be:
     CreateMenu "New Menu" "PRE"
     InsertMenuOption "New Menu" "Option 1" 0 "Command_1" "PRE"
     InsertMenuOption "New Menu" "Option 2" 1 "Command_2" "PRE"
     InsertMenuOption "New Menu" "---"      2 "" "PRE"
     InsertMenuOption "New Menu" "Option 3" 3 "Command_3" "PRE"
     
     InsertMenuOption "Help" "My Help" 1 "" "PRE" "insert"
     InsertMenuOption "Help" "My Help>My help 1" 0 "Command_help1" "PRE"
     InsertMenuOption "Help" "My Help>My help 2" 1 "Command_help2" "PRE"
     
     
     RemoveMenuOption  "Help" "Customization Help" "PRE"
     RemoveMenuOption  "Help" "What is new ..." "PRE"
     RemoveMenuOption  "Help" "FAQ" "PRE"
     UpdateMenus

EXAMPLE: removing a submenu or a submenu option
In this example we remove the option `Quadrilateral' of the `Meshing'
menu.

   To remove option `Quadrilateral':

     RemoveMenuOption  "Meshing" "Element type>Quadrilateral" "PRE"
     UpdateMenus


File: gid.info,  Node: HTML support,  Next: GiD version,  Prev: Managing menus,  Up: TCL-TK extension

HTML support
============

   GiD offers a function which opens an internal HTML browser; that may
be useful if you want to add online help to your problem type.

     1 - Create a directory named `html' inside your problem type
     directory
     2 - Call HelpWindow "CUSTOM_HELP" "problem_type_name", where
     `problem_type_name' is the name of your problem type with the
     `.gid' extension (for example, `cmas2d.gid').
     3 - Function HelpWindow opens the file "index.html" which must be
     inside the `html' folder.
   It's a good idea to call the function HelpWindow "CUSTOM_HELP"
"problem_type_name" using the menu functions (*note Managing menus::.).
EXAMPLE: Adding a customized HTML help in the Help menu for the CMAS2D
problem type:

     InsertMenuOption "Help" \
         "Help CMAS2D"  0 {HelpWindow "CUSTOM_HELP" "cmas2d.gid"} "PREPOST"
     
     UpdateMenus


File: gid.info,  Node: GiD version,  Next: Using EXEC in GiD,  Prev: HTML support,  Up: TCL-TK extension

GiD version
===========

   Normally a problem type requires a minimum version of GiD to run.
Because the problem type can be distributed or sold separately from
GiD, it's important to check the GiD version before continuing with the
execution of the problem type. GiD offers a function, GiDVersionCmp,
which compares the version of the GiD which is currently running with a
given version.

   GiDVersionCmp { Version }
Returns a negative integer if `Version' is greater than the currently
executed GiD version; zero if the two versions are identical; and a
positive integer if `Version' is less than the GiD version.
Note: This function will always return a -1 if the GiD version is
previous to 6.1.5.

EXAMPLE
     proc InitGIDProject { dir } {
         global GidPriv
         set VersionRequired "6.2.0b"
         set comp -1
         catch {
           set comp [GiDVersionCmp $VersionRequired]
         }
         if { $comp < 0 } {
     	tk_dialogRAM .gid.tempwinw Warning \
     	  "This interface requires GiD $VersionRequired or later" error 0 OK
         }
     }


File: gid.info,  Node: Using EXEC in GiD,  Next: Detailed example - TCL-TK extension creation,  Prev: GiD version,  Up: TCL-TK extension

Using EXEC in GiD
=================

   The TCL language has the `exec' command used to invoke a subprocess.
This command treats its arguments as the specification of one or more
subprocesses to execute. It's possible to invoke a subprocess from GiD
using this option.

   Example: invoking a process in the background
     exec netscape http://gid.cimne.com &

Note: In Windows, instead of `&' it's necessary to put `>& NUL: &' to
run the process in the background. Example: `exec PROGRAM_NAME >& NUL:
& '

File: gid.info,  Node: Detailed example - TCL-TK extension creation,  Prev: Using EXEC in GiD,  Up: TCL-TK extension

Detailed example - TCL-TK extension creation
============================================

Next is an example of the creation of a TCL-TK extension, step by step.
In this example we will create the `cmas2d.tcl' file, so, we will
extend the capabilities of the cmas2d problem type. The file
`cmas2d.tcl' has to be placed inside the cdmas2d problem type directory.

   Note: The cmas2d problem type calculates the center of masses of a
2D surface. This problem type is located inside `problemtypes', in the
GiD directory.

   In this example, the `cmas2d.tcl' creates a window which appears
when the problem type is selected.

   This window gives information about the location, materials and
conditions of the problem type. The window has two buttons: the button
CONTINUE lets the users continue working with the cmas2d problem type;
the button RANDOM SURFACE creates a random 2D surface in the plane XY.

   Here starts the TCL code for the example. There are three main
procedures in the `cmas2d.tcl' file:
   * proc InitGIDProject {dir}

          proc InitGIDProject {dir } {
          
            set materials  [.central.s info materials]
            set conditions [.central.s info conditions ovpnt]
          
            CreateWindow $dir $materials $conditions
          
          }

     This is the main procedure. It is executed when the problem type
     is selected. It calls the CreateWindow procedure.

   * proc CreateWindow {dir mat cond}
          proc CreateWindow {dir mat cond} {
          
           set w .gid.win_example
          
           InitWindow $w "CMAS2D.TCL - Example tcl file" ExampleCMAS "" \
          	    "" 1
          
           frame $w.top
           label $w.top.title_text \
                  -text " TCL window example for CMAS2D problem type "
          
           frame $w.information  -relief ridge -bd 2
           label $w.information.path        \
                  -text " Problem Type path: $dir "
           label $w.information.materials   \
                  -text " Avalaible materials: $mat"
           label $w.information.conditions  \
                  -text " Avalaible conditions: $cond"
          
           frame $w.bottom
           button $w.bottom.start \
                  -text "CONTINUE" \
                  -height 1 -width 14 -command "destroy $w"
           button $w.bottom.random \
                  -text "RANDOM SURFACE" \
                  -height 1 -width 20 -command "CreateRandomSurface $w"
          
          
          
           pack $w.top.title_text -pady 10
           pack $w.information.path $w.information.materials \
                $w.information.conditions -side top -anchor w
          
           pack $w.bottom.start $w.bottom.random \
                 -side left -anchor center
           pack $w.top
           pack $w.information -expand yes -fill both
           pack $w.bottom -side top -padx 6 -pady 10 -ipady 2
          }

     This procedure creates the window with information about the path,
     the materials and the conditions of the project. The window has
     two buttons: if the CONTINUE button is pressed the window is
     dismissed; if the RANDOM SURFACE button is pressed, it calls the
     CreateRandomSurface procedure.

   * proc CreateRandomSurface {w}

          proc CreateRandomSurface {w} {
          
           set ret [tk_dialogRAM $w.dialog "Warning!!" \
              "Warning: this will create a nurbs surface in your \
               current project" "" 1 "ok" "cancel"]
          
           if {$ret ==0} {
                 Create_surface
                 destroy $w
            }
          }
     This procedure is called when the RANDOM SURFACE button is
     pressed. Before creating the surface, a dialog asks the user to
     continue or to cancel the creation of the surface. If the surface
     has to be created, the Create_surface procedure is called. Then,
     the window is destroyed.

          proc Create_surface {} {
          
          
            set a_x [expr rand()*10]
            set a_y [expr rand()*10]
          
            set b_x [expr $a_x + rand()*10]
            set b_y [expr $a_y + rand()*10]
          
            set c_x [expr $b_x + rand()*10]
            set c_y [expr $b_y - rand()*10]
          
          
          
            if {$a_y < $c_y} {
                     set d_y [expr $a_y - rand()*10]
          	   set d_x [expr $a_x + rand()*10]
          	   } else {
          	   set d_y [expr $c_y - rand()*10]
          	   set d_x [expr $c_x - rand()*10]
          	   }
          
          
            .central.s process escape escape escape escape
          
            .central.s process geometry create line \
            $a_x,$a_y,0.000000tol0.176991 \
            $b_x,$b_y,0.000000tol0.176991 \
            $c_x,$c_y,0.000000tol0.176991 \
            $d_x,$d_y,0.000000tol0.176991 \
            close
          
          
          
            .central.s process escape escape escape escape
            .central.s process geometry create NurbsSurface Automatic \
            4 \
            escape \
          
            .central.s process zoom frame escape escape escape escape
           }

     A 2D surface (a 4 side 2D polygon) is created. The points of this
     surface are chosen at random.


File: gid.info,  Node: INDEX,  Prev: TCL-TK extension,  Up: Top

INDEX
*****

* Menu:

* About:                                 About.
* ACIS read:                             ACIS read.
* Actualize problem type:                Transform problem type.
* Add:                                   Specific commands.
* analysis selection:                    postprocessing results.
* angle:                                 Dimensions.
* Angle rotation:                        Rotate angle.
* animate controls:                      Animate controls.
* Animation:                             Animation.
* Animation Window:                      Animation.
* Arc center:                            Option Arc center.
* Arc creation:                          Arc creation.
* Arc tangents:                          Arc tangents.
* Arcs (swap):                           Swap arcs.
* Arrows operations:                     Command line.
* ASCII write project:                   Save ASCII project.
* Assign condition:                      Assign condition.
* Assign material:                       Assign material.
* Assign unstruct sizes:                 Assign unstruct sizes.
* automatic comments:                    Automatic comments.
* automatic comments patterns:           Automatic comments.
* Automatic NURBS surface:               NURBS surface creation.
* Automatic volume:                      Automatic 6-sided volumes.
* AVI files:                             Animation.
* Background Image:                      Background image.
* background mesh:                       Assign unstruct sizes.
* bas file example:                      Detailed example.
* Base option in points:                 Button Base.
* Basics:                                GiD basics.
* BasicUnit:                             Single value return commands.
* bat file commands:                     Commands accepted by the GiD command.exe.
* bat file examples:                     Shell script examples.
* Batch file:                            Batch file.
* batch window:                          Read batch window.
* beam diagrams:                         Line Diagrams.
* body:                                  Display Style.
* body with boundaries:                  Display Style.
* body with lines:                       Display Style.
* Book:                                  Special fields.
* Boolean surface operations:            Surface boolean operations.
* Boolean volume operations:             Volume boolean operations.
* Boundaries <1>:                        Display Style.
* Boundaries:                            View boundaries.
* Break:                                 Specific commands.
* By cordal error:                       Assign unstruct sizes.
* By geometry:                           Assign unstruct sizes.
* CAD differences:                       Introduction.
* Calculate:                             Calculate.
* Calculation file:                      Calculation file.
* Calculator:                            Calculator.
* Call:                                  Commands accepted by the GiD command.exe.
* Calling GiD:                           Invoking GiD.
* Cancel mesh:                           Cancel mesh.
* Center (rotation):                     Rotate center.
* change light vector:                   Change Light Vector.
* changing cut color:                    Display Style.
* changing mesh color:                   Display Style.
* changing set color:                    Display Style.
* cilynder:                              Object.
* Circle:                                Object.
* Clip planes:                           Clip planes.
* Clock:                                 Single value return commands.
* Collapse:                              Collapse.
* color selection:                       Display Style.
* Command line:                          Command line.
* Command line arguments:                Invoking GiD.
* command.exe:                           Commands accepted by the GiD command.exe.
* commands *.bat:                        Commands accepted by the GiD command.exe.
* Commands used in the .bas file:        Commands used in the .bas file.
* Comments:                              Comments.
* Comments patterns:                     Automatic comments.
* Cond:                                  Single value return commands.
* Conditions:                            Conditions.
* Conditions definitions:                Conditions file.
* Conditions file example:               Example Conditions File creation.
* Conditions symbols:                    Conditions symbols file.
* CondNumEntities:                       Single value return commands.
* cone:                                  Object.
* Configuration file:                    Save configuration file.
* Contact copy:                          Copy.
* Contact creation:                      Contact creation.
* contour fill:                          Contour Fill.
* contour lines:                         Contour Lines.
* Contour Range, Contour Ranges:         Result Range Table.
* contour ranges:                        Contour Ranges.
* Control functions:                     Control functions.
* convert cuts to sets:                  Do Cuts.
* convert to cuts:                       Iso Surface.
* Convert to NURBS line:                 Convert to NURBS.
* Coon's surface:                        4-sided surface creation.
* Coordinates:                           Entering points by coordinates.
* Coordinates window:                    Coordinates window.
* Copy:                                  Copy.
* Copy command:                          Commands accepted by the GiD command.exe.
* Cordal error:                          Assign unstruct sizes.
* Correct sizes:                         Assign unstruct sizes.
* cover mesh:                            Cover mesh.
* Create 4-sided surface:                4-sided surface creation.
* Create 4-sided surface automatically:  4-sided surface automatic creation.
* Create arc:                            Arc creation.
* Create contact:                        Contact creation.
* Create entities:                       Create.
* Create line:                           Line creation.
* Create line (straight):                Line creation.
* Create NURBS line:                     NURBS line creation.
* Create NURBS surface:                  NURBS surface creation.
* Create planar surface:                 Planar surface creation.
* Create point:                          Point creation.
* Create polyline:                       Polyline creation.
* Create volume:                         Volume creation.
* Customization:                         Customization.
* Cylindrical coordinates:               Cylindrical coordinates.
* Data:                                  Data.
* data files:                            POSTPROCESS DATA FILES.
* data input files:                      General description.
* data report:                           Text data report.
* deform mesh:                           Deform Mesh.
* Del:                                   Commands accepted by the GiD command.exe.
* Delete elements:                       Delete elements.
* Delete entities:                       Delete.
* Delete lonely nodes:                   Delete lonely nodes.
* Dependencies:                          Special fields.
* display style:                         Display Style.
* display vectors:                       Display vectors.
* distance:                              Dimensions.
* Distance:                              Distance.
* Divide:                                Divide.
* Draw again:                            Redraw.
* Draw assigned sizes:                   Draw Sizes.
* Draw condition:                        Draw condition.
* Draw line normals:                     Draw line normals.
* Draw material:                         Draw material.
* Draw Sizes:                            Draw Sizes.
* Draw surface normals:                  Draw surface normals.
* DXF read:                              DXF read.
* DXF write:                             DXF write.
* Dynamic box:                           Entities selection.
* Dynamic pan:                           Pan.
* Echo:                                  Commands accepted by the GiD command.exe.
* Edit entities:                         Edit.
* Edit mesh:                             Edit mesh.
* Edit NURBS line:                       Edit NURBS line.
* Edit NURBS surface:                    Edit NURBS surface.
* Edit polyline:                         Edit polyline.
* Edit SurfMesh:                         Edit SurfMesh.
* Element type:                          Element type.
* Elements (structured):                 Structured mesh.
* ElemsConec:                            Multiple values return commands.
* ElemsLayerName:                        Single value return commands.
* ElemsLayerNum:                         Single value return commands.
* ElemsMat:                              Single value return commands.
* ElemsNnode:                            Multiple values return commands.
* ElemsNnodeCurt:                        Multiple values return commands.
* ElemsNum:                              Single value return commands.
* ElemsType:                             Multiple values return commands.
* ElemsTypeName:                         Multiple values return commands.
* Else:                                  Specific commands.
* ElseIf:                                Specific commands.
* End:                                   Specific commands.
* End session:                           Quit.
* Endif:                                 Specific commands.
* Entering cylindrical coordinates:      Cylindrical coordinates.
* Entering global coordinates:           Local/global coordinates.
* Entering local coordinates:            Local/global coordinates.
* Entering points:                       Point definition.
* Entering points by coordinates:        Entering points by coordinates.
* Entering spherical coordinates:        Spherical coordinates.
* Entities informations:                 List.
* Entities labels:                       Label.
* Entities selection:                    Entities selection.
* Entities share:                        Copy.
* Entities visualization:                Entities.
* Erase:                                 Commands accepted by the GiD command.exe.
* Erase elements:                        Delete elements.
* Erase entities:                        Delete.
* Errors when executing an external program: Managing errors.
* Escape:                                Escape.
* Euler Angles result format:            old results format.
* EXEC:                                  Using EXEC in GiD.
* Executing external program:            Executing an external program.
* Explode polyline:                      Explode polyline.
* Export:                                Export.
* Export ASCII project:                  Save ASCII project.
* Export calculation file:               Calculation file.
* export data report:                    Text data report.
* Export DXF:                            DXF write.
* export GiD mesh:                       GiD mesh.
* Export IGES:                           IGES write.
* Extents (zoom):                        Zoom.
* External program execution:            Executing an external program.
* Extrude:                               Copy.
* FactorUnit:                            Single value return commands.
* FEMAP:                                 files - postprocess.
* File NAME.bas:                         General description.
* File NAME.cnd:                         Conditions file.
* File NAME.mat:                         Materials file.
* File NAME.prb:                         Problem and intervals data file.
* File NAME.sim:                         Conditions symbols file.
* File NAME.uni:                         Unit System file.
* File ProjectName.flavia.bon (Old Format): File ProjectName.flavia.bon old.
* File ProjectName.flavia.dat (Old Format): File ProjectName.flavia.dat old.
* File ProjectName.flavia.msh:           File ProjectName.post.msh - ProjectName.flavia.msh.
* File ProjectName.flavia.msh (Old Format): File ProjectName.flavia.msh old.
* File ProjectName.flavia.res:           File ProjectName.post.res - ProjectName.flavia.res.
* File ProjectName.post.msh:             File ProjectName.post.msh - ProjectName.flavia.msh.
* File ProjectName.post.res:             File ProjectName.post.res - ProjectName.flavia.res.
* Files:                                 Files.
* Files ***.bas:                         General description.
* Files ***.geo:                         Conditions symbols file.
* Fillet:                                Arc tangents.
* Filter:                                Entities selection.
* filter window:                         Selection window.
* Find entities:                         Signal.
* For:                                   Specific commands.
* Force mesh:                            Mesh criteria.
* Force no mesh:                         Mesh criteria.
* Format:                                Specific commands.
* Four-sided surface automatic creation: 4-sided surface automatic creation.
* Four-sided surface creation:           4-sided surface creation.
* Frame:                                 Zoom.
* Gauss points format (new format):      Gauss Points.
* Gauss points format (old format):      Gauss Points - Old format.
* Gauss points in contour fill:          Contour Fill.
* Gauss points in smooth contour fill:   Smooth Contour Fill.
* GenData:                               Single value return commands.
* General data:                          Problem data.
* Generate mesh:                         Generate.
* Geometry:                              Geometry.
* Geometry view:                         View geometry.
* GiD basics:                            GiD basics.
* GiDVersionCmp:                         GiD version.
* GIF sequence:                          Animation.
* GlobalNodes:                           Multiple values return commands.
* Goto:                                  Commands accepted by the GiD command.exe.
* Graph Lines:                           Graphs.
* Graph Lines file format:               Graph Lines File Format.
* Graph Lines options:                   Graph Lines Options.
* Graphical displacement:                Pan.
* Graphs:                                Graphs.
* Hardcopy:                              Print to file.
* Help:                                  HTML support.
* hidden boundaries:                     Display Style.
* Hidden lines:                          Display Style.
* Hide drawing regions:                  Clip planes.
* Hole NURBS surface:                    Hole NURBS surface.
* Hole volume:                           Volume creation.
* HTML support:                          HTML support.
* Icons:                                 User interface.
* Id:                                    Id.
* Identity:                              Id.
* If:                                    Specific commands.
* If command:                            Commands accepted by the GiD command.exe.
* IGES read:                             IGES read.
* IGES write:                            IGES write.
* Illumination:                          Render.
* Image:                                 Special fields.
* Import:                                Import.
* import ACIS:                           ACIS read.
* import DXF:                            DXF read.
* Import GiD mesh:                       Mesh read.
* import IGES:                           IGES read.
* import NASTRAN:                        NASTRAN read.
* import Parasolid:                      Parasolid read.
* import Shapefile:                      Shapefile read.
* Import STL mesh:                       STL mesh read.
* import VDA:                            VDA read.
* Import/Export material:                Import/Export material.
* Info entities:                         List.
* Info function:                         info function.
* Info problem:                          List.
* Initial view (rotation):               Rotate angle.
* Insert geometry:                       Insert geometry.
* Insert GiD model:                      Insert geometry.
* Internet Retrieve:                     Internet Retrieve.
* Intersection:                          Intersection.
* Intersection line-line:                Intersection line-line.
* Intersection multiple lines:           Intersection multiple lines.
* Intersection Multiple surfaces:        Intersection Multiple surfaces.
* Intersection surface lines:            Intersection Surface lines.
* Intersection Surface surface:          Intersection Surface surface.
* intersection volume volume:            Volume boolean operations.
* Interval data:                         Interval data.
* Intervals:                             Intervals.
* Intformat:                             Specific commands.
* IntvData:                              Single value return commands.
* Invoking a subprocess:                 Using EXEC in GiD.
* Invoking GiD:                          Invoking GiD.
* Iso Surface:                           Iso Surface.
* IsQuadratic:                           Single value return commands.
* Join lines end points:                 Join lines end points.
* Keyboard shortcut:                     Macros window.
* Label:                                 Label.
* Label lists (holes):                   Renumber.
* LayerColor:                            Single value return commands.
* LayerName:                             Single value return commands.
* LayerNum:                              Single value return commands.
* Layers:                                Layers.
* Layers ON save:                        Save ON layers.
* Leaving commands:                      Escape.
* legends:                               Legends.
* light:                                 Change Light Vector.
* Line (straight) creation:              Line creation.
* Line creation:                         Line creation.
* line diagrams:                         Line Diagrams.
* line options:                          Point and Line options.
* Line-line intersection:                Intersection line-line.
* Lines:                                 Display Style.
* Lines intersection (Multiple):         Intersection multiple lines.
* Lines normals:                         Draw line normals.
* Lines sense swap:                      Draw line normals.
* Lines-surface intersection:            Intersection Surface lines.
* List:                                  List.
* Listing of .bas commands:              Commands used in the .bas file.
* Local axes:                            Local axes.
* Local Axes result format:              old results format.
* Local/global coordinates:              Local/global coordinates.
* LocalAxesDef:                          Multiple values return commands.
* LocalAxesDef(EulerAngles):             Multiple values return commands.
* LocalAxesDefCenter:                    Multiple values return commands.
* LocalAxesNum:                          Single value return commands.
* LocalNodes:                            Multiple values return commands.
* Loop:                                  Specific commands.
* LoopVar:                               Single value return commands.
* Macros window:                         Macros window.
* Main Stresses result format:           old results format.
* Managing menus:                        Managing menus.
* Material (new):                        New material.
* Materials:                             Materials.
* Materials file example:                Example Materials File creation.
* Materials properties:                  Materials file.
* MatNum:                                Single value return commands.
* MatProp:                               Single value return commands.
* Matrix result format:                  old results format.
* Mcopy:                                 Copy.
* Menu TCL functions:                    Managing menus.
* Mesh:                                  Meshing.
* Mesh cancel:                           Cancel mesh.
* Mesh criteria:                         Mesh criteria.
* Mesh edit:                             Edit mesh.
* mesh example:                          Mesh example.
* Mesh generation:                       Generate.
* Mesh quality:                          Mesh quality.
* Mesh read:                             Mesh read.
* Mesh view:                             Mesh view.
* Mesh write:                            GiD mesh.
* Meshing:                               Meshing.
* Meshing data reset:                    Reset mesh data.
* MessageBox:                            Specific commands.
* Mirror:                                Copy.
* Mkdir:                                 Commands accepted by the GiD command.exe.
* model unit:                            Unit System file.
* Mouse:                                 Mouse operations.
* Move:                                  Move.
* Move node:                             Move node.
* Move point:                            Move point.
* MPEG files:                            Animation.
* Multiple lines intersection:           Intersection multiple lines.
* Multiple surfaces intersection:        Intersection Multiple surfaces.
* Multiple values return commands:       Multiple values return commands.
* Multiple views:                        Multiple windows.
* Multiple windows:                      Multiple windows.
* NASTRAN read:                          NASTRAN read.
* Ndime:                                 Single value return commands.
* Nelem:                                 Single value return commands.
* New:                                   New.
* New material:                          New material.
* New postprocess mesh format:           File ProjectName.post.msh - ProjectName.flavia.msh.
* New postprocess results format:        File ProjectName.post.res - ProjectName.flavia.res.
* Nlocalaxes:                            Single value return commands.
* Nmats:                                 Single value return commands.
* Nnode:                                 Single value return commands.
* NodesCoord:                            Multiple values return commands.
* NodesLayerName:                        Single value return commands.
* NodesLayerNum:                         Single value return commands.
* NodesNum:                              Single value return commands.
* Normal in surface option:              Option normal in surface.
* Normal projection:                     Perspective.
* Npoin:                                 Single value return commands.
* NURBS line conversion:                 Convert to NURBS.
* NURBS line creation:                   NURBS line creation.
* NURBS line edition:                    Edit NURBS line.
* NURBS surface creation:                NURBS surface creation.
* NURBS surface edition:                 Edit NURBS surface.
* NURBS surface hole:                    Hole NURBS surface.
* Object axes rotation:                  Rotate object axes.
* Offset:                                Copy.
* OnlyInCond:                            Specific commands.
* OnlyInLayer:                           Specific commands.
* Open project:                          Open.
* Operation:                             Single value return commands.
* Option Arc center:                     Option Arc center.
* Option base in points:                 Button Base.
* Option normal in surface:              Option normal in surface.
* Option point in line:                  Option point in line.
* Option point in surface:               Option point in surface.
* Option tangent in line:                Option tangent in line.
* Output view:                           showing feedback when runing the solver.
* Pan (graphical):                       Pan.
* Parallel lines. NURBS surface:         NURBS surface creation.
* Parametric line:                       Parametric line.
* Parasolid read:                        Parasolid read.
* particle tracing:                      Stream Lines.
* Perspective:                           Perspective.
* Perspective projection:                Perspective.
* Planar surface creation:               Planar surface creation.
* Point (show):                          Id.
* Point creation:                        Point creation.
* Point definition:                      Point definition.
* Point enter window:                    Coordinates window.
* Point in line option:                  Option point in line.
* Point in surface option:               Option point in surface.
* point options:                         Point and Line options.
* Points:                                Point definition.
* Points rotation:                       Rotate points.
* polygon:                               Object.
* Polyline creation:                     Polyline creation.
* Post-processing change light vector:   Display Style.
* Post-processing culling:               Display Style.
* Post-processing cut planes:            Do Cuts.
* Post-processing cuts:                  Do Cuts.
* Post-processing data files:            POSTPROCESS DATA FILES.
* Post-processing divide:                Do Cuts.
* Post-processing Do Cuts:               Do Cuts.
* Post-processing Fast-rotation:         Display Style.
* Post-processing Make a cut:            Do Cuts.
* Post-processing opaque:                Display Style.
* Post-processing render:                Display Style.
* Post-processing select meshes/sets/cuts: Display Style.
* Post-processing transparent:           Display Style.
* Postprocess Files:                     POSTPROCESS DATA FILES.
* Postprocess Files (Old mesh format):   old mesh format.
* Postprocess Files (Old results format): old results format.
* Postprocess introduction:              POSTPROCESS OPTIONS.
* postprocess utilities:                 utilities - postprocess.
* Postprocessing no results:             postprocessing results.
* Postprocessing results:                postprocessing results.
* PRB file example:                      Example Problem and intervals data file creation.
* Preferences:                           Preferences.
* Print to file:                         Print to file.
* prism:                                 Object.
* Problem and intervals data:            Problem and intervals data file.
* Problem and intervals file example:    Example Problem and intervals data file creation.
* Problem data:                          Problem data.
* Problem information:                   List.
* Problem Type:                          Customization.
* Problem type:                          Problem type.
* Problem Type Files:                    Configuration Files.
* Process function:                      process function.
* ProjectName.flavia.msh:                File ProjectName.post.msh - ProjectName.flavia.msh.
* ProjectName.flavia.res:                File ProjectName.post.res - ProjectName.flavia.res.
* ProjectName.post.msh:                  File ProjectName.post.msh - ProjectName.flavia.msh.
* ProjectName.post.res:                  File ProjectName.post.res - ProjectName.flavia.res.
* Quadratic:                             Quadratic.
* Quadratic9:                            Quadratic.
* Quality of the mesh:                   Mesh quality.
* Quit:                                  Quit.
* radius:                                Dimensions.
* Read ACIS:                             ACIS read.
* Read batch window:                     Read batch window.
* Read DXF:                              DXF read.
* Read IGES:                             IGES read.
* Read NASTRAN:                          NASTRAN read.
* Read Parasolid:                        Parasolid read.
* Read project:                          Open.
* Read saved project:                    Files.
* Read Shapefile:                        Shapefile read.
* Read STL mesh:                         STL mesh read.
* Read surface mesh:                     Read surface mesh.
* Read VDA:                              VDA read.
* Read View:                             Save/Read View.
* reading post-process files:            files - postprocess.
* Realformat:                            Specific commands.
* Redraw (graphical):                    Redraw.
* Rem:                                   Commands accepted by the GiD command.exe.
* remove:                                Specific commands.
* Remove elements:                       Delete elements.
* Remove lonely nodes:                   Delete lonely nodes.
* Rename:                                Commands accepted by the GiD command.exe.
* Render:                                Render.
* Renumber:                              Renumber.
* Repair:                                Repair.
* Reset mesh data:                       Reset mesh data.
* Result entry, Result block:            Result Block.
* Result group:                          Result Group.
* result groups:                         Result Group.
* results example:                       Results example.
* Results file:                          File ProjectName.post.res - ProjectName.flavia.res.
* Results Range Table, Result Range Table: Result Range Table.
* results visualization:                 postprocessing results.
* Rotate (graphical):                    Rotate.
* Rotate angle:                          Rotate angle.
* Rotate center:                         Rotate center.
* Rotate object axes:                    Rotate object axes.
* Rotate original view:                  Rotate original view.
* Rotate points:                         Rotate points.
* Rotate screen axes:                    Rotate screen axes.
* Rotate trackball:                      Rotate trackball.
* Rotation:                              Copy.
* Rounded arc:                           Arc tangents.
* Save:                                  Files.
* Save as:                               Save as.
* Save ASCII project:                    Save ASCII project.
* Save configuration file:               Save configuration file.
* Save ON layers:                        Save ON layers.
* Save project:                          Save.
* Save View:                             Save/Read View.
* saving binary results:                 files - postprocess.
* saving boundaries:                     files - postprocess.
* saving cuts:                           files - postprocess.
* saving graphs:                         files - postprocess.
* saving in binary format:               files - postprocess.
* saving post-process files:             files - postprocess.
* scalar diagram:                        Line Diagrams.
* Scalar result format:                  old results format.
* Scale:                                 Copy.
* Screen axes rotation:                  Rotate screen axes.
* Script file:                           Batch file.
* Search entities:                       Signal.
* Search volume:                         Volume creation.
* select meshes/sets/cuts:               Display Style.
* Selecting points:                      Entities selection.
* selection filter:                      Selection window.
* selection window:                      Selection window.
* Sequence of commands:                  Macros window.
* Set:                                   Specific commands.
* Set command:                           Commands accepted by the GiD command.exe.
* Set Layer:                             Specific commands.
* setting contour fill colors:           Contour Fill.
* Settings:                              Preferences.
* several results:                       Several results.
* Shapefile read:                        Shapefile read.
* Shift:                                 Commands accepted by the GiD command.exe.
* Shortcut, keyboard:                    Macros window.
* show min max:                          Show Minimum and Maximum.
* Signal entities:                       Signal.
* Simplify NURBS:                        Simplify NURBS.
* Single value return commands:          Single value return commands.
* Size of mesh:                          Assign unstruct sizes.
* smooth contour fill:                   Smooth Contour Fill.
* Solver:                                Calculate.
* Spacing:                               Assign unstruct sizes.
* Special functions:                     special functions.
* Specific commands:                     Specific commands.
* sphere:                                Object.
* Spherical coordinates:                 Spherical coordinates.
* Status:                                Status.
* STL mesh read:                         STL mesh read.
* stream lines:                          Stream Lines.
* structured concentrate:                Structured concentrate.
* Structured mesh:                       Structured mesh.
* Surface (4-sided):                     4-sided surface creation.
* Surface (planar):                      Planar surface creation.
* Surface boolean operations:            Surface boolean operations.
* surface intersection:                  Surface boolean operations.
* Surface mesh read:                     Read surface mesh.
* Surface surface intersection:          Intersection Surface surface.
* Surface-lines intersection:            Intersection Surface lines.
* Surfaces normals:                      Draw surface normals.
* Surfaces normals sense swap:           Draw surface normals.
* SurfMesh edition:                      Edit SurfMesh.
* Swap arcs:                             Swap arcs.
* Symbols file example:                  Example Symbols File creation.
* Symbols geometrical definitions:       Conditions symbols file.
* table mesh example:                    Mesh example.
* Table results example:                 Results example.
* Tangent in line option:                Option tangent in line.
* Tcl:                                   Specific commands.
* TCL Functions:                         Control functions.
* TCL Info Function:                     info function.
* TCL menu functions:                    Managing menus.
* TCL Process Function:                  process function.
* TCL Special functions:                 special functions.
* TCL-TK extension:                      TCL-TK extension.
* TCL-TK extension creation example:     Detailed example - TCL-TK extension creation.
* TECPLOT:                               files - postprocess.
* Template File (.bas):                  Template File.
* Template file example:                 Detailed example.
* Template file. Description:            General description.
* text data report:                      Text data report.
* texture:                               Textures.
* textures:                              Textures.
* Three-sided surface creation:          4-sided surface creation.
* TIFF sequence:                         Animation.
* Time:                                  Single value return commands.
* Title:                                 Special fields.
* Toolkit icons:                         User interface.
* Trackball rotation:                    Rotate trackball.
* Transform problem type:                Transform problem type.
* Translation:                           Copy.
* Trimmed NURBS surface:                 NURBS surface creation.
* Type:                                  Commands accepted by the GiD command.exe.
* Type of element:                       Element type.
* Unassign condition:                    Unassign condition.
* Unassign material:                     Unassign material.
* Uncollapse:                            Uncollapse.
* Undo:                                  Undo.
* Unit field:                            Special fields.
* unit system:                           Unit System file.
* Units:                                 Single value return commands.
* Up menus:                              Escape.
* Update problem type:                   Internet Retrieve.
* User basics:                           User basics.
* User interface:                        User interface.
* Using this manual:                     Using this manual.
* Utilities:                             Utilities.
* Var:                                   Specific commands.
* Variables:                             Preferences.
* VDA read:                              VDA read.
* vector diagram:                        Line Diagrams.
* Vector result format:                  old results format.
* version:                               GiD version.
* View:                                  View.
* View entities:                         Entities.
* View geometry:                         View geometry.
* View mesh:                             Mesh view.
* View Results window:                   postprocessing results.
* Views, several:                        Multiple windows.
* Visualization:                         View.
* visualization troubles:                Invoking GiD.
* Volume automatic:                      Automatic 6-sided volumes.
* Volume boolean operations:             Volume boolean operations.
* Volume creation:                       Volume creation.
* volume intersection:                   Volume boolean operations.
* Window Configuration file:             Save configuration file.
* Windows:                               User interface.
* windows state:                         Graphical.
* Word oriented:                         Command line.
* Write calculation file:                Calculation file.
* Write DXF:                             DXF write.
* Write IGES:                            IGES write.
* Write using template file:             Using template.
* Writing data input files:              General description.
* Zoom:                                  Zoom.



Tag Table:
Node: Top153
Node: Introduction7082
Node: Using this manual9163
Node: GiD basics10552
Node: Invoking GiD16915
Node: User interface19386
Node: Mouse operations22391
Node: Command line23355
Node: User basics24296
Node: Point definition24642
Node: Picking in the graphical window25922
Node: Entering points by coordinates26467
Node: Local/global coordinates27471
Node: Cylindrical coordinates29133
Node: Spherical coordinates29722
Node: Selecting an existing point30285
Node: Button Base31271
Node: Option point in line31781
Node: Option point in surface32111
Node: Option tangent in line32464
Node: Option normal in surface32833
Node: Option Arc center33205
Node: Entities selection33485
Node: Quit37758
Node: Escape38010
Node: Files38639
Node: New39012
Node: Open39336
Node: Save39673
Node: Save as40631
Node: Import40984
Node: IGES read41284
Node: DXF read43023
Node: Parasolid read43786
Node: ACIS read44607
Node: VDA read44892
Node: Shapefile read45556
Node: NASTRAN read45811
Node: STL mesh read47377
Node: Mesh read47716
Node: Read surface mesh50305
Node: Batch file51143
Node: Insert geometry53748
Node: Export54098
Node: IGES write54350
Node: DXF write54796
Node: GiD mesh55067
Node: Text data report55327
Node: Save ASCII project55875
Node: Save ON layers56377
Node: Calculation file56821
Node: Using template57724
Node: Print to file58593
Node: About59429
Node: View59639
Node: Zoom60277
Node: Rotate61637
Node: Rotate screen axes62136
Node: Rotate object axes62957
Node: Rotate trackball63782
Node: Rotate angle64387
Node: Rotate points64899
Node: Rotate center65313
Node: Rotate original view65734
Node: Pan66056
Node: Redraw66409
Node: Render66735
Node: Label67620
Node: Entities68360
Node: Layers68718
Node: Save/Read View72909
Node: Background image73183
Node: Multiple windows73876
Node: Geometry74165
Node: View geometry74457
Node: Create74706
Node: Point creation75355
Node: Line creation75878
Node: Arc creation76872
Node: Arc tangents78093
Node: NURBS line creation78427
Node: Polyline creation80685
Node: Parametric line82104
Node: Planar surface creation82837
Node: 4-sided surface creation84420
Node: 4-sided surface automatic creation87230
Node: NURBS surface creation87788
Node: Volume creation91613
Node: Automatic 6-sided volumes92963
Node: Contact creation93330
Node: Intersection95986
Node: Intersection line-line96326
Node: Intersection multiple lines97400
Node: Intersection Surface 2 points97852
Node: Intersection Surface lines98478
Node: Intersection Surface surface99029
Node: Intersection Multiple surfaces99572
Node: Volume boolean operations99814
Node: Surface boolean operations100653
Node: Object101279
Node: Delete102240
Node: Edit102855
Node: Move point103238
Node: Explode polyline103783
Node: Edit polyline104182
Node: Edit NURBS line105267
Node: Edit NURBS surface106951
Node: Hole NURBS surface108782
Node: Divide109185
Node: Join lines end points111554
Node: Swap arcs112259
Node: Edit SurfMesh112757
Node: Convert to NURBS113142
Node: Simplify NURBS113429
Node: Utilities113797
Node: Preferences114517
Node: Renumber124487
Node: Calculator125511
Node: Id125860
Node: Signal126363
Node: List126956
Node: Status127343
Node: Distance127517
Node: Draw line normals127706
Node: Draw surface normals128388
Node: Copy129809
Node: Move134474
Node: Repair134968
Node: Collapse135260
Node: Uncollapse136790
Node: Undo137190
Node: Comments137500
Node: Graphical138029
Node: Coordinates window139126
Node: Read batch window140846
Node: Clip planes141835
Node: Save configuration file142610
Node: Perspective142958
Node: Change Light Vector143356
Node: Macros window143957
Node: Selection window144548
Node: Animate controls147082
Node: Dimensions148663
Node: Data149992
Node: Problem type150882
Node: Transform problem type151966
Node: Internet Retrieve152576
Node: Conditions153142
Node: Assign condition153947
Node: Draw condition155805
Node: Unassign condition156658
Node: Materials157248
Node: Assign material157864
Node: Draw material158644
Node: Unassign material159091
Node: New material159374
Node: Import/Export material160000
Node: Problem data160538
Node: Intervals161069
Node: Interval data162315
Node: Local axes162769
Node: Meshing164199
Node: Generate165833
Node: Mesh view167073
Node: View boundaries167477
Node: Assign unstruct sizes167909
Node: Draw Sizes172620
Node: Structured mesh173153
Node: Structured concentrate175581
Node: Mesh criteria176237
Node: Element type176671
Node: Quadratic178201
Node: Reset mesh data178669
Node: Cancel mesh179137
Node: Mesh quality179356
Node: Edit mesh181296
Node: Move node181567
Node: Delete elements181823
Node: Delete lonely nodes182652
Node: Calculate183038
Node: POSTPROCESS OPTIONS184578
Node: introduction - postprocess184890
Node: files - postprocess187278
Node: utilities - postprocess189812
Node: Point and Line options192954
Node: Display Style194744
Node: Textures195059
Node: Cover mesh196794
Node: postprocessing results197588
Node: Contour Fill199859
Node: Smooth Contour Fill204062
Node: Contour Ranges204886
Node: Contour Lines205294
Node: Show Minimum and Maximum205948
Node: Display vectors206412
Node: Iso Surface209533
Node: Stream Lines211270
Node: Line Diagrams214010
Node: Legends215887
Node: Graphs216727
Node: Graph Lines Description216930
Node: Graph Lines Options218415
Node: Graph Lines File Format219789
Node: Deform Mesh220894
Node: Do Cuts222771
Node: Animation227922
Node: Automatic comments230720
Node: Several results232431
Node: Customization232992
Node: Introduction - ProblemType233250
Node: Configuration Files237764
Node: Conditions file238356
Node: Example Conditions File creation244314
Node: Materials file248060
Node: Example Materials File creation251777
Node: Problem and intervals data file253948
Node: Example Problem and intervals data file creation256298
Node: Conditions symbols file257789
Node: Example Symbols File creation259622
Node: Unit System file264221
Node: Special fields266291
Node: Template File270946
Node: General description273294
Node: Commands used in the .bas file277952
Node: Single value return commands278254
Node: Multiple values return commands286205
Node: Specific commands293570
Node: Detailed example313431
Node: Executing an external program344480
Node: Commands accepted by the GiD command.exe346753
Node: showing feedback when runing the solver357945
Node: Managing errors358684
Node: Shell script examples359658
Node: POSTPROCESS DATA FILES360818
Node: File ProjectName.post.msh - ProjectName.flavia.msh364480
Node: Mesh example367568
Node: File ProjectName.post.res - ProjectName.flavia.res370410
Node: Gauss Points372080
Node: Result Range Table376403
Node: Result Block378690
Node: Result Group384321
Node: Results example393996
Node: old results format399033
Node: Gauss Points - Old format408411
Node: old mesh format411788
Node: File ProjectName.flavia.msh old414660
Node: File ProjectName.flavia.bon old418199
Node: File ProjectName.flavia.dat old421622
Node: TCL-TK extension425619
Node: Control functions428680
Node: process function429122
Node: info function430181
Node: special functions451552
Node: Managing menus453074
Node: HTML support458483
Node: GiD version459473
Node: Using EXEC in GiD460657
Node: Detailed example - TCL-TK extension creation461304
Node: INDEX466737

End Tag Table
