This is gid.info, produced by Makeinfo version 3.12h from gid.texinfo.

   This is the GiD manual

   Copyright 1997-2002 CIMNE


File: gid.info,  Node: Top,  Next: Introduction,  Prev: (dir),  Up: (dir)

   TO USE THIS HELP:

     -Pick with left mouse button on colored item to go into it.
     -Use letters `p, n, u, l' as shortcuts for previous, next, up, last.
     -Use arrows `up' and `down' to go up and down in the page.
     -Use `Control-s' to make an incremental search.

* Menu:

* Introduction::
* GiD basics::
* Invoking GiD::
* User interface::
* User basics::
* Files::                               Pre-processing
* Geometry::
* Data::
* Meshing::
* View::
* Utilities::
* Calculate::                           Solving

* POSTPROCESS OPTIONS::
* postprocessing results::
* Customization::                       Customization

* POSTPROCESS DATA FILES::
* TCL-TK extension::                    Tcl-TK

* Index::

 --- The Detailed Node Listing ---

INTRODUCTION

* Using this manual::

USER INTERFACE

* Mouse operations::
* Command line::

USER BASICS

* Point definition::
* Entities selection::
* Quit::
* Escape::

Point definition

* Picking in the graphical window::
* Entering points by coordinates::
* Selecting an existing point::
* Button Base::
* Option point in line::
* Option point in surface::
* Option tangent in line::
* Option normal in surface::
* Option Arc center::

Entering points by coordinates

* Local/global coordinates::
* Cylindrical coordinates::
* Spherical coordinates::

FILES

* New::
* Open::
* Save::
* Save as::
* Import::
* Export::
* About::
* Print to file::
* Read image::

Import

* IGES read::
* DXF read ::
* Parasolid read::
* ACIS read::
* VDA read::
* NASTRAN read::
* STL mesh read::
* Mesh read::
* Read surface mesh::
* Batch file::
* Insert geometry::

Export

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

GEOMETRY

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

Create

* Point creation::
* Line creation::
* Arc creation::
* Arc tangents::
* NURBS line creation::
* Polyline creation::
* Parametric line::
* Planar surface creation::
* 4-sided surface creation::
* 4-sided surface automatic creation::
* NURBS surface creation::
* Volume creation::
* Contact creation::
* Intersection::
* Volume boolean operations::
* Surface boolean operations::
* Object::

Volume creation

* Automatic 6-sided volumes::

Intersection

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

Edit

* Move point::
* Explode polyline::
* Edit polyline::
* Edit NURBS line::
* Edit NURBS surface::
* Hole NURBS surface::
* Divide::
* Join lines end points::
* Swap arcs::
* Edit SurfMesh::
* Convert to NURBS::
* Simplify NURBS::

DATA

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

Conditions

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

Materials

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

MESHING

* Generate::
* Mesh view::
* View boundaries::
* Assign unstruct sizes::
* Draw Sizes ::
* Structured mesh::
* Structured concentrate::
* Mesh criteria::
* Element type::
* Quadratic::
* Reset mesh data::
* Cancel mesh::
* Mesh quality::
* Edit mesh::

Edit mesh

* Move node::
* Delete elements::
* Delete lonely nodes::

VIEW

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

Rotate

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

UTILITIES

* Preferences::
* Renumber::
* Calculator::
* Id::
* Signal::
* List::
* Status::
* Distance::
* Draw line normals::
* Draw surface normals::
* Copy::
* Move::
* Repair::
* Collapse::
* Uncollapse::
* Undo::
* Comments::
* Graphical::
* Coordinates window::
* Read batch window::
* Clip planes::
* Save configuration file::
* Perspective::
* Change Light Vector::
* Default background::
* Macros window::
* Selection window::
* Animate controls::
* Dimensions::

POSTPROCESS OPTIONS

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

POSTPROCESSING RESULTS

* Contour Fill::
* Contour Ranges::
* Contour Lines::
* Show Minimum and Maximum::
* Display vectors::
* Iso Surface::
* Stream Lines::
* Line Diagrams::
* Legends::
* Graphs::
* Deform Mesh::
* Do Cuts::
* Animation::
* Automatic comments::
* Several results::

POSTPROCESSING RESULTS

* Contour Fill::
* Contour Lines::
* Show Minimum and Maximum::
* Display vectors::
* Iso Surface::
* Stream Lines::
* Line Diagrams::
* Legends::

Graphs

* Graph Lines Description::
* Graph Lines Options::
* Graph Lines File Format::

CUSTOMIZATION

* Introduction - ProblemType::
* Configuration Files::
* Template File::
* Executing an external program::

Configuration Files

* Conditions file::
* Materials file::
* Problem and intervals data file::
* Conditions symbols file ::
* Unit System file::
* Special fields::

Conditions file (.cnd)

* Example Conditions File creation ::

Materials file (.mat)

* Example Materials File creation ::

Problem and intervals data file (.prb)

* Example Problem and intervals data file creation::

Conditions symbols file (.sim)

* Example Symbols File creation ::

Template File

* General description::
* Commands used in the .bas file::
* Detailed example::

Commands used in the .bas file

* Single value return commands::
* Multiple values return commands::
* Specific commands::

Executing an external program

* Commands accepted by the GiD command.exe::
* showing feedback when runing the solver::
* Managing errors ::
* Shell script examples::

POSTPROCESS DATA FILES

* File ProjectName.flavia.msh::
* File ProjectName.flavia.res::
* old results format::
* old mesh format::

New postprocess mesh format - File ProjectName.flavia.msh

* Mesh example::

New postprocess results format - File ProjectName.flavia.res

* Gauss Points::
* Result Range Table::
* Result Block::
* Results example::

Old postprocess results format

* Gauss Points - Old format::

Old postprocess mesh format

* File ProjectName.flavia.msh old::
* File ProjectName.flavia.bon old::
* File ProjectName.flavia.dat old::

Old format - File ProjectName.flavia.bon


TCL-TK EXTENSION

* Control functions::
* Managing menus::
* HTML support::
* GiD version::
* Using EXEC in GiD::
* Detailed example - TCL-TK extension creation::

Control functions

* process function::
* info function::

   CN $Revision: 1.129 $ April 2002


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

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

   GiD is an interactive graphical user interface that is used for the
definition, preparation and visualization of all the data related to a
numerical simulation. This data includes the definition of the
geometry, materials, conditions, solution information and other
parameters. The program can also generate a mesh for finite element,
finite volume or finite difference analysis and write the information
for a numerical simulation program in its correct format. It is also
possible to run the numerical simulation from within GiD and to
visualize the results from the analysis.

   GiD can be customized and configured by users so that the data
required for their own solver modules may be generated.These solver
modules may then be included within the GiD software system.

   The program works, when defining the geometry, similar to a CAD
(Computer Aided Design) system but with some differences. The most
important one is that the geometry is constructed in a hierarchical
mode. This means that an entity of higher level (dimension) is
constructed over entities of lower level; two adjacent entities will
then share the same lower level entity.

   All materials, conditions and solution parameters can also be
defined on the geometry without the user having any knowledge of the
mesh: the meshing is done once the problem has been fully defined. The
advantages of doing this are that, using associative data structures,
modifications can be made to the geometry and all other information
will automatically be updated and ready for the analysis run.

   Full graphic visualization of the geometry, mesh and conditions is
available for comprehensive checking of the model before the analysis
run is started.  More comprehensive graphic visualization features are
provided to evaluate the solution results after the analysis run. This
post-processing user interface is also customizable depending on the
analysis type and the results provided.

   A query window appears for some confirmations or selections. This
feature is also extended to the end of a session, when GiD prompts the
user to save the changes, even when the normal ending has been
superseded by closing the main window from the Window Manager, or in
most cases with incorrect exits.

* Menu:

* Using this manual::


File: gid.info,  Node: Using this manual,  Prev: Introduction,  Up: Introduction

Using this manual
=================

   This manual has been split into five clearly differentiated parts.

   It consists of a first part, General aspects, where the user can
find the program from basics.  This helps gain confidence on how to get
the maximum from the interactive actions between users and the system.

   The second part, Pre-processing, describes the pre-processing
functionality.  The users will learn how to configure a project, define
all its parts, geometry, data and mesh.

   The third part, Analysis, is related to the calculation process.
Although it will be performed by an independent solver, it forms part
of the integrated GiD system in the sense that the analysis can be run
from inside GiD.

   The fourth part, Post-processing, emphasizes aspects related to the
visualization of the results.

   The fifth part, Customization, explains how to customize the users
own files to be able to introduce and run different solver modules
according to their own requirements.

   Different kinds of fonts are used to help the users follow all the
possibilities offered by the code:
  1. `font' is used for the options found in the menus and windows.

  2. `font' is used for the windows names used in the post-processing.

  3. font is used for special references in some parts.

   Sections are referenced throughout the manual with the section
number, section name given in square brackets as [section] and the page
number.


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

GiD BASICS
**********

   GiD is a geometrical system in the sense that, having defined the
geometry, all the attributes and conditions (i.e., material
assignments, loading, conditions, etc.) are applied to the geometry
without any reference or knowledge of a mesh. Only once everything is
defined, is the meshing of the geometrical domain carried out. This
methodology facilitates alterations to the geometry while maintaining
the attributes and conditions definitions.  Alterations to the
attributes or conditions can simultaneously be made without the need of
reassigning to the geometry. New meshes can also be generated if
necessary and all the information will be automatically assigned
correctly.

   GiD also provides the option of defining attributes and conditions
directly on the mesh once this has been generated. However, if the mesh
is regenerated, it is not possible to maintain these definitions and
therefore all attributes and conditions must be then redefined.

   In general, the complete solution process can be defined as:

  1. define geometry - points, lines, surfaces, volumes.
        * use other facilities.

        * import geometry from CAD.

  2. define attributes and conditions.

  3. generate mesh.

  4. carry out simulation.

  5. view results.

   Depending upon the results in step (5) it may be necessary to return
to one of the steps (1), (2) or (3) to make alterations and rerun the
simulations.

   Building a geometrical domain in GiD is based on the following four
geometrical levels of entities: points, lines, surfaces and volumes.
Entities of higher level are constructed over entities of lower level;
two adjacent entities can therefore share the same level entity. A few
examples are given:

   * example 1: One line has two lower level entities (points), each of
     them at an extreme of the line. If two lines are sharing one
     extreme, they are really sharing the same point, which is a unique
     entity.

   * example 2: When creating a new line, what is being really created
     is a line plus two points or a line with existing points created
     previously.

   * example 3: When creating a volume, this is created over a set of
     existing surfaces which are joined to each other by common lines.
     The lines are, in turn, joined to each other by common points.

   All domains are considered in 3-dimensional space but if there is no
variation in the third coordinate (into the screen) the geometry is
assumed to be 2-dimensional for analysis and results visualization
purposes. Thus, to build a geometry with GiD, the users must first
define points, join these together to form lines, create closed
surfaces from the lines and define closed volumes for the surfaces.
Many other facilities are provided for creating the geometrical domain;
these include: copying, moving points, automatic surface creation, etc.

   The geometrical domain can be created in a series of layers where
each one is a separate part of the geometry. Any geometrical entity
(points, lines, surfaces or volumes) can belong to a particular layer.
It is then possible to view and manipulate some layers and not others.
The main purpose of the use of layers is to offer a visualization and
selection tool, but they are not used in the analysis. An example of
the use of layers might be a chair where the four legs, seat, backrest
and side arms are the different layers.

   GiD has the option of importing a geometry or a mesh that has been
created by a CAD program outside GiD. At present, this can be done via
a DXF, IGES,VDA,STL or NASTRAN interfaces available inside GiD.

   Attributes and conditions are applied to the geometrical entities
(points, lines, surfaces and volumes) using the data input menus. These
menus are specific to the particular solver that will be utilized for
the simulation and, therefore, the solver needs to be defined before
attributes are defined. The form of these menus can also be configured
for the user's own solver module, as explained below and later in this
manual.

   Once the geometry and attributes have been defined, the mesh can be
generated using the mesh generation tools supplied within the system.
Structured and unstructured meshes containing triangular and
quadrilateral surface meshes or tetrahedral and hexahedral volume
meshes may be generated. The automatic mesh generation facility
utilizes a background mesh concept for which the users are required to
supply a minimum number of parameters.

   Simulations are carried out from within GiD by using the calculate
menu.  Indeed, specific solvers require specific data that must have
been prepared previously. A number of solvers may be incorporated
together with the correct pre-processing interfaces.

   The final stage of graphic visualization is flexible in order to
allow the users to critically evaluate the results quickly and easily.
The menu items are generally determined by the results supplied by the
solver module. This not only reduces the amount of information stored
but also allows a certain degree of user customization.

   One of the major strengths of GiD is the ability for the users to
define and configure their own graphic user interface within GiD. This
is done by the users, defining first, via use of graphic windows, the
format for the data definition windows for pre-processing. The format
that GiD must use to write a file containing the necessary data in
order to run the numerical simulation program must also be defined in a
similar way. This pre-processor or data input interface will thus be
tailored specifically for the users simulation program, but using the
facilities and functionality of the GiD system.

   The user's simulation program can then be included within GiD so
that it may be run utilizing the calculate menu option.

   The third step consists of writing an interface program that
provides the results information in the format required by the GiD
graphic visualizer, thereby configuring the post-processing menus. This
post analysis interface may be included fully into the GiD system so
that it runs automatically once the simulation run has terminated.

   Details on this configuration can be found in Chapters 16 and 17.


File: gid.info,  Node: Invoking GiD,  Next: User interface,  Prev: GiD basics,  Up: Top

INVOKING GiD
************

   When starting the GiD program from a shell or script it is possible
to supply some options in the same command line.

   With
     gid -help
   the program will list the possible command line options.

   The standard UNIX command is used:
     gid [-b[{+/-}g][{+/-}i][{+/-}w] batch_file] [-h] [-p problem] [-e anything] [-n] [-n2] [-c]


   All options and `filename' are optional.  `filename' is the name of
