INDEX

Cimne's copyrighted CustomLib is developed between CIMNE and Compass Ingenieria y Sistemas http://www.compassis.com, and it is the library included in GiD for creating advanced customized problemtypes, i.e. adaptations to third-party simulation codes or e

This document shows an example about the access to the data stored in the customlib tree. We are using the cmas2d_customlib tree as example. The customlib tree is stored in a xml document. To manage an xml object, we use the tdom functions, available in h

GiD_AccessValue ?-index? set|get ?-default? material|condition|intvdata|gendata ?<name>? <question> ?<attribute>? <value> To get or set some field values of materials, interval data or general data: if -index is specified then the material or condition nu

GiD_AccessValueAssignedCondition ?-field_index? set|get <condition> <over> {<question>|<field_index> ?<value>? ... <question>|<field_index> ?<value>?} <entities> To get or set field values of conditions applied over entities: <condition> is the name of th

The following section is of purely practical nature. It contains examples of the most common functions from the areas CustomLib deals with. Example: Using functions based on Interpolated Data The linear interpolation uses two or more pairs of input data p

CustomLib also allows to enter square matrices of order n automatically. The Matrix Editor window is opened by locating in the data tree the field to modify, and choosing the edit button (e.g. [x]) as follows, image2021-6-9_17-24-25.png This will open the

To learn how to configure GiD for a particular type of analysis, you can find some practical examples: By following the tutorial of the chapter Defining a problem type of the GiD user manual. By studing and modifing some existing Problem Types Problem typ

From version 13 of GiD, a new system of problem types has been developed, which offers several advantages compared with the old (classic) system: it organizes better the data, provides with a more intuitive and user-friendly GUI, enable more sophisticated

Use in your module the same image as GiD use In order to use an image that GiD use, you must use the tcl function gid_themes::GetImage, to see a complete list of images available you can take a look for example to the folder: (GiD Folder)\themes\GiD_class

GiD_AssignData material|condition <name> <over> ?<values>? <entities> To assign materials or conditions over entities: <name> is the name of the material or condition. In case of material it is allowed a numeric index (0 for not assigned material) <over>

GiD_Project backup To allow save/read the model in a backup fast format GiD_Project backup save <name> To save as <name> the model. (name without the .gid extension) GiD_Project backup read <name> To read the model <name>, saved with backup-fast format

