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: 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: About,  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 2000).
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 *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: About,  Next: Print to file,  Prev: Export,  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: Print to file,  Next: Read image,  Prev: About,  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 97:' Writes a VRML model file with the current visualization.

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


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

Read image
==========

   An image can be used as background of GiD for visualization purposes
and then it will be fitted into GiD's window, with the option `As
background'.

   Or it can be used to be digitalized with the option `Real size'.
Then 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.

   *Note*: To leave the default background from the menu bar, the option
'`Utilities' / `Graphical' / `Default background'' can be used.


File: gid.info,  Node: Geometry,  Next: Data,  Prev: Files,  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.


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

Create
======

   Generation of all the different possible geometrical entities.

* 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::.).  Before entering the last point of the polygon, it is
compulsory to press `LastPoint'.

   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-cT1 ] 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::.).

   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 or
in the layer where the maximum number of surface contour lines lie.

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

   * `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. Also, if all
     lines lie in a plane, it is possible to select the boundary lines
     and the interior lines defining holes at the same time.
     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 either in the current layer or in the layer where the
     maximum number of surface contour lines lie.
     *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:

     If the set of closed lines that are inside the surface define two
     new surfaces, then, these two new surfaces will be created and the
     old one deleted:

     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:


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


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.

   When a volume is created, GiD supplies information about its
approximate size.

   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' or `prism', 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::.).

   Options:

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

   * Weight change: 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
     calculate that have a better advance of the knots list related to
     the control points.


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.

   * Weight change: 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 divide into two where the parametric variable takes that value.
     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.


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.

   Lines which have higher entities above them or have conditions
assigned (*note Conditions::.), cannot be converted. For example, if a
surface is created over some lines, it is necessary to erase the
surface before converting the lines.


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.