a problem to be opened (extension `.gid' is optional)

   Options are:

   * -b batchfile executes `batch_file' as a script file (*note Batch
     file::.).
        · +/- g Enable/Disable Graphics (if -g, GiD doesn't redraw
          until the batch file has finished.)

        · +/- i Enable/Disable GraphInput (enable or disable
          peripherals while the batch file is being executed: mouse,
          keyboard, ...)

        · +/- w Enable/Disable Windows (GiD displays, or not, windows
          which require interaction with the user)

   * -h shows GiD's command line arguments.

   * -p problem loads `problem' as the type of the problem to be used
     for a new project.

   * -e anything

     can continue until the end of the line. Execute `anything' as if
     it were a group of commands entered into GiD.

   * -n runs the program without any window. It is most useful when
     used with the option `batchfile'.

   * -n2 runs the program without any window but theTk library is
     loaded. This option is useful if in you use TCL commands in a
     batch file.

   * -c conffile

     Takes window configuration from `conffile'. This file can be
     generated with option *Note Save configuration file::.

   * -openglconfig

     ( Only for Windows): this allows the user to choose between the
     accelerated OpenGL, if present, or the generic implementation, if
     the user experiences troubles using the accelerated libraries of
     the graphic card.


   Other useful options are:

     gid -compress [ -123456789ad] file_name_in file_name_out
   to compress a file, for instance to compress '`.dat'' files or new