GiD_Project batchfile To handle the batch file where processed commands are recorded GiD_Project batchfile get name It returns the file name of the batch, associated to the current model GiD_Project batchfile flush To force flush in the file (e.g. to read

The postprocess binary format is strongly based in the ascii format. Each line of the Mesh and Result headers are stored as a 4-byte integer with the length of the string followed by the 0-terminated string-line. Mesh coordinates, connectivities and resul

<blockdata> Represents a set of properties with some kind of relationship. A 'blockdata' field can copy itself, to duplicate and create several sets. It can contain the following fields: <value>, <container>, <condition>, <function>, <dependencies>, and o

GiD_Book material|condition create|set|exists To create or know if a book of materials or conditions exists, or to set its current book. Books are like a container to visually separe materials or conditions in submenus and different windows GiD_Book mater

GiD_Event_BeforeWriteCalculationFile: will be called just before writing the calculation file. It is useful for validating some parameters. If it returns -cancel- as a value then nothing will be written. file: the name of the output calculation file. proc

This command is only valid for preprocess GiD_Cartesian get|set ngridpoints|boxsize|corner|dimension|coordinates|iscartesian|auto_calculated <values> To get and set cartesian grid properties ngridpoints: the number of values of the grid axis on each direc

This functions are based on the implementation of a problemtype for the Frame3DD http://frame3dd.sourceforge.netsolver, but can be useful to anyone. Basic and advanced tcl commands for writing the input file - example How to write a string. See how we pri

The keywords are as follows: % Shift Rem Chdir (Cd) Del (Delete, Erase) Copy Rename (Ren, Move) Mkdir (Md) Set Echo If Call Goto : Type Unknown instructions will be executed as from an external file. Not all the possible parameters and modifiers available

List of bas commands: (all these commands must be prefixed by a character *) Add Break Clock Cond CondElemFace CondHasLocalAxes CondName CondNumEntities CondNumFields ElemsCenter ElemsConec ElemsLayerName ElemsLayerNum ElemsMat ElemsMatProp ElemsNnode Ele

See source code of gid_themes package inside the scripts folder. gid_themes::GetThemes Return the list of available themes Example: gid_themes::GetThemes -> GiD_black GiD_classic GiD_classic_renewed GiD_Set Theme(Current)|Theme(Size)|Theme(MenuType)|Theme

<condition> It contains some inputs with values and can be applied to groups. For each applied group, a dependent set of values will be created that belong to that group, for this condition. A group is a category that brings together selected entities (po

GiD_Event_AfterCreateCondition: will be called just after create the condition 'name' proc GiD_Event_AfterCreateCondition { name } { } GiD_Event_BeforeDeleteCondition: will be called just before delete the condition 'name' If it returns -cancel- the mater

Files with extension .cnd contain all the information about the conditions that can be applied to different entities. The condition can adopt different field values for every entity. This type of information includes, for instance, all the displacement co

Files with the extension .sim comprise different symbols to represent some conditions during the preprocessing stage. You can define these symbols by creating ad hoc geometrical drawings and the appropriate symbol will appear over the entity with the appl

These files generate the conditions and material properties, as well as the general problem and intervals data to be transferred to the mesh, at the same time giving you the chance to define geometrical drawings or symbols to represent some conditions on

<container> This is the simplest form to group the data for improving its visualization. On the resulting window, in addition to the inputs there will be the following set of buttons: worddav579740ea63286d1d36c09639af03a63c.png It can contain the followin

GiD_Info postprocess get <option> The following <option> are available: contour_limits Returns the minimum and maximum value of the contour limits. Before each value, the word STD appears if the contour limit value is the default value, and USER if it is

GiD_Event_BeforeCopy/Move GiD_Event_AfterCopy/Move: will be called just before or after use copy or move tools. useof : could be GEOMETRYUSE or MESHUSE transformation : could be ROTATION, TRANSLATION, MIRROR, SCALE, OFFSET, SWEEP or ALIGN proc GiD_Event_B

GiD-Tcl special commands to create and delete materials and conditions: GiD_CreateData create|delete material|material_base|condition ... To create or delete materials or conditions: GiD_CreateData create material <basename> <name> <values> To create a ma

Create themes are only for modules that distribute they own package including GiD, or for GiD developers. If you have created a theme for GiD and want that the theme will be distributed with GiD, just contact us at: gid@cimne.upc.edu mailto:gid@cimne.upc.

In this section the Tcl/Tk (scripted) customization of the look and feel of the data windows is shown. The layout of the properties drawn in the interior of any of the data windows - either Conditions, Materials, Interval Data or Problem Data - can be cus

For using this extra functionality, just activate the CustomLibAutomatic field in the XML declaration file or load it manually by requiring the package customlib_extras The extra content on this package is: New fields added to the spd file. New functions

GiD_Event_AfterCreateCutSet: will be called just after a postprocess cut is created, providing its name proc GiD_Event_AfterCreateCutSet { name } { } GiD_Event_AfterRenameCutSet: will be called just after a postprocess cut has been renamed providing its o

GiD-Tcl special commands to manage books, materials, conditions, intervals, general data or local axes:

The fields and parameters of the main configuration file (.spd) of the data tree, are described below.

In this subsection we explain a Tcl procedure used to configure the common behaviour of Materials. We are working on providing a similar functionality for Conditions using the same interface. GiD_DataBehaviour controls properties of data windows for Mater

GiD_Event_AfterDataManagerConnect: will be called when the DataManager’s share has been mounted locally proc GiD_Event_AfterDataManagerConnect { path } { # path = Unit in windows ( Z: for instance) # path = $HOME/GiD Cloud in linux or macOS } GiD_Event_Af

GiD_Project db GiD_Project db ?-fast? read|save mesh|mesh_groups|mesh_local_axes|mesh_conditions|geometry|geometry_groups|geometry_local_axes|geometry_conditions|materials|conditions|units|render|embedded_distances <filename> Special command to read/sav

GiD_Layers create|delete|edit|get|list|window|exists|is_forbidden_name GiD_Layers create <layer> To create a new layer. <layer> must be the full name (e.g. if a layer B has as parent A then must use as fullname A//B) GiD_Layers delete <layer> To delete a

CustomLib defines its own XML tags, which clearly describes its content. For more information about this attribute, see the section Data tree fields. TDOM library The tDOM library is used by the Toolkit due to it combines high performance XML data process

GiD_Groups create|clone|delete|edit|get|list|window|exists|is_forbidden_name|draw|end_draw GiD_Groups create <group> To create a new group. <group> must be the full name (e.g. if a group B has as parent A then must use as fullname A//B) GiD_Groups clone <

GiD_Sets get To handle the definition of postprocess sets (similar to preprocess layers) GiD_Sets get color|visible|type|num_entities|id <set_name> To obtain the current value of some property: type: set type. could be 0==unknown, 1==mesh, 2==set, 3==cut

<dependencies> When a field of type 'value' changes its value 'v', the <dependencies> field allows to force a change in other values. The parameters are as follows, node - It is the xpath expression to the node that should be updated. value - Field <value

Local axes definition CustomLib lets the user to define new coordinates reference systems. Local axes can be assigned to entities using the Local axes window. Local coordinates systems of lines are defined such that the local x-axis will correspond to the

GiD_Project detach_mesh_from_geometry To discard the storage of meshes by its owning geometrical entities. This feature can become a bottleneck in some cases with a lot of geometrical entities. GiD_Project detach_mesh_from_geometry is_attached It returns

Below is an example of how to create a Template file, step by step. Note that this is a real file and as such has been written to be compatible with a particular solver program. This means that some or all of the commands used will be non-standard or inco

GiD is compiled with the Tcl/Tk libraries (the Tcl version could be seen in Help->About - More...). Remember that if the developed plugin is targeted for 32 bits, only GiD 32 bits can handle it. If the developed plugin is developed for 64 bits systems, th

GiD_Dimension create|delete|edit|get|list <num>|append <data> To create, delete, get data or list the identifiers of dimensions: <num>|append: <num> is the entity identifier (integer > 0). You can use the word 'append' to set a new number automatically. <

GiD_Event_BeforeDeleteDimension: will be called just before delete the entity, providing its number proc GiD_Event_BeforeDeleteDimension { num } { } GiD_Event_AfterCreateDimension: will be called just after create the entity, providing its number proc GiD

GiD_Info postprocess get <option> The following <option> are available: all_display_styles Returns a list of all types of display styles available. cur_display_style Returns the current display style. all_display_renders Returns a list of all types of ren

<edit_command> It adds a button in the window that allows to call a TCL procedure when necessary. The parameters are as follows, n - Name used to reference the field, especially when writing the .dat file. pn - Label that will be visualized by the user. I

First, we set the loop to the interval of the data. *loop intervals The next couple of lines indicate the starting of one section and the title of the example, taken from the first field in the interval data with an abbreviation on the label. They are fol

Now we want to output the desired results to the output file. The first line should be a title or a label as this lets the solver know where a loop section begins and ends. The end of this block of instructions will be signalled by the line END_GEOMETRY.

GiD_EntitiesLayers assign|assign_back_layer|assign_front_layer|get|print|entity_layer To handle the entities that belong to layers GiD_EntitiesLayers assign <layer> ?-also_lower_entities? ?-also_higher_entities? <over> <selection> To assign the selection

GiD_EntitiesGroups assign|unassign|get|entity_groups To handle the entities that belong to groups Note: GiD_WriteCalculationFile could be interesting to tranverse an print data based on groups without the extra cost of GiD_EntitiesGroups serializing poten

GiD_EntitiesSets get|entity_sets To handle the entities that belong to postprocess sets (similar to preprocess layers) GiD_EntitiesSets get|entity_sets To know the entities of a set or to know the sets of an entity GiD_EntitiesSets get <set_name> nodes|el

A 'Event procedure' is a Tcl procedure that is invoked from GiD when doing some actions. I allows developers to interleave its code with the GiD flow. The structure of problem_type_name.tcl can optionally implement some of these Tcl prototype procedures (

GUI GiD_Event_AfterCreateTopMenus GiD_Event_AfterChangeBackground GiD_Event_ChangedLanguage GiD_Event_ChangeMainWindowTitle GiD_Event_BeforeUpdateWindow GiD_Event_BeforeSetCursor GiD_Event_BeforeSetWarnLine GiD_Event_MessageBoxModeless GiD_Event_MessageBo

Start/End GiD_Event_BeforeInitGIDPostProcess GiD_Event_InitGIDPostProcess GiD_Event_AfterSetPostModelName GiD_Event_EndGIDPostProcess GraphsSet GiD_Event_AfterCreateGraphSet GiD_Event_BeforeDeleteGraphSet GiD_Event_AfterDeleteGraphSet GiD_Event_AfterChang

New GiD_Event_AfterNewGIDProject Read GiD_Event_BeforeReadGIDProject GiD_Event_AfterReadGIDProject GiD_Event_AfterReadGIDProjectWithError GiD_Event_AfterInsertGIDProject GiD_Event_AfterSetProjectName GiD_Event_BeforeOpenFile GiD_Event_AfterOpenFile Write

Start / End GiD_Event_InitProblemtype GiD_Event_BeforeInitProblemtype GiD_Event_EndProblemtype GiD_Event_AfterChangeProblemtype GiD_Event_AfterSetProblemtypeName Read / Write GiD_Event_LoadModelSPD GiD_Event_LoadProblemtypeSPD GiD_Event_SaveModelSPD Trans

Here is an example of how to create a conditions file, explained step by step: First, you have to create the folder or directory where all the problem type files are located, problem_type_name.gid in this case. Then create and edit the file (problem_type_

Here is an example of how to create a materials file, explained step by step: Create and edit the file (problem_type_name.mat in this example) inside the problem_type_name directory (where all your problem type files are located). As you can see, except f

Here is an example of how to create a problem data file, explained step by step: Create and edit the file (problem_type_name.prb in this example) inside the problem_type_name directory (where all your problem type files are located). Except for the extens

Here is an example of how to create a symbols file. Create and edit the file (problem_type_name.sim in this example) inside the problem_type_name directory (where all your problem type files are located). Except for the extension, the names of the file an

Here are two examples of easy scripts to do. One of them is for Unix/Linux machines and the other one is for MS-Dos or Windows. UNIX/Linux example: #!/bin/sh basename = $1 directory = $2 ProblemDirectory = $3 # OutputFile: "$1.log" # ErrorFile: "$1.err" r

Once all the problem type files are finished (.cnd, .mat, .prb, .sim, .bas files), you can run the solver. You may wish to run it directly from inside GiD. To do so, it is necessary to create the file problem_type_name.bat in the Problem Type directory. T

The main procedures available to be used in the TCL files, are listed below. All the usages and examples can be found on the 'cmas2d_customlib' problemtype. customlib::InitWriteFile filename Open the file for writing customlib::EndWriteFile customlib::Ini

GiD offers the following customization features: Complete menu´s can be customised and created to suit the specific needs of the user´s simulation software. Simple interfaces can be developed between the data definition and the simulation software. Simple

GiD_File fopen|fclose|fprintf|fflush|list To allow print data from a Tcl procedure with standard fprintf command, specially to write the calculation file from Tcl or a mix of .bas template and Tcl procedures GiD_File fopen <filename> ?<access>? Open a fil

When a module is loaded from inside GiD, module can not control theme configuration. But if you are installing GiD together with your module, there is a variable inside scripts/ConfigureProgram.tcl to control how GiD manage themes. The variable is ::GidPr

As with the previous section, this block of code begins with a title for the subsection: $ NODAL COORDINATES followed by the header of the output list: $ NODE COORD.-X COORD.-Y COORD.-Z Now GiD will trace all the nodes of the model: *loop nodes For each n

<function> Main function field, which contains a function variable field called <functionVariable>. It permits to create or edit a function defined by points for a determined field. e.g. for a property variable with the temperature. It can contain the fol

Inside the GiD_PostImportFile function, following functions can be called to pass information to GiD: extern "C" int GiD_NewPostProcess( void); extern "C" int GiD_NewMesh( _t_gidMode gid_mode, _t_gidMeshType mesh_type, const char *name); extern "C" int Gi

<functionVariable> It allows to define the default values of a function defined by xy points. The parameters are as follows, n - Name used to reference the field, especially when writing the .dat file. pn - Label that will be visualized by the user. It ca

If Gauss points are to be included, they must be defined before the Result which uses them. Each Gauss points block is defined between the lines GaussPoints and End GaussPoints. The structure is as follows, and should: Begin with a header that follows thi

All the rules that apply to filename.bas files are also valid for other files with the .bas extension. Thus, everything in this section will refer explicitly to the file filename.bas. Any information written to this file, apart from the commands given, is

GiD_Event_AfterCreatePoint/Line/Surface/Volume: will be called just after create the entity, providing its number proc GiD_Event_AfterCreatePoint { num } { } proc GiD_Event_AfterCreateLine { num } { } proc GiD_Event_AfterCreateSurface { num } { } proc GiD

This example consists on a simple cylinder, like the one shown on the right. It contains points, curves of type straight lines, circumference arcs and curved NURBS with circumference shape, and surfaces of the types planar, Coon and NURBS with cylindrical

DESCRIPTION OF THE FORMAT There are two versions of the <modelname>.geo GiD format: Binary (used by GiD by default) and ASCII. This chapter describes the format of the geometry ASCII file. During the development of the program, the backward compatibility

GiD_Geometry -v2 ?-no_model? create|delete|get|list|edit|exists point|line|surface|volume <num>|append <data> To create, delete, get data or list the identifiers of geometric entities: <num>|append: <num> is the entity identifier (integer > 0). You can us

classify_connected_parts GiD_Tools geometry classify_connected_parts <entity_type> <entity_ids> ?<forced_separator_ids>? To split the input items of <entity_ids> in one or several parts where the entities of the part are connected Two entities are assumed

gid-256.png GiD The universal, adaptative and user friendly pre and postprocessing system for computer analysis Customization Manual Developers Miguel Pasenau de Riera Enrique Escolano Tercero Abel Coll Sans Adrià Melendo Ribera Anna Monros Bellart Javier

This is a particular mechanism of plugin, different of the Tcl-plugin, and it only allows to import mesh and results in postprocess, and require to compile a special dll with our rules. Note that 'GiD dynamic libraries' are different of 'Tcl loadable libr

The version of GiD is returned by GiD_Info gidversion Normally, a problem type requires a minimum version of GiD to run. Because the problem type can be distributed or sold separately from GiD, it is important to check the GiD version before continuing wi

GiD_Info AutomaticTolerance This command returns the value of the Import Tolerance used in the project. This value is defined in the Preferences window under Import.

GiD_Info bounding_box ?-geometry|-mesh|-post? ?-layers_off_also? ?point|line|surface|volume <entity_id>? This command returns a list {x_min x_max y_min y_max z_min z_max} of the bounding box that contains the visualized model with the current settings (on

GiD_Info check This command returns some specialized entities check. The result for each argument is: line | surface | volume | mesh: Type of entity. <entity_id>: The number of an entity. isclosed: For lines: 1 if start point is equal to end point, 0 othe

GiD_Info conditions over_point | over_line | over_surface | over_volume | over_layer | over_group (problemtype classic only) This command returns a list of the conditions in the project. One of the arguments over_point, over_line, over_surface, over_volum

GiD_Info Coordinates ?-no_model? <point_id>|<node_id> [geometry|mesh] This command returns the coordinates (x,y,z) of a given point or node. If -no_model flag is specified then entities are stored in a special container, it doesn't belong to the model

GiD_Info events ?-deprecated? ?-args <event_name>? GiD_Info events This command returns a sorted list with the names of the GiD Tcl event procedures, that could be implemented by a problemtype. These events are automatically undefined when the problemtype

GiD_Info <option> Tcl command used to obtain information about the current GiD project. This function provides any information about GiD, the current data or the state of any task inside the application. Depending on the arguments introduced after the GiD

GiD_Info gendata This command returns the information entered in the Problem Data window (see Problem and intervals data file (.prb)). The following options are available: [otherfields]: It is possible to add this option to get the additional fields from

GiD_Info Geometry This command gives the user information about the geometry in the project. For each entity, there are two possibilities: [NumPoints]: Returns the total number of points in the model. [NumLines]: Returns the total number of lines. [NumSur

GiD_Info GiDbits If GiD is a x32 binary executable, then this command returns 32. If GiD is a x64 binary executable, then this command returns 64.

GiD_Info GiDVersion This command returns the GiD version number. For example 10.0.8

GiD_Info graphcenter This command returns the coordinates (x,y,z) of the center of rotation.

GiD_Info intvdata (problemtype classic only) This command returns a list of the interval data in the project (see Problem and intervals data file (.prb)). The following options are available: -interval <number>: To get data from an interval different from

GiD_Info IsPointInside GiD_Info IsPointInside ?-no_model? ?-tolerance <tol>? Line|Surface|Volume <num> {<x> <y> <z>} This commands returns 1 if the point {x y z} is inside the specified volume/surface/curve, or 0 if lies outside. If -no_model flag is spec

GiD_Info layers This command returns a list of the layers in the project.These options are also available: <layer_name>: If a layer name is given, the command returns the properties of that layer. -on: Returns a list of the visible layers. -off: Returns a

GiD_Info library To access to information of some linked libraries (e.g. gid mesh libraries) GiD_Info library names This command returns a list of libraries GiD_Info library version <library_name> This command returns a string with the version of the code

GiD_Info list_entities GiD_Info list_entities ?-no_model? Status|PreStatus|PostStatus If -no_model flag is specified then entities are stored in a special container, it doesn't belong to the model This command returns a list with general information about

GiD_Info ListMassProperties ?-no_model? Points|Lines|Surfaces|Volumes|Nodes|Elements <entity_id> If -no_model flag is specified then entities are stored in a special container, it doesn't belong to the model This command returns properties of the selected

GiD_Info localaxes ?<name>? ?-localaxesmat? GiD_Info localaxes Returns a list with all the user defined local axes. GiD_Info localaxes <name> Returns a list with 2 items: the euler angles "e1 e2 e3" and the center "cx cy cz" that define the local axes cal

(problemtype classic only) GiD_Info magnitudes 0|1 ?<magnitude_name> units? Return information about units and the conversion factor between units of a magnitude. GiD_Info magnitudes 0|1 GiD_Info magnitudes 0 return a list with the available default magni

GiD_Info materials (problemtype classic only) This command returns a list of the materials in the project. GiD_Info materials(<bookname>) returns only the materials that belong to the book <bookname>) These options are also available: <material_name>: If

GiD_Info Mesh This command gives the user information about the selected mesh in the project. Without arguments it returns 1 if there is mesh, followed by a list with all types of element used in the mesh. ?-pre | -post? -step_index <step_index> | -step_v

GiD_Info MeshQuality This command returns a list of numbers. These numbers are the Y relative values of the graph shown in the option Meshing -> Mesh quality (see MESH>Mesh Quality from Reference Manual) and two additional real numbers with the minimum an

GiD_Info OpenGl Returns information about the Opengl/glew version and renderer.

GiD_Info ortholimits This command returns a list (Left, Right, Bottom, Top, Near, Far, Ext) of the limits of the geometry in the project. In perspective mode near and far have the perspective distance substracted.

GiD_Info postprocess get <option> The following <option> are available: pagedimensions: Returns the settings that are applied when an image is sent to the printer or a snapshot is taken. Returns (in inches) pagewidth, leftmargin, topmargin, imgwidth, imgh

GiD_Info parametric This command returns geometric information (coordinates, derivates, etc.) about parametric lines or surfaces. For lines it has the following syntax: GiD_Info parametric ?-no_model? line <entity_id> coord|deriv_t|deriv_tt|t_fromcoord|t_

GiD_Info perspectivefactor This command returns which perspective factor is currently being used in the project.

GiD_Info postprocess get This command returns information about the GiD postprocess.

GiD_Info problemtypepath This command returns the absolute path to the current problem type.

GiD_Info Project <item>? This command returns information about the project. More precisely, it returns a list with: Problem type name. Current model name. 'There are changes' flag. Current layer to use. Active part (GEOMETRYUSE, MESHUSE, POSTUSE or GRAPH

GiD_Info unitssystems ?gid|prj|usersys|modunit|prbsys|udstate|magused? (problemtype classic only) return information about the sytems of units GiD_Info unitssystems return 1 if the problemtype is using units, 0 else GiD_Info unitssystems gid|prj|usersys|m

GiD_Info variables ?-expand_array_names? ?-mesh? ?<variable_name>? GiD_Info variables It returns a sorted list of the GiD variables, including the ones related to meshing Note: For array-like names it only return the base name, the array names can be obta

GiD_Info view This command returns the current view parameters. Something like: {x -13.41030216217041 13.41030216217041} {y 10.724431991577148 -10.724431991577148} {z -30.0 30.0} {e 10.0} {v 0.0 0.0 0.0} {r 1.0} {m 1.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0

GiD_Mesh create|delete|edit|get|list|exists To create, delete, modify, list or know information about mesh nodes or elements of the preprocess: create: to create a new node or element GiD_Mesh create node <num>|append <x y z> <num>|append: <num> is the id

GiD_MeshPost create <mesh_name> <element_type> <element_num_nodes> ?-zero_based_array? <node_ids> <node_coordinates> <element_ids> <element_connectivities> ?<radius+?normals?>? ?<r g b a>? To create a postprocess mesh. This command create all mesh nodes a

GiD_MeshPre create <layer_name> <element_type> <element_num_nodes> ?-zero_based_array? <node_ids> <node_coordinates> <element_ids> <element_connectivities> ?<radius+?normals?>? To create a preprocess mesh. This command create all mesh nodes and elements i

GiD_Process command_1 command_2 ... Tcl command used to execute GiD commands. This is a simple function, but a very powerful one. It is used to enter commands directly inside the central event manager. The commands have the same form as those typed in the

GiD_Graph clear|create|delete|edit|exists|get|hide|list|show To create, delete or get postprocess graphs: All commands accept an optional parameter <graphset_name>, else the current graphset is assumed. clear?<graphset_name>?: delete all graphs in GiD; cr

GiD_Event_AfterCreateGraph: will be called when a new graph is created proc GiD_Event_AfterCreateGraph { name } { } GiD_Event_BeforeDeleteGraph: will be called just before delete the graph 'name' If it returns -cancel- the deletion is cancelled. proc GiD_

The graph file that GiD uses is a standard ASCII file. Every line of the file is a point on the graph with X and Y coordinates separated by a space. Comment lines are also allowed and should begin with a '#'. The title of the graph and the labels for the

GiD_GraphSet create|current|delete|edit|exists|list To create, delete or get postprocess graphs sets: A graphset is a container of graphs sharing the same x, y axes create ?<graphset_name>?: creates a new graph set. If the name is not provided an automati

GiD_Event_AfterCreateGraphSet: will be called when a new graphset is created proc GiD_Event_AfterCreateGraphSet { name } { } GiD_Event_BeforeDeleteGraphSet: will be called just before delete the graphset 'name' If it returns -cancel- the deletion is cance

GiD_Info postprocess get <option> See also the more modern commands Graphs and GraphSets The following <option> are available: all_graphs Returns a list of all graphs. all_line_graphs Returns a list of the line graphs. all_graphs_views: Returns all availa

If the same meshes are used for all the analyses, the following section can be skipped. A new concept has been introduced in Postprocess: Group, which allows the postprocessing of problems which require re-meshing or adaptive meshes, where the mesh change

<group_type> Main configuration field of the group types. pn - Label that will be visualized by the user. It can be translated. default - It is a boolean value as a 1 or 0 that indicates the default group type. auto_from_bc - It is a boolean value as a 1

GiD_Event_AfterCreateGroup: similar to layer commands proc GiD_Event_AfterCreateGroup { name } { } GiD_Event_AfterRenameGroup: proc GiD_Event_AfterRenameGroup { oldname newname } { } GiD_Event_BeforeDeleteGroup: will be called just before delete the group

<groups_types> Represents the types of groups. It can contain the following fields: <group_type> The parameters are as follows, editable - It is a boolean value as a 1 or 0 that indicates if the entry could be changed or not. If it is activated (1) the en

<groups> Initial groups field. It is always an empty field in the .spd file.

GiD_Event_AfterCreateTopMenus: will be called just after creating the top menus. proc GiD_Event_AfterCreateTopMenus { } { } GiD_Event_AfterChangeBackground: will be called just after change some background property, like color, direction or image. proc Gi

In HDF5 the postprocess information is stored in several groups. You can always look at the structure of GiDPost hdf5 format with the freely available HDFView utility of the HDFGroup and which can be found at https://support.hdfgroup.org/products/java/ ht

With HelpDirs we can specify which of the subdirectories will be internal nodes of the help tree. Moreover, we can specify labels for the nodes and a link to load when a particular node is clicked. The link is relative the node. For instance: HelpDirs {ht

Problem type developers can take advantage of the internal HTML browser if they wish to provide online help. The GiDCustomHelp procedure below is how you can show help using the new format: GiDCustomHelp ?args? where args is a list of pairs option value.

Parameter called allow_import in fields of type <blockdata>allows to add the 'Import/export materials' item in the contextual menu for a specific 'blockdata' field. A material is composed by a set of material properties, which can be applied to geometry e

The recognized import plug-ins appear in the top menu bar under the menu Files->Import→Plugins: worddav29c07999724408509dab93f4aa584639.png These dynamic libraries can be manually loaded and called via TCL scripts, in GiD post-process's command line, or u

It's used to join diferent parts of the spd file. It must contain the following attributes: path: relative path, from the problemtype folder It can contain the following attributes: active: Specifies if the part must be added in the final All attributes w

If we specify a topic index by IndexPage, we can take advantage of the search index. In IndexPage we can provide a set of html index pages along with the structure type of the index. The type of the index could be: <DIR> <LI> ... </DIR> (default) <UL> <LI

From GiD 11, a themes system has been integrated inside GiD. In the following chapters, how to manage and use these system is explained in order to get a full integrated look of your module. A theme contain: visual aspect as colors and shape of toolbars a

GiD_IntervalData <mode> ?<number>? ?copyconditions? To create, delete or set interval data; <mode> must be 'create', 'delete' or 'set'; <number> is the interval number (integer >=1). Create returns the number of the newly created interval and can optional

GiD_Event_AfterCreateInterval: will be called just after a new interval is created, providing its integer id proc GiD_Event_AfterCreateInterval { interval_id } { } GiD_Event_BeforeDeleteInterval: will be called just before a interval is deleted, providing

When GiD is to be used for a particular type of analysis, it is necessary to predefine all the information required from the user and to define the way the final information is given to the solver module. To do so, some files are used to describe conditio

As the variety of existent formats worldwide is too big to be implemented in GiD and, currently, the number of supported formats for mesh and results information in GiD is limited, the GiD team has implemented a new mechanism which enables third party lib

GiD_Info postprocess get <option> The following <option> are available: iso_all_display_styles Returns a list of all available display styles for isosurfaces. iso_cur_display_style Returns the current display style for isosurfaces. iso_all_display_renders

GiD_Event_AfterCreateLayer: will be called just after create the layer 'name' proc GiD_Event_AfterCreateLayer { name } { } GiD_Event_AfterRenameLayer: will be called just after the layer 'oldname' has been renamed to 'newname' proc GiD_Event_AfterRenameLa

GiD_Info postprocess get <option> The following <option> are available: comments Returns the comments that appear in different results views. info_legend Returns the current values showed in the legend. legends_state Returns the current values in Postproc

GiD_Event_AfterChangeLicenceStatus: will be called when the licence status of GiD changes. Possible status could be "academic", "professional" or "temporallyprofessional" proc GiD_Event_AfterChangeLicenceStatus { status } { }

GiD_Info postprocess get <option> The following <option> are available: A 'line diagram' is basically a graph drawn in the local axis of the line elements, used for example to represent in bars graphs of bending moments, shear and axial efforts, etc. cur_

New file *.post.lst can be read into GiD, postprocess. This file is automatically read when the user works in a GiD project and changes from pre to postprocess. This file can also be read with File→Open The file contains a list of the files to be read by

The plug-in examples provided by GiD also include some little models of the provided import format. These are the import plug-ins provided by GiD so far: OBJ: Wavefront OBJ format This is a starter example which includes the create_demo_triangs function w

Special GiD commands related to local axis gid_groups_conds::local_axes_window This Tcl procedure open a window to handle local axis assigned to entities correct_local_axes_with_lines nodes|elements <groupList> <groupLinesList> To use this command must ap

GiD_LocalAxes <mode> <name> ?<type>? <Cx Cy Cz> <PAxex PAxey PAxez> <PPlanex PPlaney PPlanez>? To create, delete or modify local axes: <mode>: must be one of "create|delete|edit|exists", which correspond to the operations: create, delete, edit or exists;

GiD_Event_AfterLogin: will be called when the login status of GiD changes. It provide the logged username proc GiD_Event_AfterLogin { username } { } GiD_Event_AfterLogout: will be called when the username logout. proc GiD_Event_AfterLogout { } { } GiD_Eve

The main procedures available to be used in the TCL files, are listed below. gid_groups_conds::actualize_conditions_window This procedure updates the information of the whole data tree, and automatically refresh data shown in the user interface. If the da

GiD_Info postprocess get <option> The following <option> are available: It is possible to display two copies of the geometry, the main one (where results are drawn), and a refererence one. Main geometry main_geom_state Returns whether the main geometry is

A line of code like For Windows rem ErrorFile: %1.err For Linux/UNIX # ErrorFile: "$1.err" included in the .bat file means that the given filename is the error file. At the end of the execution of the .bat file, if the errorfile does not exist or is zero,

GiD offers you the opportunity to customize the pull-down menus. You can add new menus or to change the existing ones. If you are creating a problem type, these functions should be called from the InitGIDProject or InitGIDPostProcess functions (see TCL AN

GiD_Event_AfterCreateMaterial: will be called just after create the material 'name' proc GiD_Event_AfterCreateMaterial { name } { } GiD_Event_AfterRenameMaterial: will be called just after the mateial 'oldname' has been renamed to 'newname' proc GiD_Event

Files with the extension .mat include the definition of different materials through their properties. These are base materials as they can be used as templates during the Preprocessing step for the creation of newer ones. You can define as many materials

This section deals with outputting a materials listing. As before, the first lines must be the title of the section and a commentary: MATERIAL PROPERTIES $ MATERIAL PROPERTIES FOR MULTILAMINATE Next there is the loop sentence, this time concerning materia

GiD_Event_BeforeMeshGeneration: will be called before the mesh generation. It receives the mesh size desired by the user as the element_size argument. This event can typically be used to assign some condition automatically. If it returns -cancel- the mesh

GiD_MeshData size|size_by_chordal_error|size_background_mesh|size_correct|unstructured|mesher|structured|semi_structured|boundary_layer|element_type|mesh_criteria|reset To assign mesh data to geometrical entities GiD_MeshData size points|lines|surfaces|vo

GiD_Info postprocess get <option> The following <option> are available: border_criteria Returns the value of border angle option. Select the angle criteria between faces to consider the shared edge a boundary edge, i.e. sharp edge, or not. Angles between

This example clarifies the description: #mesh of a table MESH "board" dimension 3 ElemType Triangle Nnode 3 # color 127 127 0 Coordinates # node number coordinate_x coordinate_y coordinate_z 1 -5 3 -3 2 -5 3 0 3 -5 0 0 4 -2 2 0 5 -1.66667 3 0 6 -5 -3 -3 7

Note: This postprocess mesh format requires GiD version 6.0 or higher. Comments are allowed and should begin with a '#'. Blank lines are also allowed. To enter the mesh names and result names in another encoding, just write # encoding your_encoding for ex

mass_properties GiD_Tools mesh mass_properties <tetrahedra_ids> | -boundary_elements <triangle_ids> To calculate the mass properties of volume, gravity center and inertia tensor of a volume, defined by a selection of tetrahedra or the selection of the tri

GiD_ModifyData ?-book? material|condition|intvdata|gendata|localaxes ?<name>? <values> To change all field values of materials, interval data or general data: <name> is the material name or interval number; <values> is a list of all the new field values f

These commands return more than one value in a prescribed order, writing them one after the other. All of them except LocalAxesDef are able to return one single value when a numerical argument giving the order of the value is added to the command. In this

GiD_Event_AfterNewGIDProject: will be called just after start a new GiD project. proc GiD_Event_AfterNewGIDProject {} { }

As for previous sections, the first thing to do set the conditions. *Set Cond Point-Load *nodes As in the previous section, the next loop will only be executed if there is a condition in the selection. *if(CondNumEntities(int)>0) Here begins the loop over

First, we set the necessary conditions, as was done in the previous section. *Set Cond Surface-Constraints *nodes *or(1,int) *or(3,int) *Add Cond Line-Constraints *nodes *or(1,int) *or(3,int) *Add Cond Point-Constraints *nodes *or(1,int) *or(3,int) NPRES=

GiD_OpenGL register|unregister|registercondition|unregistercondition|draw|drawtext|project|unproject|get|doscrzoffset|drawentity|pgffont This command is a Tcl wrapper of some OpenGL functions. It allows to use OpenGL commands directly from GiD-Tcl. For ex

GiD_Event_AfterProcess: will be called just after GiD has finished the process of 'words' and the word is consumed (the parameter is_view==1 if the command is a view function, like a rotation of the view, pan,...). This event could be interesting for some

The following <option> are available: changed_analysis_step Returns 1 if the analysis step has changed from the last query, 0 if has not changed. changed_results_view Returns 1 if the results view has changed from the last query, 0 if has not changed. cha

GiD_Set ?-meshing_parameters_model? ?-default|-array_names? <varname> ?<value>? This command is used to set or get GiD variables. GiD variables can be found through the Right buttons menu under the option Utilities -> Variables: <varname> is the name of t

This section explains a new way to expand GiD capabilities: the plug-in mechanism. Plug-ins which should be used by GiD shoud be present inside the $GID/plugins directory. There are two possible plugin mechanisms: Tcl plug-in GiD Dynamic library plug-in

In GiD Postprocess you can study the results obtained from a solver program. The solver and GiD Postprocess communicate through the transfer of files. The solver program has to write the results to a file that must have the extension .post.res and its nam

The preprocess and postprocess meshes are different objects, and there are different commands for them.

GiD_Event_AfterReadPreferences: will be called just after GiD read from the user preferences file <filename> variables (first Tcl and then C++) proc GiD_Event_AfterReadPreferences{ filename } { } GiD_Event_AfterSavePreferences: will be called just after G

The preprocess and postprocess meshes are different objects, and there are different commands for them.

Files with the extension .prb contain all the information about general problem and intervals data. The general problem data is all the information required for performing the analysis and it does not concern any particular geometrical entity. This differ

The creation of a Problem Type involves the creation of a directory located inside the \problemtypes GiD folder, with the name of the problem type and the extension .gid. Note: now it is also possible to have a /problemtypes extra folder located at the <G

A problem type is a collection of utilities, which allows the user to interact easily with them by means of a Graphical User Interface (GUI), and facilitates the definition and introduction of all the data necessary for carrying out a particular calculati

<proc> This kind of xml node allows to define a Tcl scripting procedure that could be called in other field nodes, like values. The parameters are as follows, n - Name of the proc used in other xml nodes. args - optional, it will be set as a list with all

GiD_Project batchfile | set | windows_layout | view | transform_problemtype | write_template Command including a collection of subcommands GiD_Project batchfile To handle the batch file where processed commands are recorded GiD_Project set <option> ?<valu

<PT_data> Main root field of the .spd file. It contains the version number and the name of the problem type. PT must be replaced by the problem type name. version - Internal version number. e.g. if the problemtype is named 'cmas2d_customlib' the main node

GiD_Raster create|interpolate|subsample|fillnodatavalue To create from the mesh a raster (2D grid) with a value that represents the z, and use a raster to efficiently interpolate values to other points or all points of other raster. A raster is defined wi

GiD_Event_BeforeReadGIDProject: will be called just before read a GiD project. It receives the argument filename, which is the path of the model folder, without the .gid extension. If it returns -cancel- then the reading is cancelled. proc GiD_Event_Befor

GiD_Event_LoadModelSPD: will be called when a GiD project is loaded. It receives the argument filespd, which is the path of the file which is being opened, but with the extension .spd (specific problemtype data). This path is tipically the file of the mod

Each Result block is identified by a Result header, followed by several optional properties: component names, ranges table, and the result values, defined by the lines Values and End Values. The structure is as follows and should: Begin with a result head

Results can be grouped into one block. These results belong to the same time step of the same analysis and are located in the same place. So all the results in the group are nodal results or are defined over the same gauss points set. Each Result group is

A Result Range Table is a customized legends for the Contour Ranges visualization and referenced by the Results. Each ResultRangesTable consist of a list that associate a string or keyword to a range of result values. If a Result Range Table is to be incl

GiD_Info postprocess get <option> A 'result surface' is basically a surface-graph drawn in the local axis of the surface elements (the result value represented normal to the surface) The following <option> are available: cur_result_surface_factor <results

GiD_Event_AfterLoadResults: will be called when a results file is opened in GiD Postprocess. It receives one argument, the name of the file being opened without its extension. proc GiD_Event_AfterLoadResults { file } { } Note: LoadResultsGIDPostProcess is

Here is an example of results for the table in the previous example (see Mesh example): GiD Post Results File 1.0 GaussPoints "Board gauss internal" ElemType Triangle "board" Number Of Gauss Points: 3 Natural Coordinates: internal end gausspoints GaussPoi

Note: Code developers can download the GiDpost tool from the GiD web page (https://www.gidsimulation.com/downloads/gidpost https://www.gidsimulation.com/downloads/gidpost); this is a C/C++/Fortran library for creating postprocess files for GiD in both ASC

GiD_Result create|delete|exists|get|get_nodes|gauss_point|result_ranges_table ?-array? <data> To create, delete or get postprocess results: GiD_Result create ?-array? {Result header} ?{Unit <unit_name>}? ?{componentNames name1 ...}? {entity_id scalar|vect

GiD_Info postprocess get <option> See also the more modern command Results The following <option> are available: all_analysis Returns a list of all analyses in the project. all_steps <analysis_name> Returns the list of time step values for all steps of "a

GiD_Event_SelectGIDBatFile: must be used to switch the default batch file for special cases. This procedure must return as a value the alternative pathname of the batch file. For example it is used as a trick to select a different analysis from a list of

GiD_Project set <option> ?<0|1>? To set on off or ask the current state of some options, to control the redraw and wait state of GiD: <option> could be disable_graphics|disable_windows|disable_progressbar|disable_warnline|disable_graphinput|disable_writeb

GiD_Event_AfterCreateSurfaceSet, GiD_Event_AfterCreateVolumeSet: will be called just after a postprocess set of volumes or surfaces is created, providing its name proc GiD_Event_AfterCreateSurfaceSet { name } { } proc GiD_Event_AfterCreateVolumeSet { name

GiD_Info postprocess get <option> The following <option> are available: A volumeset is basically a mesh of volume elements, a surfaceset is a mesh of surface (and line) elements. All entities of the set are of the same element type. A cut store the inform

The information about what is displayed when Output view: is pressed is also given here. To determine what will be shown, the script must include a comment line in the following form: For Windows: rem OutputFile: %1.log For Linux/Unix: # OutputFile: "$1.l

When writing a command, it is generally not case-sensitive (unless explicitly mentioned), and even a mixture of uppercase and lowercase will not affect the results. *npoin, *ndime, *nnode, *nelem, *nmats, *nintervals. These return, respectively, the numbe

Array fields Fields of conditions, problem data or materials could store an array of values, and the length of this array is not predefined, could be set at runtime. For example, if a material has a variable property (an example would be where a property

GiD add to the standard Tcl/Tk keywords some extra commands, to do specific thinks.

Control commands, etc.

GiD_Event_InitProblemtype / GiD_Event_BeforeInitProblemtype: will be called when the problem type is selected. It receives the dir argument, which is the absolute path to the problem_type_name.gid directory, which can be useful inside the routine to locat

GiD_Event_BeforeInitGIDPostProcess: will be called just before changing from pre to postprocess, and before read any postprocess file (this event can be used for example to check the results file existence and/or rename files). It has no arguments. If it

GiD_Info postprocess get <option> The following <option> are available: info_stream_line_size Returns the stream line size value. result_stream_lines_options Returns the current stream lines detail render, the color mode, the color of monochrome mode and

Assuming that html has been chosen as the base directory for the multilingual help content, the following structure is possible: html |__ en - English content |__ es - Spanish content Each content will probably have a directory structure to organize the i

The problem type is defined using a directory with the its name and a set of files. The directory with the problem type will be located in the problemtypes directory in the GiD distribution, or in a subdirectory of it. Note: now it is also possible to hav

<style> Optional item, for some GUI options The parameters are as follows, show_menubutton_search - 0 or 1: to show or hide the search button on the top of the customLib tree widget showlines - 0 or 1 : to show or hide the lines of the tree show_menubutto

<symbol> Every condition can have a symbol, that will be drawn when the user selects Draw symbols in the contextual menu that appears on user interactions such as right-mouse click operation. The symbol is defined by a field <symbol> inside the condition.

This chapter looks at the advanced features of GiD in terms of expandability and total control. Using the Tcl/Tk extension you can create script files to automatize any process created with GiD. With this language new windows and functionalities can be ad

This is a particular case of a Tcl plug-in to generate the mesh from geometric entities. It is a special case, because it require that GiD invoke our procedures while meshing, and provide the input of each geometric entity, and store the generated mesh, a

If a file with extension .tcl is located inside the GiD 'plugins' folder, with the same name as the folder containing it, then it is automatically sourced when starting GiD. To avoid source some unwanted tcl file is is also required the existence of an XM

Here is a step by step example of how to create a Tcl/Tk extension. In this example we will create the file cmas2d.tcl, so we will be extending the capabilities of the cmas2d problem type. The file cmas2d.tcl has to be placed inside the cdmas2d Problem Ty

Once you have generated the mesh, and assigned the conditions and the materials properties, as well as the general problem and intervals data for the solver, it is necessary to produce the data input files to be processed by that program. To manage this r

The problem type developer can change the way a QUESTION is displayed and if he wishes he can also change the whole contents of a window, while maintaining the basic behavior of the data set, i.e. in the Condition window: assign, unassign, draw; in the Ma

TocPage defines an html page as a table of contents for the current node (current directory). We have considered two ways of specifying a table of contents: <UL> <LI> ... </UL> (default) <DT> <DL> ... </DT> The first is the one generated by texinfo. For i

GiD_Tools geometry|mesh This GiD_Tools command pretends to have subcommands of tools specialized in some geometry or mesh tasks

GiD_Event_BeforeTransformProblemType: will be called just before transforming a model from a problem type to a new problem type version. If it returns -cancel- as a value then the transformation will not be invoked. file: the name of the model to be trans

Usually a problemtype is evolving along the time, the name and version is declared in the <problemtype>.xml file The number of the version must be increased in each released version. A model using a customLib-like problemtype will store the version in the

GiD_Project transform_problemtype <new_problemtype> To invoke a transform to update the fields of conditions, materials, etc. of a model saved with a different problemtype version to the current problemtype version. <new_problemtype> is the name of the ne

GiD_UnAssignData material|condition <name> <over> <entities> ?wherefield <fieldname> <fieldvalue>? To unassign materials or conditions of some entities: <name> is the name of the material or condition; Can use "*" to match all materials <over> must be: po

<unit> A unit of measurement is a definite magnitude of a physical quantity, defined and adopted by convention or by law, that is used as a standard for measurement of the same physical quantity. Any other value of the physical quantity can be expressed a

When GiD is installed, the file units.gid is copied within the GiD directory. In this file a table of magnitudes is defined. For each magnitude there is a set of units and a conversion factor between the unit and the reference unit. The units systems are

<unit_magnitude> It can contain the following fields: <unit> The parameters are as follows, n - Name used to reference the field, especially when writing the .dat file. pn - Label that will be visualized by the user. It can be translated. default - Defaul

<unit_mesh> Attributes n Length unit name to be used for the mesh

GiD_Event_AfterChangeModelUnitSystem: will be raised when user change the current unit system or the declared model length units. old_system and new_system are the names of the units systems before and after the change respectivelly. They could be empty "

Auxiliary procedures to convert between different unit types There are a couple of functions that are essential when writing the input file for the calculation. These functions permit the treatment of the units, and facilitates the conversion from one mea

<units_system> Unit system definition The field used to choose the unit system is special. It has the attribute units_system_definition="1", it does not contain any "v" attribute, and it contains a unique dependency related to the unit fields. n unit name

GiD_Units edit|get magnitude_units|magnitudes|model_unit_length|system ?<value>? To allow get or modify units and magnitudes. Note: units doesn't exists without load a problemtype that define them GiD_Units get magnitude_units <magnitude> Returns the list

<units> Main unit field. It can contain the following fields: <unit_magnitude> <unit_mesh> <units_system>

User preferences of the problemtype will be automatically saved/read to/from disk in a xml file named .$problem_type$version.ini, located in the same user folder as the GiD preferences. To set/get user preferences variables these procedures must be used.

The default action taken by GiD when validating a problem type password is verifying that it is not empty. When a password is considered as valid, this information is written in the file 'password.txt' which is located in the problem type directory. In or

<value> It is the main field to store data. This field allows to define an entry, or a combobox in the window. It can contain the following fields: <function>, <dependencies>, <edit_command> The parameters are as follows, n - Name used to reference the fi

GiD_Info postprocess get <option> The following <option> are available: cur_vector_factor <results_view_type> <result_name> ?<component_name>? <analysis_name> <step_value> Returns the current vector factor of the result "results_view_type" "result_name" "

GiD_Event_AfterChangeViewMode: useof: can be "GEOMETRYUSE", "MESHUSE", "POSTUSE" or "GRAPHUSE". proc GiD_Event_AfterChangeViewMode { useof } { body... } GiD_Event_GetBoundingBox: will be called when recalculating the bounding box, for example when user se

GiD_Project view <option> ?<value>? To handle view parameters <option> could be clip_planes_x|clip_planes_y|clip_planes_z|clip_planes_margin|rotation_vector|rotation_factor|rotation_matrix|rotation_center|perspective_distance|perspective_ortho_near|perspe

GiD includes a modified version of the tcl package snitwiz by Steve Casssidy. The package is called gid_wizard, and can be found inside the scripts folder. It is useful to create a step guieded GUI for your problemtype or plugin. It provides a window, wit

GiD_Event_BeforeSaveGIDProject / GiD_Event_AfterSaveGIDProject will be called just before save a GiD project. It receives the argument modelname which is the path of the model folder, without the .gid extension. If GiD_Event_BeforeSaveGIDProject returns -

GiD_Project write_template <template> <filename_out> To use a template .bas file to write an output file e.g. to export the current triangle mesh in STL format using the STL.bas template set template [file join $::GIDDEFAULT templates STL.bas] set filenam

GiD_WriteCalculationFile The command called GiD_WriteCalculationFile facilitate the creation of the output calculation file. See also Writing the input file for calculation Note: This command is provided to allow efficiency and relative flexibility writin

The command called GiD_WriteCalculationFile facilitate the creation of the output calculation file. See its syntax at WriteCalculationFile

The file problem_type.xml declare information related to the configuration of the problem type, such name, version, file browser icon, password validation or message catalog location, history news, etc. The data included inside the xml file should observe

XPath short description (see https://www.w3schools.com/xml/xpath_intro.asp https://www.w3schools.com/xml/xpath_intro.asp) Selecting XML nodes XPath uses path expressions to select nodes in an XML document. The node is selected by following a path or steps