posprocess formated data files.

   and

     gid [ -PostBinaryFormat { 1.0 / 1.1}] -PostResultsToBinary file_in file_out
   to compress Ascii results files into compressed binary ones. You can
select wether to use the binary format 1.0 or 1.1. The default, and
recommended, is the 1.1.


File: gid.info,  Node: User interface,  Next: User basics,  Prev: Invoking GiD,  Up: Top

USER INTERFACE
**************

   The user interface allows the GiD user to interact with the program.
It is composed of buttons, windows, icons, menus, text entries and
graphical output of certain information. The interface can be
configured by the user who may use as many menus and windows as
required for its application.

   The initial layout of GiD is composed of a large graphical area,
pull down menus at the top, click on menus on the right side, a command
line at the bottom left and a message window above it. The project that
is being run is written on the window header. The pull down menus and
the click on menus are utilized for fast accessing to the GiD commands.
Some of them offer a shortcut for an easier access, which is activated
by clicking at the same time the keys `Control' and the letter that is
displayed.

   The right mouse button pressed over the graphical area, opens an
on-screen menu with some visualization options. To select one of them,
use the left or right button; to quit, select the left button anywhere
outside the menu.

   First option in this menu is called `Contextual'. It will give
different options related to the current function that is being used.

   The pair of icon bars contain some facilities that also appear on
the graphical area of the window or on the menu bar.  When clicking on
the icon with the left mouse button, the corresponding command is
performed or a icon menu with several options will be shown. Whilst
when clicking the right (or center, when this exists) mouse button, a
menu with the options `help' and `configure toolbars' will appear
allowing the user to get a description of the icon or to configure the
position of the toolbars. The description apperas also when the mouse
remains quiet for a couple os seconds inside the icon.

   To configure the toolbars position and view, the Toolbars position
window can be called from `Utilities' > `Graphical' > `Toolbars' or
clicking with the right mouse button over a toolbar.
Using the Toolbars position window it is possible to enable the Right
buttons menu. These buttons should be used only by advanced users.

   The Standard bar has common options for both pre and post-processing
parts like open, take a snapshot, print, preferences, help, exit and
others.

   *Notes:*

   If windows are used to enter the data, it is generally necessary to
accept this data before closing the window. If this is not done, the
data will not be changed.

   Usually, commands and operations are invoked by using the menus or
mouse, but all the information can be typed into the command line.

   In Windows95/NT the secondary windows appear generally in top of the
main window and cannot be hiiden behind it. This mode can be changed
deselecting the `Always on top' flag in the Window system menu (press
second button over the windows bar to achieve it).

* Menu:

* Mouse operations::
* Command line::


File: gid.info,  Node: Mouse operations,  Next: Command line,  Prev: User interface,  Up: User interface

Mouse operations
================

   The left mouse button is also used to make selections, selecting
entities or opening a box (*note Entities selection::.) and to enter
points in the plane z=0 (*note Point definition::.).

   The middle mouse button is equivalent to `escape' (*note Escape::.).

   The right mouse button opens an on-screen menu with some
visualization options. To select one of them, use the left or right
button; to quit, select the left button anywhere outside the menu.

   First option in this menu is called `Contextual'. It will give
different options related to the current function that is being used.

   When the mouse is moved to different windows, depending on the
situations, different cursor shapes and colors will appear on the
screen.

   In some windows, help is achieved pressing button-2 or button-3 over
one icon.


File: gid.info,  Node: Command line,  Prev: Mouse operations,  Up: User interface

Command line
============

   All commands may be entered via the command line by typing the full
name or only part of it (long enough to avoid confusion); case is not
significant.  Any command within the right side menu can be entered by
the name given there or by a part of it. Special commands are also
available for viewing (zoom, rotation and so on) and these can be typed
or used at any time when working or from within another function. A
list of these special commands is given in `View' (*note View::.).

   Commands entered by typing are word oriented. This means that the
same operation is achieved if one writes the entire command and then
presses `enter' or if one writes a part of it, presses `enter' and then
writes the rest.

   All these typed commands can be retrieved with the use of the up (to
recover) and down arrows (to come back).


File: gid.info,  Node: User basics,  Next: Files,  Prev: User interface,  Up: Top

USER BASICS
***********

   The following features are essential to the effective use of the GiD
system. They are, therefore, described apart from the pre-processing
facilities section.

* Menu:

* Point definition::
* Entities selection::
* Quit::
* Escape::


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

Point definition
================

   Many functions inside GiD need the definition of a point to be given
by the user.  Points are the lowest level of geometrical entity and,
therefore the most commonly used. It is, consequently, important that
the user has a thorough understanding of their definition and uses.
Sometimes an existing point is required and sometimes a new or an old
point must be defined.

   All the options explained in this section are available through the
specific window of Points Definition (*note Coordinates window::.).
This window is accessed via the options `Utilities' and `Graphical' in
the title's bar. In doing so, the user can choose not only the kind of
reference system, cartesian, cylindrical or spherical, but also the
system to be used, global or local and if the origin of coordinates is
fixed or relative (new coordinates are referred to the last entered
origin point).

* Menu:

* Picking in the graphical window::
* Entering points by coordinates::
* Selecting an existing point::
* Button Base::
* Option point in line::
* Option point in surface::
* Option tangent in line::
* Option normal in surface::
* Option Arc center::


File: gid.info,  Node: Picking in the graphical window,  Next: Entering points by coordinates,  Prev: Point definition,  Up: Point definition

Picking in the graphical window
-------------------------------

   Points are picked in the graphics window in the plane z=0 according
to the coordinates viewed in the window. Depending on the activated
preferences (*note Preferences::.), if the user selects a region
located in the vicinity of an existing point, GiD asks whether it
should create a new point or if it should use the existing one.


File: gid.info,  Node: Entering points by coordinates,  Next: Selecting an existing point,  Prev: Picking in the graphical window,  Up: Point definition

Entering points by coordinates
------------------------------

   GiD offers a window for entering points in order to easily create
geometries, defining fixed or relative coordinates as well as different
reference systems, cartesian, cylindrical or spherical.

   Coordinates of the point can be entered either in the `enter points'
window or in the command line by following one of two possible formats:

  1. In the format: `x,y,z'

  2. In the format: `x y z'
        Coordinate z can be omitted in both cases.

   The following are valid examples of point definitions:

     	5.2,1.0 	5.2,1
     	8 9 2 		8 9,2

   All the points coordinates can be entered as local or global and
through different reference systems in addition to the cartesian one.

* Menu:

* Local/global coordinates::
* Cylindrical coordinates::
* Spherical coordinates::


File: gid.info,  Node: Local/global coordinates,  Next: Cylindrical coordinates,  Prev: Entering points by coordinates,  Up: Entering points by coordinates

Local/global coordinates
........................

   Local coordinates are always considered relative to the last point
that was used, created or selected.  It is possible to use the commands
`Utilities' and `Id' in order to make a reference to one point (*note
Id::.). Then, to define points using local coordinates referring to the
same point, use `Options' and `Fixed Relative' when entering each
point. The last point selected or created before using this will be the
origin of the local coordinate system. It is also possible to enter this
central point by its coordinates.

   The following are valid examples of defining points using local
coordinates:

     	example (1):
     				1,0,0
     				@2,1,0 (actual coordinates 3,1,0)
     				@0,3,0 (actual coordinates 3,4,0)
     				2,2,2
     				@1,0,3 (actual coordinates 3,2,5)
     
     	example (2):
     				1,0,0
     				Fixed Relative (when creating the point)
     				@2,1,0 (actual coordinates 3,1,0)
     				@0,3,0 (actual coordinates 1,3,0)
     				2,2,2
     				@1,0,3 (actual coordinates 2,0,3)
     
     	example (3):
     				'local_axes_name'2.3,-4.5,0.0

   The last example shows how to enter a point from a local coordinate
system called `'local_axes_name'' (any name inside the quotation marks
will fit), previously defined via the option `define local axes' (*note
Local axes::.).

   All the examples have been presented using a cartesian notation.
However, cylindrical or spherical coordinates can also be used.


File: gid.info,  Node: Cylindrical coordinates,  Next: Spherical coordinates,  Prev: Local/global coordinates,  Up: Entering points by coordinates

Cylindrical coordinates
.......................

   Cylindrical coordinates can be entered as: `r<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. If one entity is selected a second time, it becomes
deselected and its color reverts to normal.
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 `All', 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.


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

Quit
====

   Command `Quit' is used to finish the working session. If there were
changes since the last time a session was saved, GiD asks the user to
save them.


File: gid.info,  Node: Escape,  Prev: Quit,  Up: User basics

Escape
======

   The command `escape' is used for moving up a level within the right
side column menus, for finishing most commands, or for finishing
selections and other utilities. This command can be applied by:
  1. Middle button of the mouse.

  2. Key `ESC'.

  3. Button `escape' in the right side commands menu.

  4. Writing the reserved word `escape' in the command line. This is
     useful in scripts (*note Batch file::.).

   All above options give the same result.

   *Caution:* `escape' is a reserved word. It cannot be used in any
other context.


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

FILES
*****

   GiD includes the usual ways of saving and reading saved information
(`Save', `Read') and other file capabilities, such as importing
external files, saving in other formats and so on.

* Menu:

* New::
* Open::
* Save::
* Save as::
* Import::
* Export::
* About::
* Print to file::
* Read image::


File: gid.info,  Node: New,  Next: Open,  Prev: Files,  Up: Files

New
===

   `New' opens a new project with no title assigned.

   If this option is chosen from inside a project where some changes
have been introduced, GiD asks to save them before entering the new
project.  Next, a new problem without a title is begun.


File: gid.info,  Node: Open,  Next: Save,  Prev: New,  Up: Files

Open
====

   With this command, a project previously saved with `Save' (*note
Save::.) or with `Save ASCII project' (*note Save ASCII project::.) can
be open.

   Generally, there is no difference between using a project name with
the `.gid' extension or without it.


File: gid.info,  Node: Save,  Next: Save as,  Prev: Open,  Up: Files

Save
====

   `Save' a project is the way of saving all the information relative
to the project: geometry, conditions, materials, mesh, etc. onto the
disk.

   To save a project, GiD creates a directory with its name and
extension `.gid'.  Some files are written into this directory
containing all the information. Some of these files are binary and
others are ASCII. The user can then work with this project directory as
if it were a file.

   User doesn't need to write the `.gid' extension because it will be
automatically added to the directory name.

   *Caution:* Be careful if changing some files manually into the
`Project.gid' directory. If done in this way, some information may be
corrupted.

   *Advice:* It is advisable to save often to prevent losing
information.


File: gid.info,  Node: Save as,  Next: Import,  Prev: Save,  Up: Files

Save as
=======

   With this command, GiD allows the user to save the current project
with another name.

   When it is selected, an auxiliary window appears with all the
existing projects and directories to facilitate the introduction of the
project's new name and directory.


File: gid.info,  Node: Import,  Next: Export,  Prev: Save as,  Up: Files

Import
======

* Menu:

* IGES read::
* DXF read ::
* Parasolid read::
* ACIS read::
* VDA read::
* NASTRAN read::
* STL mesh read::
* Mesh read::
* Read surface mesh::
* Batch file::
* Insert geometry::


File: gid.info,  Node: IGES read,  Next: DXF read,  Prev: Import,  Up: Import

IGES
----

   With this option it is possible to read a file in IGES format,
version 5.1.

   GiD can incorporate files in IGES version 5.1 format, incorporating
most parts of the currently recognized entities.

     Entity number and type				Notes
     100	Circular arc
     102	Composite curve
     104	Conic arc			ellipse, hyperbola and parabola
     106	Copious data				forms 1, 2, 12 and 63
     108	Plane (form1 bounded)
     110	Line
     112	Parametric spline curve
     114	Parametric spline surface
     116	Point
     118     Ruled surface
     120	Surface of revolution
     122	Tabulated cylinder
     124	Transformation matrix			form 0
     126	Rational B-spline curve
     128	Rational B-spline surface
     140     Offset surface entity
     141     Bounded entity
     142	Curve on a parametric surface
     143     Bounded surface
     144	Trimmed surface
     308	Subfigure definition
     402	Associativity instance
     408	Singular subfigure instance

   The variable `ImportTolerance' (*note Preferences::.) controls the
creation of new points when an IGES file is read.  Points are therefore
defined as unique if they lie further away than this tolerance distance
from another already defined point. Curves are also considered
identical if they have the same points at their extremes and the "mean
proportional distance" between them is smaller than the tolerance.
Surfaces can also be collapsed.

   Entities that are read in and transformed are not necessarily
identical to the original entity. For example, surfaces may be
transformed into plane,into Coons or into NURBS surfaces defining their
contours and shape.


File: gid.info,  Node: DXF read,  Next: Parasolid read,  Prev: IGES read,  Up: Import

DXF
---

   With this option it is possible to read a file in DXF format,
version AutoCAD 2000.

   Mostly all the geometry in the DXF is read except the solid modeled
entities.

   A very important parameter to consider is related to how the points
must be joined.  This means that points that are close to each other
must be converted to a single point.  This is done by defining variable
ImportTolerance (*note Preferences::.).  Points closer together than
`ImportTolerance' will be considered to be a single point. Straight
lines that share both points are also converted to a single line.

   User can perform one `Collapse' (*note Collapse::.) to join more
entities.


File: gid.info,  Node: Parasolid read,  Next: ACIS read,  Prev: DXF read,  Up: Import

Parasolid
---------

   With this option it is possible to read a file in Parasolid format,
version 11.

   GiD can incorporate files in Parasolid version 11 format (ASCCI or
binary formats).

   The most usual Parasolid file extension is `.x_t' for ASCII and
`.x_b' for binary format.

   The variable `ImportTolerance' (*note Preferences::.) controls the
creation of new points when a Parasolid file is read.  Points are
therefore defined as unique if they lie further away than this tolerance
distance from another already defined point. Curves are also considered
identical if they have the same points at their extremes and the "mean
proportional distance" between them is smaller than the tolerance.
Surfaces can also be collapsed.


File: gid.info,  Node: ACIS read,  Next: VDA read,  Prev: Parasolid read,  Up: Import

ACIS
----

   With this option it is possible to read a file in ACIS format,
version 5.0.  GiD reads the ASCII version, the SAT Save File Format.
ACIS files (in ASCII) have the `.sat' extension.


File: gid.info,  Node: VDA read,  Next: NASTRAN read,  Prev: ACIS read,  Up: Import

VDA
---

   With this option it is possible to read a file in VDA format.

   A very important parameter to consider is related to how the points
must be joined.  This means that points that are close to each other
must be converted to a single point.  This is done by defining variable
`ImportTolerance' (*note Preferences::..  Points closer together than
`ImportTolerance' will be considered to be a single point. Straight
lines that share both points are also converted to a single line.

   User can perform one `Collapse' (*note Collapse::.) to join more
entities.


File: gid.info,  Node: NASTRAN read,  Next: STL mesh read,  Prev: VDA read,  Up: Import

NASTRAN mesh
------------

   With this option it is possible to read a file in the NASTRAN
format, version 68.

   GiD can read files written in NASTRAN version 68 format,
incorporating most parts of the currently recognized entities:

     Entity name					Notes
     GRID
     CBAR
     CBEAM				        translated as 2 node bars
     CELAS2					translated as 2 node bars
     CHEXA						8 or 20 nodes
     CONM2
     CORD1C
     CORD1R
     CORD1S
     CORD2C
     CORD2R
     CORD2S
     CQUAD4
     CROD					translated as 2 node bars
     CTRIA3
     CTETRA

   There are two options that can be used when reading a mesh if GiD
already contains a mesh:

   * a) Erasing the old mesh (`Erase')

   * b) Adding the new mesh to the old without sharing the nodes; the
     nodes will be    duplicated although they will occupy the same
     position in the space    (`AddNotShare').

   The properties and materials of elements are currently ignored,
because of the difficulties in associating the NASTRAN file properties
with the requirements of the analysis programs.  The user must
therefore assign the materials "a posteriori" accordingly. However, in
order to make this easier, the elements will be partitioned into
different layers each with the name PIdn, where n is the property
identity number associated with the elements as defined in the NASTRAN
file. Note that CELAS2 elements do not have associated property
identities so these will be created by default during the reading of
the file.


File: gid.info,  Node: STL mesh read,  Next: Mesh read,  Prev: NASTRAN read,  Up: Import

STL mesh
--------

   With this option it is possible to read a mesh in the STL format.
The STL binary format is also supported.

   The variable `ImportTolerance' (*note Preferences::.) controls the
creation of new points when the file is read.


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

GiD mesh
--------

   With this option it is possible to read a mesh in order to visualize
it within GiD.

   It is also possible to read a new mesh and add it to the existing
one. In this case, the user is prompted to keep the former one or join
it to the new mesh.

   The format of the file (whose name is introduced by means of the
command line or directly by getting it from the auxiliary window)
describing the mesh must have the following structure:

     mesh dimension = 3 elemtype tetrahedra nnode = 4
     coordinates
     1 0 0 0
     2 3 0 0
     3 6 0 0
     4 3 3 0
     5 3 1.5 4
     6 3 1.5 -4
     7 1.5 0 2
     end coordinates
     elements
     1 1 2 4 5 1
     2 2 3 4 5 1
     3 1 4 2 6 1
     4 2 4 3 6 1
     5 1 2 5 7 1
     end elements

   Code `nnode' means the number of nodes per element and `dimension'
can be either:

   * `2': 2 dimensions. Nodes have just two coordinates.

   * `3': 3 dimensions. Nodes have three coordinates.

   Where `elemtype' must be:

   * Linear

   * Triangle

   * Quadrilateral

   * Tetrahedra

   * Hexahedra

   Every element may have an optional number after the connectivities
definition.  This number usually defines the material type and it is
useful to divide the mesh into layers to visualize it better. GiD offers
the possibility of dividing the problem into different layers according
to the different materials through the option `Material' (*note
Layers::.).

   *Note:* The sign `=' is optional, but if it is present it is
necessary to leave a space.

   If it is necessary to enter different types of elements, every type
must belong to a different mesh. More than one mesh can be entered by
writing one after the other, all of them in the same file. The only
difference is that all meshes except the first one have nothing between
`coordinates' and `end coordinates'. They share the first mesh's
points. Example: to enter tetrahedra elements and triangle elements,

     mesh dimension = 3 elemtype tetrahedra nnode = 4
     coordinates
     1 0 0 0
     2 3 0 0
     3 6 0 0
     4 3 3 0
     5 3 1.5 4
     6 3 1.5 -4
     7 1.5 0 2
     end coordinates
     elements
     1 1 2 4 5 1
     2 2 3 4 5 1
     3 1 4 2 6 1
     4 2 4 3 6 1
     5 1 2 5 7 1
     end elements
     mesh dimension = 3 elemtype triangle nnode = 3
     coordinates
     end coordinates
     elements
     1 1 2 4 1
     2 2 3 4 1
     3 1 4 2 1
     4 2 4 3 1
     5 1 2 5 1
     end elements

