MIDAS  0.75
 All Classes Namespaces Files Functions Variables Enumerations Enumerator Friends Macros
alias.h
Go to the documentation of this file.
1 #ifndef MIDAS_ALIAS_H
2 #define MIDAS_ALIAS_H
3 
4 //* There is conflict name XMLDocument in msxml and tinyxml, see gelib/tixy2.h
5 //* This define have to be before first win32 include.
6 #define WIN32_LEAN_AND_MEAN
7 
8 #include "gelib.h"
9 #include "arrays.h"
10 #include "tinyxml2.h"
11 
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <stdarg.h>
16 
17 
24 namespace midaspace {
25 
26 //* ********************************************************************************************
27 //* ********************************************************************************************
28 //* *** *** *** *** MACROS *** *** *** ***
29 //* ********************************************************************************************
30 //* ********************************************************************************************
32 #ifndef DEBUG
33 //#define DEBUG // activate or de-activate this line or define this variable via command argument of compiler
34 #endif
35 
37 #define COLOREDOUT
38 
40 #define _NOCASE
41 
42 #ifdef _NOCASE
43 #define CASE false
44 #define STRCMP strcasecmp
45 #else
46 #define CASE true
47 #define STRCMP strcmp
48 #endif
49 
50 
51 #define ZERO 1.0e-4
52 #define ZERO_NC 1.0e-9
53 #define NAED_NO 10
54 #define NAFA_NO 20
55 #define NAEL_ED 6
56 #define NAFA_ED 6
57 #define PIconst 3.1415926535
59 
60 
61 //* ********************************************************************************************
62 //* ********************************************************************************************
63 //* *** *** *** *** INLINE FUNCTIONS *** *** *** ***
64 //* ********************************************************************************************
65 //* ********************************************************************************************
66 
67 //* ********************************************************************************************
68 //* ********************************************************************************************
69 //* *** *** *** *** CLASSES *** *** *** ***
70 //* ********************************************************************************************
71 //* ********************************************************************************************
72 class Problem;
73 
74 class ComponentGeometry;
75  class ComponentGeometry1D;
76  class ComponentGeometry2D;
77  class ComponentGeometry2Dtriangle;
78  class ComponentGeometry2Dquadrangle;
79  class ComponentGeometry3D;
80  class ComponentGeometry3Dhexahedron;
81 
82 
83 class ProblemSubject;
84  class Geometry;
85  class Model;
86  class Mesh;
87  class GeometrySubject;
88  class GeometryComponent;
89  class Point;
90  class Vertex;
91  class Node;
92  class HangingNode;
93  class RigidArmNode;
94  class Cell;
95  class Facedge;
96  class Edge;
97  class Face;
98  class Element;
99  class Gelement;
100  class PolyLine;
101  class Line;
102  class PolygonMdl;
103  class FElement;
104  class Beam;
105  class Triangle;
106  class Quadrangle;
107  class Tetrs;
108  class Brick;
109  class GeomCompSubject;
110  class PointDOFsAttributes;
111  class PointDOFsBCPM;
112  class PointDOFsRANHN;
113  class PointDOFsCondense;
114  class Atttibutes;
115  class CellAttribs;
116  class ElemAttribs;
117  class FElemAttribs;
118  class GelemAttribs;
119  class PointAttribs;
120  class RANAttribs;
121  class HNAttribs;
122  class Assign;
123  class AssignFix;
124  class AssignBC;
125  class ABC_NLoad;
126  class ABC_CELoad;
127  class ABC_CFLoad;
128  class ABC_CBLoad;
129  class Attribute;
130  class LoadTimeFunction;
131  class ProblemAnalysis;
132  class CrossSection;
133  class Material;
134  class BoundaryCond;
135 
136 class LocalCoordSystemA;
137  class LCS_pure;
138  class LCS_beam;
139 
140 
142 enum classID {
143  classVoid,
144 
145  classComponentGeometry,
146 
147  classComponentGeometry1D,
148  classComponentGeometry1Dpoly,
149 
150  classComponentGeometry2D,
151  classComponentGeometry2Dtriangle,
152  classComponentGeometry2Dquadrangle,
153  classComponentGeometry2Dpolygon,
154 
155  classComponentGeometry3D,
156  classComponentGeometry3Dhexahedron,
157  classComponentGeometry3Dtetrahedron,
158 
159  classVertex, classNode, classHangingNode, classRigidArmNode,
160  classEdge, classFace,
161  classPolyLine, classLine, classPolygonMdl,
162  classBeam, classTriangle, classQuadrangle, classBrick, classTetra,
163 
164  classModel, classMesh,
165 
166  classAttribute,
167  classProblemAnalysis, classCrossSection, classMaterial, classBoundaryCond,
168  classABC_NLoad, classABC_CELoad, classABC_CFLoad, classABC_CBLoad,
169  classElemAttribs, classGelemAttribs, classFEelemAttribs,
170  classPointAttribs, classRANAttribs, classHNAttribs
171 };
172 
173 
174 
175 //* ********************************************************************************************
176 //* ********************************************************************************************
177 //* *** *** *** *** ENUMS *** *** *** ***
178 //* ********************************************************************************************
179 //* ********************************************************************************************
180 //* automatic numbering starts with 0
181 
182 
183 //* ********************************************************************************************
184 //* *** *** *** *** PROBLEM VARIABLES *** *** *** ***
185 //* ********************************************************************************************
186 
188 enum Solver { SOL_Void , SOL_OOFEM , SOL_SIFEL , SOL_ANSYS };
189 
191 enum MeshGenerator { MGT_Void, MGT_T3d };
192 
194 enum RVType { RVT_Void,
195  RVTstrn , RVTstrs ,
196  RVTstrn_displ , RVTstrn_rotat , RVTstrs_displ , RVTstrs_rotat ,
197  RVTstrn_displ_local_main , RVTstrn_rotat_local_main , RVTstrs_displ_local_main , RVTstrs_rotat_local_main ,
198  RVTstrs_grad };
199 
201 enum VTKdataset { VTKDS_Void , VTKDS_polydata, VTKDS_unstruct };
202 
204 enum ResultTypesAtNode {
205  RTN_displacement ,
206  RTN_reaction ,
207  RTN_transpunknowns ,
208  RTN_ada_refder ,
209  RTN_ada_h_act ,
210  RTN_ada_h_new ,
211  cRTN
212 };
213 
240 enum ResultTypesAtElem {
241  //* *** MECHANICS ***
242  RTE_global_strain ,
243  RTE_global_stress ,
244  RTE_localOO_strain ,
245  RTE_localOO_stress ,
246  RTE_layered_strain ,
247  RTE_layered_stress ,
248 
249  //* SST_3dshell
250  RTE_plaststrain , // : plaststrain, N=...
251 
252  //* TRANSPORT
253  RTE_gradient , // gradient, N=NIP ; dim*nmedia
254  RTE_fluxes , // fluxes, N=NIP ; dim*nmedia
255 
256  //* ADAPTIVITY
257  RTE_ada_error_pct_l, // , percentual error local
258  RTE_ada_error_pct_g, // , percentual error global
259  RTE_ada_h_act , // , element characteristic size, actual
260  RTE_ada_h_new , // , element characteristic size, new
261  RTE_ada_normal , // , element normal vector
262  RTE_ada_eia , // , docas
263  cRTE , // count of ...
264  RTE_Void //
265 };
266 
267 //* *** STIFFNESS MATRIX TYPE ***
269 enum StiffMatrixType { SMT_Void , SMT_initial , SMT_tangent };
271 inline StiffMatrixType StiffMatrixType_i2e_SIFEL (int val)
272 {
273  switch (val) {
274  case 1: return SMT_initial; break;
275  case 2: return SMT_tangent; break;
276  default: return SMT_Void;
277  }
278 }
280 inline int StiffMatrixType_e2i_SIFEL (StiffMatrixType val)
281 {
282  switch (val) {
283  case SMT_initial: return 1; break;
284  case SMT_tangent: return 2; break;
285  default: _errorr2("Unknown stiffness matrix type %d", (int)val);
286  }
287  return 0;
288 }
289 
290 
291 //* *** LINEAR SOLVER TYPE ***
293 enum LinearSolverType { LST_Void , LST_ldl , LST_gauss };
295 inline LinearSolverType LinearSolverType_i2e_SIFEL (int val)
296 {
297  switch (val) {
298  case 1: return LST_gauss; break;
299  case 2: return LST_ldl; break;
300  // lu=3,cg=20,bicg=30,lapack_sol=100,spdirect_sol=140
301  default: return LST_Void;
302  }
303 }
305 inline int LinearSolverType_e2i_SIFEL (LinearSolverType val)
306 {
307  switch (val) {
308  case LST_gauss: return 1; break;
309  case LST_ldl: return 2; break;
310  default: _errorr2("Unknown linear solver type %d", (int)val);
311  }
312  return 0;
313 }
314 
317 inline int EntityType_type2dim_jktkT3d (long val)
318 {
319  switch (val) {
320  case 1: return 0; break;
321  case 2: return 1; break;
322  case 3: return 2; break;
323  case 4: return 3; break;
324  case 5: return 2; break;
325  case 6: return 2; break;
326  default: _errorr2("Unknown linear solver type %d", (int)val);
327  }
328  return 0;
329 }
332 inline int EntityType_dim2type_jktkT3d (int val)
333 {
334  return val + 1;
335 }
336 
338 enum SPRpatchType {
339  SPRPT_Void , //
340  SPRPT_2d //
341 };
342 
343 
344 
345 // !!!!!!!!!!!!!!!!!!!!!!!!! tady jsem skoncil s doxygen kontrolou
346 // !!!!!!!!!!!!!!!!!!!!!!!!! tady jsem skoncil s doxygen kontrolou
347 // !!!!!!!!!!!!!!!!!!!!!!!!! tady jsem skoncil s doxygen kontrolou
348 // !!!!!!!!!!!!!!!!!!!!!!!!! tady jsem skoncil s doxygen kontrolou
349 // !!!!!!!!!!!!!!!!!!!!!!!!! tady jsem skoncil s doxygen kontrolou
350 // !!!!!!!!!!!!!!!!!!!!!!!!! tady jsem skoncil s doxygen kontrolou
351 // !!!!!!!!!!!!!!!!!!!!!!!!! tady jsem skoncil s doxygen kontrolou
352 // !!!!!!!!!!!!!!!!!!!!!!!!! tady jsem skoncil s doxygen kontrolou
353 // !!!!!!!!!!!!!!!!!!!!!!!!! tady jsem skoncil s doxygen kontrolou
354 // !!!!!!!!!!!!!!!!!!!!!!!!! tady jsem skoncil s doxygen kontrolou
355 // !!!!!!!!!!!!!!!!!!!!!!!!! tady jsem skoncil s doxygen kontrolou
356 // !!!!!!!!!!!!!!!!!!!!!!!!! tady jsem skoncil s doxygen kontrolou
357 // !!!!!!!!!!!!!!!!!!!!!!!!! tady jsem skoncil s doxygen kontrolou
358 // !!!!!!!!!!!!!!!!!!!!!!!!! tady jsem skoncil s doxygen kontrolou
359 
360 //* ********************************************************************************************
361 //* *** *** *** *** PROBLEM ATTRIBUTES *** *** *** ***
362 //* ********************************************************************************************
363 //* ***
364 //* *** PROBLEM ANALYSIS ***
365 //* ***
367 enum PAGroup { PAG_Void , PAG_mechanics , PAG_transport };
369 enum PAType { PAT_Void,
370  PAT_OOFEM, PAT_SIFEL, // obecne
371  //PAT_adaptivity, // tohle musim jeste promyslet !!!!!!!!!!!! jestli drzet adaptivity nebo static + ada/yes, zatim to drzet budu, v OOFEMU bude adapt. v SIFLU stat + adapt flag
372  PAT_static_linear_adapt,// mechanics statics linear
373  PAT_static_linear, // mechanics statics linear
374  PAT_static_nonlinear, // mechanics statics nonlinear
375  PAT_dynamic_PNlDEI, // mechanics dynamic direct explicit nonlinear parallel
376  PAT_stability_linear, // mechanics stability linear
377  PAT_stationary, // transport media(heat, moisture) stationary
378  PAT_nonstationary, // transport media(heat, moisture) nonstationary linear
379  cPAT
380 };
381 
382 //* *** PROBLEM GROUP ***
383 inline PAGroup PAGroup_t2g (PAType val)
384 {
385  switch (val) {
386  case PAT_static_linear:
387  case PAT_static_linear_adapt:
388  case PAT_static_nonlinear:
389  case PAT_dynamic_PNlDEI:
390  case PAT_stability_linear: return PAG_mechanics; break;
391  case PAT_stationary:
392  case PAT_nonstationary: return PAG_transport; break;
393  default: _errorr2("Unknown problem type %d", (int)val);
394  }
395  return PAG_Void;
396 }
397 
398 //
399 inline PAType PAType_s2e_OOFEM (const char* str)
400 {
401  if (STRCMP(str, "LinearStatic") == 0) return PAT_static_linear;
402  else if (STRCMP(str, "LinearStability" ) == 0) return PAT_stability_linear;
403  else if (STRCMP(str, "NonLinearStatic") == 0) return PAT_static_nonlinear;
404  else if (STRCMP(str, "PNlDEIDynamic") == 0) return PAT_dynamic_PNlDEI;
405  else if (STRCMP(str, "Adaptlinearstatic") == 0) return PAT_static_linear_adapt;
406  else _errorr2 ("Unknown OOFEM analysis type \"%s\"", str);
407 
408  return PAT_Void;
409 }
410 //
411 inline PAType PAType_i2e_SIFEL (int val)
412 {
413  switch (val) {
414  case 1: return PAT_static_linear; break;
415  case 50: return PAT_stationary; break;
416  case 60: return PAT_nonstationary; break;
417  //case 2: return eigen_dynamics; break; //case 3: return forced_dynamics; break; //case 5: return linear_stability; break; //case 10: return nonlinear_statics; break; //case 15: return mech_timedependent_prob; break; //case 20: return earth_pressure; break; //case 30: return layered_linear_statics; break;
418  // enum problemtypet {, nonlinear_stationary_problem=51, nonlinear_nonstationary_problem=61, discont_nonstat_problem=62, discont_nonlin_nonstat_problem=63, growing_np_problem=70, growing_np_problem_nonlin=71, hermes=201};
419  default: return PAT_Void; }
420 }
421 inline int PAType_e2i_SIFEL (PAType val)
422 {
423  switch (val) {
424  case PAT_static_linear: return 1; break;
425  case PAT_stationary: return 50; break;
426  default: _errorr2("Unknown problem type %d", (int)val);
427  }
428  return 0;
429 }
430 
431 
432 //* ***
433 //* *** CROSS SECTION ***
434 //* ***
435 enum CrossSectType { CST_Void, CST_OOFEM, CST_SIFEL,
436  CST_SimpleCS, CST_LayeredCS, CST_FiberedCS,
437  CST_Truss, CST_2d, CST_3d,
438  CST_Beam,
439  CST_Rectangle, CST_Rectangle_tube,
440  CST_Circle,
441  CST_Circle_tube ,
442  CST_Circle_cable ,
443  CST_1d_rolled ,
444  cCrossSectTypes
445 };
447 //inline CrosssectType CrossSectType_s2e_OOFEM (const char* val)
448 //{
449 // if (STRCMP(val, "j2mat") == 0) return CST_j2mat;
450 // else return CST_Void;
451 //}
452 //inline const char* CrossSectType_e2s_OOFEM (CrossSectType val)
453 //{
454 // switch (val) {
455 // case CST_j2mat: return "j2mat"; break;
456 // default: _errorr2("Unknown OOFEM material %d", val);
457 // }
458 // return NULL;
459 //}
461 inline CrossSectType CrossSectType_i2e_SIFEL (int val, PAGroup pg)
462 {
463  if (pg == PAG_mechanics) {
464  switch (val) {
465  case 1: return CST_Truss; break;
466  case 10: return CST_2d; break;
467  //nocrosssection=0,csbar2d=1,csbeam2d=2,csbeam3d=4,csplanestr=10,cs3dprob=20,csnodal=40};
468  }
469  }
470  else if (pg == PAG_transport) {
471  switch (val) {
472  case 2: return CST_2d; break;
473  //enum crsectypet {nocrosssectiont=0,crsec1dt=1,crsec2dt=2,crsec3dt=3};
474  }
475  }
476  else errol;
477 
478  return CST_Void;
479 }
480 inline int CrossSectType_e2i_SIFEL (CrossSectType val, PAGroup pg)
481 {
482  if (pg == PAG_mechanics) {
483  switch (val) {
484  case CST_2d: return 10; break;
485  case CST_Truss: return 1; break;
486  case CST_3d: return 0; break;
487  default: _errorr2("Unknown cross section type %d", (int)val);
488  }
489  }
490  else if (pg == PAG_transport) {
491  switch (val) {
492  case CST_2d: return 2; break;
493  default: _errorr2("Unknown cross section type %d", (int)val);
494  }
495  }
496  else errol;
497 
498  return 0;
499 }
500 
501 
502 //* ***
503 //* *** MATERIAL ***
504 //* ***
505 enum MaterialType { MAT_Void, MAT_OOFEM, MAT_SIFEL,
506  MAT_IsoLE, MAT_IsoTrans, MAT_RIGID,
507  MAT_j2mat ,
508  cMaterialTypes
509 };
511 inline MaterialType MaterialType_s2e_OOFEM (const char* val)
512 {
513  if (STRCMP(val, "j2mat") == 0) return MAT_j2mat;
514  else if (STRCMP(val, "IsoLE") == 0) return MAT_IsoLE;
515  else return MAT_Void;
516 }
517 inline const char* MaterialType_e2s_OOFEM (MaterialType val)
518 {
519  switch (val) {
520  case MAT_j2mat: return "j2mat"; break;
521  case MAT_IsoLE: return "IsoLE"; break;
522  default: _errorr2("Unknown OOFEM material %d", val);
523  }
524  return NULL;
525 }
527 inline MaterialType MaterialType_i2e_SIFEL (int val, PAGroup pg)
528 {
529  if (pg == PAG_mechanics) {
530  switch (val) {
531  case 1: return MAT_IsoLE; break;
532  // elgmat3d=2,simplas1d=10,jflow=11,mohrcoul2d=20,mohrcoul3d=21,mohrcoulparab=22,mohrcoul=24,boermaterial=25,druckerprager=26,modcamclaymat=30,microplaneM4=50,microsimp=51,microfibro=52,simvisplas=70,lemaitr=75,scaldamage=100,scaldamagecc=101,aci=200,cebfip=202,nonlocalmod=300,nonlocplastmat=310,nonlocdamgmat=320,nonlocalmicroM4=340,graphm=400,creepbaz=500,winklerpasternak=550,consolidation=600,therisodilat=900
533  }
534  }
535  else if (pg == PAG_transport) {
536  switch (val) {
537  case 100: return MAT_IsoTrans; break;
538  // {isotransmat=100, cernyconcrete=101, nlisotransmat=102, homomat=110, lincoupledmat=120, bazantpedersen=150, pedersen=151, milly=154, kunzel=155, grunewald=156, devries=157, kunzel2=158, simplediscmat=159, concreteB=160, baroghelB=161, C60baroghelB=165, C30baroghelB=166, o30bazantB=167, C60bazantB=168, C30bazantB=169, glasgow=170, carb1mat=171, richardsmat=181, salt1mat=200, salt2mat=201, salt3mat=202, salt4mat=203, radiationmater=251, soilmat1=300, discontisotrmat=401, cementhydrmat=500, sejtkr=600, consolawf2=700};
539  }
540  }
541  else errol;
542  return MAT_Void;
543 }
544 inline int MaterialType_e2i_SIFEL (MaterialType val, PAGroup pg)
545 {
546  if (pg == PAG_mechanics) {
547  switch (val) {
548  case MAT_IsoLE: return 1; break;
549  default: break;
550  }
551  }
552  else if (pg == PAG_transport) {
553  switch (val) {
554  case MAT_IsoTrans: return 100; break;
555  default: break;
556  }
557  }
558  _errorr2("Unknown material type %d", (int)val);
559  return 0;
560 }
561 
562 
563 //* ***
564 //* *** BOUNDARY CONDITION ***
565 //* ***
566 enum BCType { BC_Void,
567  BC_OOFEM, BC_SIFEL, // obecne
568  BC_PV, // prescribed value
569  BC_NL , // nodal load
570  BC_CEL , // constant edge load
571  BC_CFL , // constant face load, it is called surface in OOFEM
572  BC_CBL, // constant body load
573  BC_DW , // dead weight
574  cBCTypes
575 };
577 inline BCType BCType_s2e_OOFEM (const char* val)
578 {
579  if (STRCMP(val, "NodalLoad") == 0) return BC_NL;
580  else if (STRCMP(val, "ConstantEdgeLoad") == 0) return BC_CEL;
581  else if (STRCMP(val, "ConstantSurfaceLoad") == 0) return BC_CFL;
582  //else if (STRCMP(val, "BoundaryCondition") == 0) return BC_BC;
583  else if (STRCMP(val, "DeadWeight") == 0) return BC_DW;
584  else return BC_Void;
585 }
587 inline const char* BCType_e2s_OOFEM (BCType val)
588 {
589  switch (val) {
590  case BC_CFL: return "ConstantSurfaceLoad"; break;
591  default: _errorr2("Unknown OOFEM boundart condition %d", val);
592  }
593  return NULL;
594 }
595 
596 
597 
598 
599 
600 
601 
602 
603 
604 
605 
606 
607 
608 
609 
610 
611 
612 //* ********************************************************************************************
613 //* *** *** *** *** ENUMS *** *** *** ***
614 //* ********************************************************************************************
615 //* *** MODEL/MESH PROCESSING ***
616 enum MMprocessing {
617  MMP_Void,
618  MMP_primary,
619  MMP_secondary,
620  MMP_RFbyHN
621 };
622 inline MMprocessing MMprocessingStoE (const char* val)
623 {
624  if (STRCMP(val, "primary") == 0) return MMP_primary;
625  else if (STRCMP(val, "secondary" ) == 0) return MMP_secondary;
626  else if (STRCMP(val, "RFbyHN" ) == 0) return MMP_RFbyHN;
627  else _errorr2 ("Unknown model mesh processing \"%s\"", val);
628  return MMP_Void;
629 }
630 
631 //* *** FINITE ELEMENT MESH FILE FORMAT ***
632 enum femFileFormat {
633  FFF_Void ,
634 
635  FFF_VTK ,
636  FFF_VTP ,
637  FFF_VTU ,
638  FFF_UNV ,
639  FFF_JKTK ,
640 
641  FFF_T3d ,
642  FFF_ANSYS ,
643  FFF_OOFEM ,
644  FFF_SIFEL ,
645 
646  FFF_MIDAS ,
647  FFF_POLYLINE ,
648  FFF_VTX ,
649 
650  FFF_MELNIK ,
651  FFF_VLNA
652 };
653 inline femFileFormat femFileFormatStoE (const char* fff)
654 {
655  if (STRCMP(fff, "vtk" ) == 0) return FFF_VTK;
656  else if (STRCMP(fff, "vtp" ) == 0) return FFF_VTP;
657  else if (STRCMP(fff, "vtu" ) == 0) return FFF_VTU;
658  else if (STRCMP(fff, "unv" ) == 0) return FFF_UNV;
659  else if (STRCMP(fff, "jktk" ) == 0) return FFF_JKTK;
660 
661  else if (STRCMP(fff, "t3d" ) == 0) return FFF_T3d;
662  else if (STRCMP(fff, "ansys" ) == 0) return FFF_ANSYS;
663  else if (STRCMP(fff, "oofem" ) == 0) return FFF_OOFEM;
664  else if (STRCMP(fff, "sifel" ) == 0) return FFF_SIFEL;
665 
666  else if (STRCMP(fff, "polyline" ) == 0) return FFF_POLYLINE;
667 
668  else if (STRCMP(fff, "melnik" ) == 0) return FFF_MELNIK;
669 
670  else _errorr2 ("Unknown fem file format \"%s\"", fff);
671  return FFF_Void;
672 }
673 inline const char* femFileFormatEtoS (femFileFormat fff)
674 {
675  switch (fff) {
676  case FFF_VTK: return "vtk"; break;
677  case FFF_VTP: return "vtp"; break;
678  case FFF_VTU: return "vtu"; break;
679  case FFF_UNV: return "unv"; break;
680  case FFF_JKTK: return "jktk"; break;
681 
682  case FFF_T3d: return "t3d"; break;
683  case FFF_ANSYS: return "ansys"; break;
684  case FFF_OOFEM: return "oofem"; break;
685  case FFF_SIFEL: return "sifel"; break;
686 
687  case FFF_POLYLINE: return "polyline"; break;
688 
689  case FFF_MELNIK: return "melnik"; break;
690  default: _errorr("Unknown fem file format in alias.h");
691  }
692  return 0;
693 }
694 
695 
696 //* *** DOFs per node ***
698 enum DOFtype { DOF_Void=0 , DOF_Dx=1 , DOF_Dy=2 , DOF_Dz=3 , DOF_Rx=4 , DOF_Ry=5 , DOF_Rz=6 , DOF_Tm=7 };
700 enum DOFsPerNode { DPN_Void ,
701  DPN_Dxy_R___ , DPN_Dxy_R__z , DPN_D__zRxy_ ,
702  DPN_DxyzR___ , DPN_DxyzRxyz ,
703  //DPN_Dx_zR_y_ ,
704  DPN_TR_1 , DPN_TR_2
705 };
706 
707 
708 inline DOFsPerNode DOFsPerNode_s2e (const char *val)
709 {
710  if (STRCMP(val, "2d" ) == 0) return DPN_Dxy_R___;
711  else if (STRCMP(val, "2dRot" ) == 0) return DPN_Dxy_R__z;
712  else if (STRCMP(val, "2dPlate") == 0) return DPN_D__zRxy_;
713  else if (STRCMP(val, "3d" ) == 0) return DPN_DxyzR___;
714  else if (STRCMP(val, "3dRot" ) == 0) return DPN_DxyzRxyz;
715  //
716  else if (STRCMP(val, "Dxy_R___") == 0) return DPN_Dxy_R___;
717  else if (STRCMP(val, "Dxy_R__z") == 0) return DPN_Dxy_R__z;
718  else if (STRCMP(val, "D__zRxy_") == 0) return DPN_D__zRxy_;
719  else if (STRCMP(val, "DxyzR___") == 0) return DPN_DxyzR___;
720  else if (STRCMP(val, "DxyzRxyz") == 0) return DPN_DxyzRxyz;
721 
722  else _errorr2 ("Unknown type of domain \"%s\"", val);
723  return DPN_Void;
724 }
725 
726 inline DOFsPerNode OOFEMdomain2DOFsPerNode (const char* od)
727 {
728  if (STRCMP(od, "2d-Truss" ) == 0) return DPN_Dxy_R___;
729  else if (STRCMP(od, "2dPlaneStress" ) == 0) return DPN_Dxy_R___;
730  else if (STRCMP(od, "3d" ) == 0) return DPN_DxyzR___;
731  else if (STRCMP(od, "2dPlaneStressRot") == 0) return DPN_Dxy_R__z;
732  else if (STRCMP(od, "2dMindlinPlate" ) == 0) return DPN_D__zRxy_;
733  else if (STRCMP(od, "3dShell" ) == 0) return DPN_DxyzRxyz;
734  //else if (STRCMP(od, "2dBeam" ) == 0) return DPN_Dx_zR_y_;
735  else if (STRCMP(od, "TranspMedium1" ) == 0) return DPN_TR_1;
736  else if (STRCMP(od, "TranspMedium2" ) == 0) return DPN_TR_2;
737  else _errorr ("Unknown OOFEM domain in alias.h");
738  return DPN_Void;
739 }
740 inline const char* DOFsPerNode2OOFEMdomain (DOFsPerNode od)
741 {
742  switch (od) {
743  case DPN_Dxy_R___: return "2dPlaneStress"; break;
744  case DPN_DxyzR___: return "3d"; break;
745  case DPN_Dxy_R__z: return "2dPlaneStressRot"; break;
746  case DPN_D__zRxy_: return "2dMindlinPlate"; break;
747  case DPN_DxyzRxyz: return "3dShell"; break;
748  //case DPN_Dx_zR_y_: return "2dBeam"; break;
749 
750  case DPN_Void: fprintf (stderr, "OOdom_Void has assigned no string");
751  default: fprintf (stderr, "Unknown OOFEM domain in alias.h");
752  }
753  return 0;
754 }
755 inline int DOFsPerNode2nDOFs (DOFsPerNode od)
756 {
757  switch (od) {
758  case DPN_Dxy_R___: return 2; break;
759  case DPN_DxyzR___: return 3; break;
760  case DPN_Dxy_R__z: return 3; break;
761  case DPN_D__zRxy_: return 3; break;
762  case DPN_DxyzRxyz: return 6; break;
763  //case DPN_Dx_zR_y_: return 3; break;
764  case DPN_TR_1 : return 1; break;
765  case DPN_TR_2 : return 2; break;
766 
767  case DPN_Void: _errorr ("OOdom_Void has assigned no nDOFs");
768  default: _errorr ("Unknown OOFEM domain in alias.h");
769  }
770  return 0;
771 }
772 inline bool DOFsPerNode2rotDOFsPresence (DOFsPerNode od)
773 {
774  switch (od) {
775  case DPN_Dxy_R___: return false; break;
776  case DPN_DxyzR___: return false; break;
777  case DPN_Dxy_R__z: return true; break;
778  case DPN_D__zRxy_: return true; break;
779  case DPN_DxyzRxyz: return true; break;
780  //case DPN_Dx_zR_y_: return true; break;
781 
782  case DPN_Void: _errorr ("OOdom_Void has assigned no string");
783  default: _errorr ("Unknown OOFEM domain in alias.h");
784  }
785  return 0;
786 }
787 inline int* DOFsPerNode2dofBCmask (DOFsPerNode od)
788 {
789  int *m = NULL;
790 
791  switch (od) {
792  case DPN_Dxy_R___: m = new int[2]; m[0]=1; m[1]=2; break;
793  case DPN_DxyzR___: m = new int[3]; m[0]=1; m[1]=2; m[2]=3; break;
794  case DPN_Dxy_R__z: m = new int[3]; m[0]=1; m[1]=2; m[2]=6; break;
795  case DPN_D__zRxy_: m = new int[3]; m[0]=3; m[1]=4; m[2]=5; break;
796  case DPN_DxyzRxyz: m = new int[6]; m[0]=1; m[1]=2; m[2]=3; m[3]=4; m[4]=5; m[5]=6; break;
797  //case DPN_Dx_zR_y_: m = new int[3]; m[0]=1; m[1]=3; m[2]=5; break;
798  case DPN_TR_1 : m = new int[1]; m[0]=1; break;
799  case DPN_TR_2 : m = new int[2]; m[0]=1; m[1]=2; break;
800 
801  case DPN_Void: _errorr ("OOdom_Void has assigned no mask");
802  default: _errorr ("Unknown DOFsPerNode");
803  }
804  return m;
805 }
806 
807 inline const char* DOFtype_i2s_ANSYS (DOFtype dt)
808 {
809  switch (dt) {
810  case DOF_Dx: return "UX"; break;
811  case DOF_Dy: return "UY"; break;
812  case DOF_Dz: return "UZ"; break;
813  case DOF_Rx: return "ROTX"; break;
814  case DOF_Ry: return "ROTY"; break;
815  case DOF_Rz: return "ROTZ"; break;
816  default: _errorr ("Unknown DOFtype");
817  }
818  return NULL;
819 }
820 inline const char* DOFtype_i2s_force_ANSYS (DOFtype dt)
821 {
822  switch (dt) {
823  case DOF_Dx: return "FX"; break;
824  case DOF_Dy: return "FY"; break;
825  case DOF_Dz: return "FZ"; break;
826  case DOF_Rx: return "MX"; break;
827  case DOF_Ry: return "MY"; break;
828  case DOF_Rz: return "MZ"; break;
829  default: _errorr ("Unknown DOFtype");
830  }
831  return NULL;
832 }
833 
834 
835 
836 //* ********************************************************************************************
837 //* *** *** *** *** ELEMENTS *** *** *** ***
838 //* ********************************************************************************************
840 enum CellGeometry { CG_Void, CG_Line, CG_PolyLine,
841  CG_Triangle, CG_Quadrangle, CG_Polygon,
842  CG_Tetrahedron, CG_Hexahedron,
843  CG_Wedge, CG_Pyramid,
844  cCG };
845 
846 
847 inline CellGeometry CellGeometry_i2e_HN (int val)
848 {
849  switch (val) {
850  case 211: return CG_Line; break; // isolinear1d
851  case 312: return CG_Triangle; break; // trianglelinear
852  case 412: return CG_Quadrangle; break; // isolinear2d
853  case 413: return CG_Tetrahedron; break; // tetrahedronlinear
854  case 813: return CG_Hexahedron; break; // isolinear3d
855  // isoquadratic1d=2, trianglequadratic=4,
856  // isoquadratic2d=6, tetrahedronquadratic=8,
857  // pyramidelinear=9, pyramidequadratic=10,
858  // vedgelinear=11, vedgequadratic=12, isoquadratic3d=14,
859  default: _errorr("Unknown cell geometry");
860  }
861  return CG_Void;
862 }
863 
864 inline CellGeometry CellGeometry_i2e_JKTK (int val)
865 {
866  switch (val) {
867  case 1: return CG_Line; break; // isolinear1d
868  case 3: return CG_Triangle; break; // trianglelinear
869  case 5: return CG_Quadrangle; break; // isolinear2d
870  case 7: return CG_Tetrahedron; break; // tetrahedronlinear
871  case 13: return CG_Hexahedron; break; // isolinear3d
872  // isoquadratic1d=2, trianglequadratic=4,
873  // isoquadratic2d=6, tetrahedronquadratic=8,
874  // pyramidelinear=9, pyramidequadratic=10,
875  // vedgelinear=11, vedgequadratic=12, isoquadratic3d=14,
876  default: _errorr("Unknown cell geometry");
877  }
878  return CG_Void;
879 }
880 inline int CellGeometry_e2i_JKTK (CellGeometry cg)
881 {
882  switch (cg) {
883  case CG_Line: return 1; break; // isolinear1d
884  case CG_Triangle: return 3; break; // trianglelinear
885  case CG_Quadrangle: return 5; break; // isolinear2d
886  case CG_Tetrahedron: return 7; break; // tetrahedronlinear
887  case CG_Hexahedron: return 13; break; // isolinear3d
888  default: _errorr("Unknown cell geometry");
889  }
890  return 0;
891 }
892 
893 inline CellGeometry CellGeometry_i2e_VTK (int val)
894 {
895  switch (val) {
896  case 3: return CG_Line; break; // VTK_LINE
897  case 4: return CG_PolyLine; break; // VTK_POLY_LINE
898  case 5: return CG_Triangle; break; // VTK_TRIANGLE
899  case 9: return CG_Quadrangle; break; // VTK_QUAD
900  case 7: return CG_Polygon; break; // VTK_POLYGON
901  case 10: return CG_Tetrahedron; break; // VTK_TETRA
902  case 12: return CG_Hexahedron; break; // VTK_HEXAHEDRON
903  // VTK_VERTEX=1 , VTK_POLY_VERTEX=2 , VTK_TRIANGLE_STRIP=6 , , VTK_PIXEL=8
904  // VTK_VOXEL=11 , , VTK_WEDGE=13 , VTK_PYRAMID=14 , VTK_QUADRATIC_EDGE=21 ,
905  // VTK_QUADRATIC_TRIANGLE=22 , VTK_QUADRATIC_QUAD=23 , VTK_QUADRATIC_TETRA=24 ,
906  // VTK_QUADRATIC_HEXAHEDRON=25
907  default: _errorr("Unknown cell geometry in alias.h");
908  }
909  return CG_Void;
910 }
911 inline int CellGeometry_e2i_VTK (CellGeometry cg)
912 {
913  switch (cg) {
914  case CG_Line: return 3; break; // VTK_LINE
915  case CG_PolyLine: return 4; break; // VTK_POLY_LINE
916  case CG_Triangle: return 5; break; // VTK_TRIANGLE
917  case CG_Quadrangle: return 9; break; // VTK_QUAD
918  case CG_Polygon: return 7; break; // VTK_POLYGON
919  case CG_Tetrahedron: return 10; break; // VTK_TETRA
920  case CG_Hexahedron: return 12; break; // VTK_HEXAHEDRON
921  default: _errorr("Unknown cell geometry in alias.h");
922  }
923  return 0;
924 }
925 
926 
927 //* ********************************************************************************************
928 //* *** *** *** *** VTK ELEMENTS *** *** *** ***
929 //* ********************************************************************************************
931 enum VTKPDtopology { VTKPD_Void=0 , VTKPD_VERTICE=1 , VTKPD_LINE=2 , VTKPD_POLYGON=3 , VTKPD_TRIANGLE_STRIP=4 };
932 
933 //* ********************************************************************************************
934 //* *** *** *** *** FINITE ELEMENT TYPE SET *** *** *** ***
935 //* ********************************************************************************************
937 enum FEApproximation { FEA_Void , // void
938  FEA_default, // default
939  FEA_linear, // linear for all
940  FEA_bilinear, // bilinear for all
941  FEA_133133 // linear, cubic, cubic, linear, cubic, cubic - beam element
942 };
944 inline FEApproximation FEApproximation_s2e (const char *val)
945 {
946  if (STRCMP(val, "linear") == 0) return FEA_linear;
947  else if (STRCMP(val, "default") == 0) return FEA_default;
948  else if (STRCMP(val, "133133") == 0) return FEA_133133;
949  else _errorr ("Unknown approximation in alias.h");
950  return FEA_Void;
951 }
952 
954 enum SStype { SST_Void,
955  SST_truss, SST_beam,
956  SST_plstress, SST_plstrain, SST_plate, SST_3dshell,
957  SST_3d,
958  SST_transp2d,
959  cSSTypes
960 };
962 inline SStype SStype_s2e (const char *val)
963 {
964  if (STRCMP(val, "planestrain") == 0) return SST_plstrain;
965  //else if (STRCMP(val, "") == 0) return ;
966  else _errorr ("Unknown approximation in alias.h");
967  return SST_Void;
968 }
969 
971 inline SStype SStype_i2e_SIFEL (int val)
972 {
973  switch (val) {
974  case 10: return SST_plstress;
975  case 11: return SST_plstrain;
976  default: return SST_Void;
977  }
978  return SST_Void;
979 }
980 inline int SStype_e2i_SIFEL (SStype val)
981 {
982  switch (val) {
983  case SST_plstress: return 10;
984  case SST_plstrain: return 11;
985  case SST_Void: _errorr("SST_Void has assigned no int");
986  default: _errorr("Unknown SIFEL stress strain state");
987  }
988  return 0;
989 }
990 
991 //* ********************************************************************************************
992 //* *** *** *** *** FINITE ELEMENT TYPE *** *** *** ***
993 //* ********************************************************************************************
995 enum FiniteElementType {
996  FET_Void,
997  //
998  FET_OOFEM_Truss2d, FET_OOFEM_Truss3d,
999  FET_OOFEM_LiBeam3d, FET_OOFEM_LiBeam3dNL, FET_OOFEM_Beam2d, FET_OOFEM_Beam3d,
1000  FET_OOFEM_TrPlaneStrain, FET_OOFEM_Quad1PlaneStrain,
1001  FET_OOFEM_TrPlaneStress2d, FET_OOFEM_PlaneStress2d,
1002  FET_OOFEM_TrPlaneStress2dRot,
1003  FET_OOFEM_Tr_Shell01, FET_OOFEM_RerShell,
1004  FET_OOFEM_LSpace, FET_OOFEM_QTrSpace,
1005  //
1006  FET_SIFEL_bar3d, FET_SIFEL_beam3d,
1007  FET_SIFEL_planeelementlt, FET_SIFEL_planeelementlq,
1008  FET_SIFEL_linearhex,
1009  FET_SIFEL_trlint,
1010  FET_SIFEL_quadlint,
1011  //
1012  FET_ANSYS_start, // for determination of number of ansys FE types
1013  FET_ANSYS_BEAM188, // klasickej beam
1014  FET_ANSYS_SHELL181, // klasickej shell
1015  FET_ANSYS_end // for determination of number of ansys FE types
1016 };
1017 
1019 struct FiniteElementTypeSet
1020 {
1021  CellGeometry cg; // cell geometry v tomto je skryto dimension and number of vertices
1022  DOFsPerNode dpn; // dofs per node v tomto je skryto byvaly rot
1023  SStype sst; // type of stress/strain state of element
1024  FEApproximation approx; // approximation
1025  int ord; // degree of polynomial aproximation on Element zatim jen nepouzivat, je to tady je abych nezapomel nektere veci az to implementovat budu
1026  FiniteElementType expltype; // explicit type of FE
1027 
1028  FiniteElementTypeSet() { this->free(); }
1029  virtual ~FiniteElementTypeSet() { }
1030 
1031  void free () { cg = CG_Void; dpn = DPN_Void; sst = SST_Void; approx = FEA_Void; expltype = FET_Void; }
1032 
1034  bool is_equal_to (const FiniteElementTypeSet fets) const
1035  {
1036  if (fets.cg == cg && fets.dpn == dpn && fets.sst == sst && fets.approx == approx && fets.expltype == expltype)
1037  return true;
1038  return false;
1039  }
1041  void beCopyOf (const FiniteElementTypeSet src)
1042  {
1043  cg = src.cg; dpn = src.dpn; sst = src.sst; approx = src.approx; expltype = src.expltype;
1044  }
1045 };
1046 
1047 
1048 //enum elemtype {bar2d=1,beam2d=2,bar3d=3,beam3d=4,beamg3d=5,barq2d=6,barq3d=7,subsoilbeam=8,beam2dsp=9,spring_1 = 10, spring_2 = 11, spring_3 = 12,spring_4 = 13, spring_5 = 14, spring_6 = 15,planeelementlt=20,planeelementqt=21,planeelementrotlt=22,planeelementlq=23,planeelementqq=24,planeelementrotlq=25,planeelementsubqt=30,planequadcontact=35,cctel=41,dktel=42,dstel=43,q4plateel=45,argyristr=46,subsoilplatetr=50,subsoilplateq=51,axisymmlt=60,axisymmlq=63,axisymmqq=64,
1049 // shelltrelem=80,shellqelem=81,lineartet=100,quadrtet=101,linearhex=102,quadrhex=103,lineartetrot=104,linearhexrot=105,linearwed=106,quadrwed=107,particleelem=200};
1050 //{barlint=200,barlintax=201,barquadt=205,barquadtax=206,trlint=210,trlaxisym=211,quadlint=215,quadquadt=216,quadlaxisym=217,quadquadtax=218,lineartett=220,linearhext=225,quadratichext=226,gen2del=300,trquadt=500,trqaxisym=501};//trquad
1051 
1053 inline FiniteElementType FET_s2e (const char* str)
1054 {
1055  if (STRCMP(str, "OOFEM_RerShell") == 0) return FET_OOFEM_RerShell;
1056  //else if (STRCMP(str, "Truss3d" ) == 0) return FET_OOFEM_Truss3d;
1057  else _errorr ("Unknown finite element type");
1058 
1059  return FET_Void;
1060 }
1062 inline FiniteElementType FETSet_si2e (const char* str, int val, Solver sol, PAGroup pg)
1063 {
1064  if (sol == SOL_OOFEM) {
1065  // truss
1066  if (STRCMP(str, "Truss2d" ) == 0) return FET_OOFEM_Truss2d;
1067  else if (STRCMP(str, "Truss3d" ) == 0) return FET_OOFEM_Truss3d;
1068  // beamy
1069  else if (STRCMP(str, "LiBeam3d" ) == 0) return FET_OOFEM_LiBeam3d;
1070  else if (STRCMP(str, "LiBeam3dNL" ) == 0) return FET_OOFEM_LiBeam3dNL;
1071  else if (STRCMP(str, "Beam2d" ) == 0) return FET_OOFEM_Beam2d;
1072  else if (STRCMP(str, "Beam3d" ) == 0) return FET_OOFEM_Beam3d;
1073  // plain strain
1074  else if (STRCMP(str, "TrPlaneStrain" ) == 0) return FET_OOFEM_TrPlaneStrain;
1075  else if (STRCMP(str, "Quad1PlaneStrain") == 0) return FET_OOFEM_Quad1PlaneStrain;
1076  // plain stress
1077  else if (STRCMP(str, "TrPlaneStress2d" ) == 0) return FET_OOFEM_TrPlaneStress2d;
1078  else if (STRCMP(str, "TrPlaneStrRot" ) == 0) return FET_OOFEM_TrPlaneStress2dRot;
1079  else if (STRCMP(str, "PlaneStress2d" ) == 0) return FET_OOFEM_PlaneStress2d;
1080  // shlell
1081  else if (STRCMP(str, "Tr_Shell01" ) == 0) return FET_OOFEM_Tr_Shell01;
1082  else if (STRCMP(str, "RerShell" ) == 0) return FET_OOFEM_RerShell;
1083  // 3d
1084  else if (STRCMP(str, "LSpace" ) == 0) return FET_OOFEM_LSpace;
1085  else if (STRCMP(str, "QTrSpace" ) == 0) return FET_OOFEM_QTrSpace;
1086  else _errorr ("Unknown OOFEM finite element");
1087  }
1088  else if (sol == SOL_SIFEL) {
1089  if (pg == PAG_mechanics) {
1090  switch (val) {
1091  case 3: return FET_SIFEL_bar3d; break;
1092  case 4: return FET_SIFEL_beam3d; break;
1093  case 20: return FET_SIFEL_planeelementlt; break;
1094  case 23: return FET_SIFEL_planeelementlq; break;
1095  case 102: return FET_SIFEL_linearhex; break;
1096  default: errol;
1097  }
1098  }
1099  else if (pg == PAG_transport) {
1100  switch (val) {
1101  case 210: return FET_SIFEL_trlint; break;
1102  case 215: return FET_SIFEL_quadlint; break;
1103  default: errol;
1104  }
1105  }
1106  else errol;
1107  }
1108  else errol;
1109 
1110  return FET_Void;
1111 }
1113 inline void FETSet_e2set (FiniteElementType fet, FiniteElementTypeSet *set)
1114 {
1115  switch (fet) {
1116  case FET_OOFEM_Truss3d: set->cg = CG_Line; set->dpn = DPN_DxyzR___; set->sst = SST_truss; set->approx = FEA_default; break;
1117  case FET_OOFEM_LiBeam3d: set->cg = CG_Line; set->dpn = DPN_DxyzRxyz; set->sst = SST_beam; set->approx = FEA_linear; break;
1118  case FET_OOFEM_Beam3d: set->cg = CG_Line; set->dpn = DPN_DxyzRxyz; set->sst = SST_beam; set->approx = FEA_default; break;
1119  case FET_OOFEM_TrPlaneStress2d: set->cg = CG_Triangle; set->dpn = DPN_Dxy_R___; set->sst = SST_plstress; set->approx = FEA_linear; break;
1120  case FET_OOFEM_TrPlaneStress2dRot: set->cg = CG_Triangle; set->dpn = DPN_Dxy_R__z; set->sst = SST_plstress; set->approx = FEA_linear; break;
1121  case FET_OOFEM_TrPlaneStrain: set->cg = CG_Triangle; set->dpn = DPN_Dxy_R___; set->sst = SST_plstrain; set->approx = FEA_default; break;
1122  case FET_OOFEM_RerShell: set->cg = CG_Triangle; set->dpn = DPN_DxyzRxyz; set->sst = SST_3dshell; set->approx = FEA_default; set->expltype = FET_OOFEM_RerShell; break;
1123  case FET_OOFEM_Tr_Shell01: set->cg = CG_Triangle; set->dpn = DPN_DxyzRxyz; set->sst = SST_3dshell; set->approx = FEA_default; break;
1124  case FET_OOFEM_PlaneStress2d: set->cg = CG_Quadrangle; set->dpn = DPN_Dxy_R___; set->sst = SST_plstress; set->approx = FEA_default; break;
1125  case FET_OOFEM_Quad1PlaneStrain: set->cg = CG_Quadrangle; set->dpn = DPN_Dxy_R___; set->sst = SST_plstrain; set->approx = FEA_default; break;
1126  case FET_OOFEM_LSpace: set->cg = CG_Hexahedron; set->dpn = DPN_DxyzR___; set->sst = SST_3d; set->approx = FEA_default; break;
1127  //
1128  case FET_SIFEL_bar3d: set->cg = CG_Line; set->dpn = DPN_DxyzR___; set->sst = SST_truss; set->approx = FEA_default; break;
1129  case FET_SIFEL_beam3d: set->cg = CG_Line; set->dpn = DPN_DxyzRxyz; set->sst = SST_beam; set->approx = FEA_default; break;
1130  case FET_SIFEL_planeelementlt: set->cg = CG_Triangle; set->dpn = DPN_Dxy_R___; set->sst = SST_Void; set->approx = FEA_default; break;
1131  case FET_SIFEL_planeelementlq: set->cg = CG_Quadrangle; set->dpn = DPN_Dxy_R___; set->sst = SST_Void; set->approx = FEA_default; break;
1132  case FET_SIFEL_linearhex: set->cg = CG_Hexahedron; set->dpn = DPN_DxyzR___; set->sst = SST_3d; set->approx = FEA_default; break;
1133  case FET_SIFEL_trlint: set->cg = CG_Triangle; set->dpn = DPN_Void; set->sst = SST_transp2d; set->approx = FEA_default; break;
1134  case FET_SIFEL_quadlint: set->cg = CG_Quadrangle; set->dpn = DPN_Void; set->sst = SST_transp2d; set->approx = FEA_default; break;
1135  default: _errorr ("Unknown finite element type");
1136  }
1137 }
1139 inline void FETSet_si2set (const char* str, int val, Solver sol, PAGroup pg, FiniteElementTypeSet *set)
1140 {
1141  FETSet_e2set (FETSet_si2e(str, val, sol, pg), set);
1142 }
1143 
1145 inline FiniteElementType FETSet_set2e (const FiniteElementTypeSet *set, Solver sol, PAGroup pg)
1146 {
1147  if (sol == SOL_OOFEM) {
1148  if ( set->cg == CG_Line && set->dpn == DPN_DxyzR___ && set->sst == SST_truss && (set->approx == FEA_linear || set->approx == FEA_default) ) { if (set->expltype != FET_Void) errol; return FET_OOFEM_Truss3d; }
1149  else if ( set->cg == CG_Line && set->dpn == DPN_DxyzRxyz && set->sst == SST_beam && set->approx == FEA_linear ) { if (set->expltype != FET_Void) errol; return FET_OOFEM_LiBeam3d; }
1150  else if ( set->cg == CG_Line && set->dpn == DPN_DxyzRxyz && set->sst == SST_beam && set->approx == FEA_default ) { if (set->expltype != FET_Void) errol; return FET_OOFEM_Beam3d; }
1151  else if ( set->cg == CG_Triangle && set->dpn == DPN_Dxy_R___ && set->sst == SST_plstress && (set->approx == FEA_linear || set->approx == FEA_default) ) { if (set->expltype != FET_Void) errol; return FET_OOFEM_TrPlaneStress2d; }
1152  else if ( set->cg == CG_Triangle && set->dpn == DPN_Dxy_R___ && set->sst == SST_plstrain && set->approx == FEA_default ) { if (set->expltype != FET_Void) errol; return FET_OOFEM_TrPlaneStrain; }
1153  else if ( set->cg == CG_Triangle && set->dpn == DPN_Dxy_R__z && set->sst == SST_plstress && (set->approx == FEA_linear || set->approx == FEA_default) ) { if (set->expltype != FET_Void) errol; return FET_OOFEM_TrPlaneStress2dRot;}
1154  else if ( set->cg == CG_Triangle && set->dpn == DPN_DxyzRxyz && set->sst == SST_3dshell && set->approx == FEA_default ) { if (set->expltype == FET_OOFEM_RerShell) return FET_OOFEM_RerShell;
1155  if (set->expltype != FET_Void) errol; return FET_OOFEM_Tr_Shell01; }
1156  else if ( set->cg == CG_Quadrangle && set->dpn == DPN_Dxy_R___ && set->sst == SST_plstress && set->approx == FEA_default ) { if (set->expltype != FET_Void) errol; return FET_OOFEM_PlaneStress2d; }
1157  else if ( set->cg == CG_Quadrangle && set->dpn == DPN_Dxy_R___ && set->sst == SST_plstrain && set->approx == FEA_default ) { if (set->expltype != FET_Void) errol; return FET_OOFEM_Quad1PlaneStrain; }
1158  else if ( set->cg == CG_Hexahedron && set->dpn == DPN_DxyzR___ && set->sst == SST_3d && set->approx == FEA_default ) { if (set->expltype != FET_Void) errol; return FET_OOFEM_LSpace; }
1159  else _errorr ("Unknown finite element type set");
1160  }
1161  else if (sol == SOL_ANSYS) {
1162  if ( set->cg == CG_Line && set->dpn == DPN_DxyzRxyz && set->sst == SST_beam && set->approx == FEA_default ) return FET_ANSYS_BEAM188;
1163  else if ( set->cg == CG_Triangle && set->dpn == DPN_DxyzRxyz && set->sst == SST_3dshell && set->approx == FEA_default ) return FET_ANSYS_SHELL181;
1164  else _errorr ("Unknown finite element type set");
1165  }
1166  else if (sol == SOL_SIFEL) {
1167  if (pg == PAG_mechanics) {
1168  if ( set->cg == CG_Line && set->dpn == DPN_DxyzR___ && set->sst == SST_truss && set->approx == FEA_default ) return FET_SIFEL_bar3d;
1169  else if ( set->cg == CG_Line && set->dpn == DPN_DxyzRxyz && set->sst == SST_beam && set->approx == FEA_default ) return FET_SIFEL_beam3d;
1170  else if ( set->cg == CG_Triangle && set->dpn == DPN_Dxy_R___ && set->approx == FEA_default ) return FET_SIFEL_planeelementlt;
1171  else if ( set->cg == CG_Quadrangle && set->dpn == DPN_Dxy_R___ && set->approx == FEA_default ) return FET_SIFEL_planeelementlq;
1172  else if ( set->cg == CG_Hexahedron && set->dpn == DPN_DxyzR___ && set->sst == SST_3d && set->approx == FEA_default ) return FET_SIFEL_linearhex;
1173  else _errorr ("Unknown finite element type set");
1174  }
1175  else if (pg == PAG_transport) {
1176  if ( set->cg == CG_Triangle && set->dpn == DPN_Void && set->sst == SST_transp2d && set->approx == FEA_linear ) return FET_SIFEL_trlint;
1177  else if ( set->cg == CG_Quadrangle && set->dpn == DPN_Void && set->sst == SST_transp2d && set->approx == FEA_bilinear) return FET_SIFEL_quadlint;
1178  else _errorr ("Unknown finite element type set");
1179  }
1180  else _errorr("Unknown problem group");
1181  }
1182  else errol;
1183 
1184  return FET_Void;
1185 }
1187 inline const char* FETSet_e2s_OOFEM (FiniteElementType feto)
1188 {
1189  switch (feto) {
1190  case FET_OOFEM_Truss3d: return "Truss3d"; break;
1191  case FET_OOFEM_LiBeam3d: return "LiBeam3d"; break;
1192  case FET_OOFEM_Beam3d: return "Beam3d"; break;
1193  case FET_OOFEM_TrPlaneStress2d: return "TrPlaneStress2d"; break;
1194  case FET_OOFEM_TrPlaneStrain: return "TrPlaneStrain"; break;
1195  case FET_OOFEM_TrPlaneStress2dRot: return "TrPlaneStrRot"; break;
1196  case FET_OOFEM_PlaneStress2d: return "PlaneStress2d"; break;
1197  case FET_OOFEM_Quad1PlaneStrain: return "Quad1PlaneStrain"; break;
1198  case FET_OOFEM_Tr_Shell01: return "Tr_Shell01"; break;
1199  case FET_OOFEM_RerShell: return "RerShell"; break;
1200  case FET_OOFEM_LSpace: return "LSpace"; break;
1201  default: _errorr ("Unknown OOFEM finite element");
1202  }
1203  return NULL;
1204 }
1206 inline int FETSet_e2i_SIFEL (FiniteElementType fet)
1207 {
1208  switch (fet) {
1209  case FET_SIFEL_bar3d: return 3; break;
1210  case FET_SIFEL_beam3d: return 4; break;
1211  case FET_SIFEL_planeelementlt: return 20; break;
1212  case FET_SIFEL_planeelementlq: return 23; break;
1213  case FET_SIFEL_linearhex: return 102; break;
1214  case FET_SIFEL_trlint: return 210; break;
1215  case FET_SIFEL_quadlint: return 215; break;
1216  default: _errorr ("Unknown SIFEL finite element");
1217  }
1218  return 0;
1219 }
1221 inline const char* FETSet_e2s_ANSYS (FiniteElementType fet)
1222 {
1223  switch (fet) {
1224  case FET_ANSYS_BEAM188: return "BEAM188"; break;
1225  case FET_ANSYS_SHELL181: return "SHELL181"; break;
1226  default: _errorr2("Unknown ANSYS element type %d", fet);
1227  }
1228  return NULL;
1229 }
1230 
1232 inline const char* FETSet_set2s_OOFEM (const FiniteElementTypeSet *set, PAGroup pg)
1233 {
1234  return FETSet_e2s_OOFEM (FETSet_set2e (set, SOL_OOFEM, pg));
1235 }
1237 inline int FETSet_set2i_SIFEL (const FiniteElementTypeSet *set, PAGroup pg)
1238 {
1239  return FETSet_e2i_SIFEL (FETSet_set2e (set, SOL_SIFEL, pg));
1240 }
1241 
1242 
1243 
1244 //* ********************************************************************************************
1245 //* *** *** *** *** INTEGRATION POINTS SET *** *** *** ***
1246 //* ********************************************************************************************
1248 enum IntPointSet { IPS_Void,
1249  IPS_1D_1ip, // 1D, 1 intpoint
1250  IPS_1D_exact, // 1D, 1 intpoint
1251  IPS_2D_3v_1ip, // 2D, 3 vertices, 1 intpoint
1252  IPS_2D_3v_3ip, // 2D, 3 vertices, 1 intpoint
1253  IPS_2D_3v_4ip, // 2D, 3 vertices, 1 intpoint
1254  IPS_2D_3v_shell, // 2D, 3 vertices, shell == combination 1 and 4 IP
1255  IPS_2D_4v_4ip, // 2D, 4 vertices, 4 intpoint
1256  IPS_3D_8v_8ip // 3D, 8 vertices, 8 intpoint
1257 };
1258 
1260 inline IntPointSet IPS_inputfile_value_i2e_OOFEM (int val, FiniteElementTypeSet *fets)
1261 {
1262  // if (fets->dim == 1 && fets->nv == 2 && fets->dpn == DPN_DxyzRxyz && fets->approx == FEA_133133) { // beam 3d
1263  // switch (fet) {
1264  // case FET_Beam3d: if (val == 1) return IPS_1D_1ip; break;
1265  // case FET_Void: _errorr("FET_Void in IntPointSet_i2e_OOFEM");
1266  // default: _errorr3("Unknown FiniteElementType %d, nip %ld", (int)fet, val);
1267  // }
1268 
1269  // TRIANGLE
1270  if (fets->cg == CG_Triangle) {
1271  switch (val) {
1272  case 1: return IPS_2D_3v_1ip; break;
1273  case 3: return IPS_2D_3v_3ip; break;
1274  case 4: return IPS_2D_3v_4ip; break;
1275  default: errol;
1276  }
1277  }
1278  // QUADRANGLE
1279  else if (fets->cg == CG_Quadrangle) {
1280  switch (val) {
1281  case 4: return IPS_2D_4v_4ip; break;
1282  default: errol;
1283  }
1284  }
1285  else
1286  errol;
1287 
1288  return IPS_Void;
1289 }
1291 inline int IPS_inputfile_value_e2i_OOFEM (IntPointSet val)
1292 {
1293  switch (val) {
1294  case IPS_2D_3v_1ip: return 1; break;
1295  case IPS_2D_3v_3ip: return 3; break;
1296  case IPS_2D_3v_4ip: return 4; break;
1297  case IPS_2D_4v_4ip: return 4; break;
1298  case FET_Void: _errorr("IPS_Void in IPS_inputfile_value_e2i_OOFEM");
1299  default: _errorr2("Unknown IPS %ld", (int)val);
1300  }
1301  return 0;
1302 }
1303 
1305 inline IntPointSet IntPointSet_s2e (const char *val)
1306 {
1307  if (STRCMP(val, "2D_3v_1ip") == 0) return IPS_2D_3v_1ip;
1308  else if (STRCMP(val, "2D_3v_3ip") == 0) return IPS_2D_3v_3ip;
1309  else if (STRCMP(val, "2D_3v_4ip") == 0) return IPS_2D_3v_4ip;
1310  else if (STRCMP(val, "2D_4v_4ip") == 0) return IPS_2D_4v_4ip;
1311  else _errorr ("Unknown integration points set in alias.h");
1312  return IPS_Void;
1313 }
1314 
1316 inline int IntPointSet_give_number_ips (IntPointSet ips)
1317 {
1318  switch (ips) {
1319  case IPS_1D_1ip: return 1; break;
1320  case IPS_1D_exact: return 1; break;
1321  case IPS_2D_3v_1ip: return 1; break;
1322  case IPS_2D_3v_3ip: return 3; break;
1323  case IPS_2D_3v_4ip: return 4; break;
1324  case IPS_2D_4v_4ip: return 4; break;
1325  case IPS_3D_8v_8ip: return 8; break;
1326  case IPS_Void: _errorr("IPS_Void in IntPointSet_i2e_OOFEM");
1327  default: _errorr2("Unknown IntPointSet %d", (int)ips);
1328  }
1329  return 0;
1330 }
1331 
1332 inline double IPS_give_ip_coord_native (int i, IntPointSet ips, PoinT &coords)
1333 {
1334  switch (ips) {
1336  case IPS_2D_3v_1ip:
1337  if (i == 0) { coords.x = coords.y = coords.z = 1 / 3.0; return 0.5; }
1338  else errol;
1339  break;
1340  case IPS_2D_3v_3ip:
1341  if (i == 0) { coords.x = 4 / 6.0; coords.y = 1 / 6.0; coords.z = 1 / 6.0; return 1 / 6.0; }
1342  else if (i == 1) { coords.x = 1 / 6.0; coords.y = 4 / 6.0; coords.z = 1 / 6.0; return 1 / 6.0; }
1343  else if (i == 2) { coords.x = 1 / 6.0; coords.y = 1 / 6.0; coords.z = 4 / 6.0; return 1 / 6.0; }
1344  else errol;
1345  break;
1346  case IPS_2D_3v_4ip:
1347  if (i == 0) { coords.x = 0.6; coords.y = 0.2; coords.z = 0.2; return 25./96.; }
1348  else if (i == 1) { coords.x = 0.2; coords.y = 0.6; coords.z = 0.2; return 25./96.; }
1349  else if (i == 2) { coords.x = 0.2; coords.y = 0.2; coords.z = 0.6; return 25./96.; }
1350  else if (i == 3) { coords.x = 1 / 3.0; coords.y = 1 / 3.0; coords.z = 1 / 3.0; return -9./32.; }
1351  else errol;
1352  break;
1354  case IPS_2D_4v_4ip:
1355  if (i == 0) { coords.x = -0.577350269189626; coords.y = -0.577350269189626; return 1.0; }
1356  else if (i == 1) { coords.x = -0.577350269189626; coords.y = 0.577350269189626; return 1.0; }
1357  else if (i == 2) { coords.x = 0.577350269189626; coords.y = -0.577350269189626; return 1.0; }
1358  else if (i == 3) { coords.x = 0.577350269189626; coords.y = 0.577350269189626; return 1.0; }
1359  else errol;
1360  break;
1361  default: _errorr2("Unknown IntPointSet %d", (int)ips);
1362  }
1363  return 0.0;
1364 }
1365 
1366 // for integration of function f
1367 inline IntPointSet IntPointSet_fets2ips (const FiniteElementTypeSet *set)
1368 {
1369  if ( set->cg == CG_Line && set->dpn == DPN_DxyzR___ && set->sst == SST_truss && set->approx == FEA_linear ) return IPS_1D_1ip; // "Truss3d"
1370  else if ( set->cg == CG_Line && set->dpn == DPN_DxyzRxyz && set->sst == SST_beam && set->approx == FEA_linear ) return IPS_1D_1ip; // "LiBeam3d"
1371 //else if ( set->cg == CG_Line && set->dpn == DPN_DxyzRxyz && set->sst == SST_beam && set->approx == FEA_default ) return IPS_; // "Beam3d"
1372  else if ( set->cg == CG_Triangle && set->dpn == DPN_Dxy_R___ && set->sst == SST_plstrain && set->approx == FEA_linear ) return IPS_2D_3v_1ip; // "TrPlaneStrain"
1373  else if ( set->cg == CG_Quadrangle && set->dpn == DPN_Dxy_R___ && set->sst == SST_plstrain && set->approx == FEA_bilinear) return IPS_2D_4v_4ip; // "Quad1PlaneStrain"
1374  else if ( set->cg == CG_Triangle && set->dpn == DPN_Dxy_R___ && set->sst == SST_plstress && set->approx == FEA_linear ) return IPS_2D_3v_1ip; // "TrPlaneStress2d"
1375 //else if ( set->cg == CG_Triangle && set->dpn == DPN_DxyzRxyz && set->sst == SST_3dshell && set->approx == FEA_default ) return IPS_; // "Tr_Shell01"
1376  else if ( set->cg == CG_Hexahedron && set->dpn == DPN_DxyzR___ && set->sst == SST_3d && set->approx == FEA_linear ) return IPS_3D_8v_8ip; // "LSpace"
1377 //else _errorr ("Unknown finite element type set");
1378  return IPS_Void;
1379 }
1380 
1382 //inline IntPointSet IntPointSet_fets2ips_2 (const FiniteElementTypeSet *set)
1383 //{
1393 // IntPointSet ips = IntPointSet_fets2ips (set);
1394 //
1395 // if (ips == IPS_Void) errol;
1396 // switch (ips) {
1397 // //case FET_Truss3d:
1398 // //case FET_LiBeam3d:
1399 // //case FET_LiBeam3dNL:
1400 // //case FET_Beam3d: IPset = IPS_1D_1ip; break;
1401 // case IPS_2D_3v_1ip: return IPS_2D_3v_1ip; break;
1402 // //case FET_PlaneStrainQuad:
1403 // //case FET_PlaneStressQuad: IPset = IPS_2D_4v_4ip; break;
1404 // //case FET_ShellTr: IPset = IPS_2D_3v_shell; break;
1405 // //case FET_HexaHedra: IPset = IPS_3D_8v_8ip; break;
1406 // default: _errorr("Unknown OOFEM element");
1407 // }
1408 //
1409 // return IPS_Void;
1410 //}
1411 
1412 
1414 inline IntPointSet IntPointSet_fet2e_comp (FiniteElementType fet)
1415 {
1416  switch (fet) {
1417  case FET_OOFEM_Truss3d: return IPS_1D_1ip; break;
1418  case FET_OOFEM_LiBeam3d: return IPS_1D_1ip; break;
1419  case FET_OOFEM_Beam3d: return IPS_1D_exact; break;
1420  case FET_OOFEM_TrPlaneStress2d: return IPS_2D_3v_1ip; break;
1421  case FET_OOFEM_TrPlaneStrain: return IPS_2D_3v_1ip; break;
1422  case FET_OOFEM_PlaneStress2d: return IPS_2D_4v_4ip; break;
1423  case FET_OOFEM_Quad1PlaneStrain: return IPS_2D_4v_4ip; break;
1424  case FET_OOFEM_RerShell: return IPS_2D_3v_1ip; break;
1425  case FET_OOFEM_Tr_Shell01: return IPS_2D_3v_1ip; break;
1426  case FET_OOFEM_LSpace: return IPS_3D_8v_8ip; break;
1427  //
1428  case FET_SIFEL_bar3d: return IPS_1D_1ip; break;
1429  //case FET_SIFEL_beam3d: return 4; break;
1430  //case FET_SIFEL_planeelementlt: return 20; break;
1431  //case FET_SIFEL_planeelementlq: return 23; break;
1432  case FET_SIFEL_linearhex: return IPS_3D_8v_8ip; break;
1433  //case FET_SIFEL_trlint: return 210; break;
1434  //case FET_SIFEL_quadlint: return 215; break;
1435  default: _errorr ("Unknown finite element type");
1436  }
1437  return IPS_Void;
1438 }
1439 
1441 inline IntPointSet IntPointSet_fet2e_rslts (IntPointSet IPset, FiniteElementType fet)
1442 {
1443  if (IPset == IPS_Void) errol;
1444 
1445  switch (fet) {
1446  case FET_OOFEM_Truss3d: return IPset; break;
1447  case FET_OOFEM_LiBeam3d: return IPset; break;
1448  case FET_OOFEM_Beam3d: return IPset; break;
1449  case FET_OOFEM_TrPlaneStress2d: return IPset; break;
1450  case FET_OOFEM_TrPlaneStress2dRot: return IPset; break;
1451  case FET_OOFEM_TrPlaneStrain: return IPset; break;
1452  case FET_OOFEM_PlaneStress2d: return IPset; break;
1453  case FET_OOFEM_Quad1PlaneStrain: return IPset; break;
1454  case FET_OOFEM_RerShell: return IPset; break;
1455  case FET_OOFEM_Tr_Shell01: return IPset; break;
1456  case FET_OOFEM_LSpace: return IPset; break;
1457  //
1458  case FET_SIFEL_bar3d: return IPset; break;
1459  //case FET_SIFEL_beam3d: return 4; break;
1460  //case FET_SIFEL_planeelementlt: return 20; break;
1461  //case FET_SIFEL_planeelementlq: return 23; break;
1462  case FET_SIFEL_linearhex: return IPset; break;
1463  //case FET_SIFEL_trlint: return 210; break;
1464  //case FET_SIFEL_quadlint: return 215; break;
1465  default: _errorr ("Unknown finite element type");
1466  }
1467  return IPS_Void;
1468 }
1469 
1470 
1471 
1472 
1473 //* ********************************************************************************************
1474 //* *** *** *** *** GLOBAL VARIABLES *** *** *** ***
1475 //* ********************************************************************************************
1476 //#ifndef EXTERN
1477 //#define EXTERN extern
1478 //#endif
1479 
1480 //* ********************************************************************************************
1481 //* ********************************************************************************************
1482 //* *** *** *** *** ECN - ELEMENT COMPONENT NUMBERING *** *** *** ***
1483 //* ********************************************************************************************
1484 //* ********************************************************************************************
1488 inline int ECN_convert_nodes_beam (bool i2e, int id, femFileFormat fff);
1489 inline int ECN_convert_edges_beam (bool i2e, int id, femFileFormat fff);
1490 
1491 inline int ECN_convert_nodes_triangle (bool i2e, int id, femFileFormat fff);
1492 inline int ECN_convert_edges_triangle (bool i2e, int id, femFileFormat fff);
1493 inline int ECN_convert_faces_triangle (bool i2e, int id, femFileFormat fff);
1494 
1495 inline int ECN_convert_nodes_quadrangle (bool i2e, int id, femFileFormat fff);
1496 inline int ECN_convert_edges_quadrangle (bool i2e, int id, femFileFormat fff);
1497 
1498 inline int ECN_convert_nodes_brick (bool i2e, int id, femFileFormat fff);
1499 inline int ECN_convert_edges_brick (bool i2e, int id, femFileFormat fff);
1500 inline int ECN_convert_faces_brick (bool i2e, int id, femFileFormat fff);
1501 
1504 inline int ECN_convert_i2e (int id, int compdim, int ord, CellGeometry cg, femFileFormat fff)
1505 {
1506  if (ord != -4) errol;
1507 
1508  switch (compdim) {
1509  case 0: // NODES
1510  switch (cg) {
1511  case CG_Line: return ECN_convert_nodes_beam (true, id, fff); break;
1512  case CG_Triangle: return ECN_convert_nodes_triangle (true, id, fff); break;
1513  case CG_Quadrangle: return ECN_convert_nodes_quadrangle (true, id, fff); break;
1514  case CG_Hexahedron: return ECN_convert_nodes_brick (true, id, fff); break;
1515  default: _errorr("unsupported cell geometry");
1516  }
1517  break;
1518  case 1: // EDGES
1519  switch (cg) {
1520  case CG_Line: return ECN_convert_edges_beam (true, id, fff); break;
1521  case CG_Triangle: return ECN_convert_edges_triangle (true, id, fff); break;
1522  case CG_Quadrangle: return ECN_convert_edges_quadrangle (true, id, fff); break;
1523  case CG_Hexahedron: return ECN_convert_edges_brick (true, id, fff); break;
1524  default: _errorr("unsupported cell geometry");
1525  }
1526  break;
1527  case 2: // FACES
1528  switch (cg) {
1529  case CG_Triangle: return ECN_convert_faces_triangle (true, id, fff); break;
1530  case CG_Hexahedron: return ECN_convert_faces_brick (true, id, fff); break;
1531  default: _errorr("unsupported cell geometry");
1532  }
1533  break;
1534  default: _errorr("unsupported dimension of converted component");
1535  }
1536  return -1;
1537 }
1539 inline int ECN_convert_e2i (int id, int compdim, int ord, CellGeometry cg, femFileFormat fff)
1540 {
1541  if (ord != -4)
1542  errol;
1543 
1544  switch (compdim) {
1545  case 0: // NODES
1546  switch (cg) {
1547  case CG_Line: return ECN_convert_nodes_beam (false, id, fff); break;
1548  case CG_Triangle: return ECN_convert_nodes_triangle (false, id, fff); break;
1549  case CG_Quadrangle: return ECN_convert_nodes_quadrangle (false, id, fff); break;
1550  case CG_Hexahedron: return ECN_convert_nodes_brick (false, id, fff); break;
1551  default: _errorr("unsupported cell geometry");
1552  }
1553  break;
1554  case 1: // EDGES
1555  switch (cg) {
1556  case CG_Line: return id; break;
1557  case CG_Triangle: return ECN_convert_edges_triangle (false, id, fff); break;
1558  case CG_Quadrangle: return ECN_convert_edges_quadrangle (false, id, fff); break;
1559  case CG_Hexahedron: return ECN_convert_edges_brick (false, id, fff); break;
1560  default: _errorr("unsupported cell geometry");
1561  }
1562  break;
1563  case 2: // FACES
1564  switch (cg) {
1565  case CG_Hexahedron: return ECN_convert_faces_brick (false, id, fff); break;
1566  default: _errorr("unsupported cell geometry");
1567  }
1568  break;
1569  default: _errorr("unsupported dimension of converted component");
1570  }
1571  return -1;
1572 }
1573 
1574 
1575 //* ********************************************************************************************
1576 //* *** *** *** *** ECN - beam linear *** *** *** ***
1577 //* ********************************************************************************************
1578 // ///
1579 // +------------> ksi ///
1580 // +---------|---------+ ///
1581 // 1 2 ///
1582 // ///
1583 // NODE NUMBERING EDGE NUMBERING ///
1584 // MIDAS + T3d, VTK, OOFEM, ANSYS MIDAS + T3d, VTK, OOFEM, ANSYS ///
1585 // 1---------2 +-----1-----+ ///
1586 // ///
1587 inline int ECN_convert_nodes_beam (bool i2e, int id, femFileFormat fff) { return id; }
1588 inline int ECN_convert_edges_beam (bool i2e, int id, femFileFormat fff) { return id; }
1589 
1590 
1591 //* ********************************************************************************************
1592 //* *** *** *** *** ECN - triangle linear *** *** *** ***
1593 //* ********************************************************************************************
1594 // ///
1595 // NODE NUMBERING ///
1596 // MIDAS + T3d, VTK, OOFEM, SIFEL, ANSYS ///
1597 // 3 ///
1598 // / \ ///
1599 // / \ ///
1600 // / \ ///
1601 // 1-------2 ///
1602 // ///
1603 inline int ECN_convert_nodes_triangle (bool i2e, int id, femFileFormat fff)
1604 {
1605  switch (fff) {
1606  case FFF_T3d:
1607  case FFF_VTX:
1608  case FFF_SIFEL:
1609  case FFF_ANSYS:
1610  case FFF_OOFEM: return id; break;
1611  default: _errorr("unsupported fem file format");
1612  }
1613  return -1;
1614 }
1615 
1616 // EDGE NUMBERING ///
1617 // MIDAS + OOFEM + T3d ///
1618 // + ///
1619 // / \ ///
1620 // 3 2 ///
1621 // / \ ///
1622 // +---1---+ ///
1623 // ///
1624 inline int ECN_convert_edges_triangle (bool i2e, int id, femFileFormat fff)
1625 {
1626  switch (fff) {
1627  case FFF_T3d: return id; break;
1628  case FFF_OOFEM: return id; break;
1629  default: _errorr("unsupported fem file format");
1630  }
1631  return -1;
1632 }
1633 // FACE NUMBERING ///
1634 inline int ECN_convert_faces_triangle (bool i2e, int id, femFileFormat fff) { return id; }
1635 
1636 // INT.POINTS NUMBERING ///
1637 // IPS_2D_3v_3ip IPS_2D_3v_4ip ///
1638 // MIDAS OOFEM MIDAS OOFEM ///
1639 // + + + + ///
1640 // / \ / \ /3\ /1\ ///
1641 // / 3 \ / 1 \ / 4 \ / 4 \ ///
1642 // / 1 2 \ / 2 3 \ /1 2\ /2 3\ ///
1643 // +-------+ +-------+ +-------+ +-------+ ///
1644 // ///
1645 static const int TRIANGLE_IPN_OOFEM_3_I2E[3] = { 2, 3, 1 };
1646 static const int TRIANGLE_IPN_OOFEM_3_E2I[3] = { 3, 1, 2 };
1647 
1648 static const int TRIANGLE_IPN_OOFEM_4_I2E[4] = { 2, 3, 1, 4 };
1649 static const int TRIANGLE_IPN_OOFEM_4_E2I[4] = { 3, 1, 2, 4 };
1650 
1651 inline int ECN_convert_ips_triangle (bool i2e, int id, femFileFormat fff, IntPointSet ips)
1652 {
1653  if (ips == IPS_2D_3v_1ip) { return id; }
1654  else if (ips == IPS_2D_3v_3ip) {
1655  switch (fff) {
1656  case FFF_OOFEM: if (i2e) return TRIANGLE_IPN_OOFEM_3_I2E[id] - 1;
1657  else return TRIANGLE_IPN_OOFEM_3_E2I[id] - 1; break;
1658  default: _errorr("unsupported fem file format");
1659  }
1660  }
1661  else if (ips == IPS_2D_3v_4ip) {
1662  switch (fff) {
1663  case FFF_OOFEM: if (i2e) return TRIANGLE_IPN_OOFEM_4_I2E[id] - 1;
1664  else return TRIANGLE_IPN_OOFEM_4_E2I[id] - 1; break;
1665  default: _errorr("unsupported fem file format");
1666  }
1667  }
1668  else errol;
1669 
1670  return -1;
1671 }
1672 
1673 //* ********************************************************************************************
1674 //* *** *** *** *** ECN - quadrangle linear *** *** *** ***
1675 //* ********************************************************************************************
1676 // eta ///
1677 // ^ ///
1678 // | ///
1679 // +---|---+ ///
1680 // | | | ksi ///
1681 // | +------> ///
1682 // | | ///
1683 // +-------+ ///
1684 // ///
1685 // NODE NUMBERING ///
1686 // MIDAS + T3d, VTK, OOFEM ///
1687 // 2-------1 ///
1688 // | | ///
1689 // | | ///
1690 // | | ///
1691 // 3-------4 ///
1692 // ///
1693 inline int ECN_convert_nodes_quadrangle (bool i2e, int id, femFileFormat fff)
1694 {
1695  switch (fff) {
1696  case FFF_T3d:
1697  case FFF_VTX:
1698  case FFF_JKTK:
1699  case FFF_SIFEL:
1700  case FFF_OOFEM: return id; break;
1701  default: _errorr("unsupported fem file format");
1702  }
1703  return -1;
1704 }
1705 
1706 // EDGE NUMBERING ///
1707 // MIDAS + OOFEM + T3d ///
1708 // +---1---+ ///
1709 // | | ///
1710 // 2 4 ///
1711 // | | ///
1712 // +---3---+ ///
1713 // ///
1714 inline int ECN_convert_edges_quadrangle (bool i2e, int id, femFileFormat fff)
1715 {
1716  switch (fff) {
1717  case FFF_T3d:
1718  case FFF_OOFEM: return id; break;
1719  default: _errorr("unsupported fem file format");
1720  }
1721  return -1;
1722 }
1723 
1724 // INT.POINTS NUMBERING ///
1725 // IPS_2D_4v_4ip ///
1726 // MIDAS + OOFEM ///
1727 // +-------+ ///
1728 // | 2 4 | ///
1729 // | | ///
1730 // | 1 3 | ///
1731 // +-------+ ///
1732 // ///
1733 inline int ECN_convert_ips_quadrangle (bool i2e, int id, femFileFormat fff, IntPointSet ips)
1734 {
1735  if (ips != IPS_2D_4v_4ip) errol;
1736 
1737  switch (fff) {
1738  case FFF_OOFEM: return id; break;
1739  default: _errorr("unsupported fem file format");
1740  }
1741  return -1;
1742 }
1743 
1744 
1745 //* ********************************************************************************************
1746 //* *** *** *** *** ECN - brick linear *** *** *** ***
1747 //* ********************************************************************************************
1748 // dzeta eta ///
1749 // ^ 7 ///
1750 // | / ///
1751 // 2--|------3 ///
1752 // /| |* + /| ///
1753 // / | * + / | ///
1754 // / | + + / | ///
1755 // 1---------4 | ksi ///
1756 // | | X++|+*----> ///
1757 // | 6-----|---7 ///
1758 // | / | / ///
1759 // | / | / ///
1760 // |/ |/ ///
1761 // 5---------8 ///
1762 // ///
1763 // NODE NUMBERING ///
1764 // MIDAS + T3d, VTK, OOFEM SIFEL, JKTK ///
1765 // 2---------3 2---------1 +---------+ ///
1766 // /| /| /| /| /| /| ///
1767 // / | / | / | / | / | / | ///
1768 // / | / | / | / | / | / | ///
1769 // 1---------4 | 3---------4 | +---------+ | ///
1770 // | | | | | | | | | | | | ///
1771 // | 6-----|---7 | 6-----|---5 | +-----|---+ ///
1772 // | / | / | / | / | / | / ///
1773 // | / | / | / | / | / | / ///
1774 // |/ |/ |/ |/ |/ |/ ///
1775 // 5---------8 7---------8 +---------+ ///
1776 // ///
1777 static const int BRICK_NN_SIFEL[8] = { 3, 2, 1, 4, 7, 6, 5, 8 }; // i2e independant
1778 //
1779 inline int ECN_convert_nodes_brick (bool i2e, int id, femFileFormat fff)
1780 {
1781  switch (fff) {
1782  case FFF_T3d:
1783  case FFF_VTX:
1784  case FFF_OOFEM: return id; break;
1785  case FFF_JKTK:
1786  case FFF_SIFEL: return BRICK_NN_SIFEL[id] - 1; break;
1787  default: _errorr("unsupported fem file format");
1788  }
1789  return -1;
1790 }
1791 
1792 // EDGE NUMBERING ///
1793 // MIDAS OOFEM SIFEL ///
1794 // +----2----+ +----2----+ +----1----+ ///
1795 // /| /| /| /| /| /| ///
1796 // 1 | 3 | 1 | 3 | 2 | 4 | ///
1797 // / 10 / 11 / 6 / 7 / 6 / 5 ///
1798 // +----4----+ | +----4----+ | +----3----+ | ///
1799 // | | | | | | | | | | | | ///
1800 // | +----6|---+ | +---10|---+ | +----9|---+ ///
1801 // 9 / 12 / 5 / 8 / 7 / 8 / ///
1802 // | 5 | 7 | 9 | 11 | 10 | 12 ///
1803 // |/ |/ |/ |/ |/ |/ ///
1804 // +----8----+ +----12---+ +----11---+ ///
1805 // ///
1806 
1807 static const int BRICK_EN_OOFEM[12] = { 1, 2, 3, 4, 9, 10, 11, 12, 5, 6, 7, 8 }; // i2e independant
1808 //
1809 static const int BRICK_EN_SIFEL_I2E[12] = { 2, 1, 4, 3, 10, 9, 12, 11, 7, 6, 5, 8 };
1810 static const int BRICK_EN_SIFEL_E2I[12] = { 2, 1, 4, 3, 11, 10, 9, 12, 6, 5, 8, 7 };
1811 //
1812 inline int ECN_convert_edges_brick (bool i2e, int id, femFileFormat fff)
1813 {
1814  switch (fff) {
1815  case FFF_OOFEM: return BRICK_EN_OOFEM [id] - 1;
1816  case FFF_JKTK:
1817  case FFF_SIFEL: if (i2e) return BRICK_EN_SIFEL_I2E[id] - 1;
1818  else return BRICK_EN_SIFEL_E2I[id] - 1;
1819  default: _errorr("unsupported fem file format");
1820  }
1821  return -1;
1822 }
1823 
1824 // FACE NUMBERING ///
1825 // MIDAS OOFEM T3d SIFEL ///
1826 // +---------+ +---------+ ///
1827 // /| /| /| /| ///
1828 // / | 1 / | / | 5 / | ///
1829 // / | 4 / | / | 2 / | ///
1830 // +---------+ | +---------+ | ///
1831 // | 3 | | 5 | | 3 | | 1 | ///
1832 // | +-----|---+ | +-----|---+ ///
1833 // | / 6 | / | / 4 | / ///
1834 // | / 2 | / | / 6 | / ///
1835 // |/ |/ |/ |/ ///
1836 // +---------+ +---------+ ///
1837 // ///
1838 static const int BRICK_FN_SIFEL_I2E[6] = { 5, 6, 3, 2, 1, 4 };
1839 static const int BRICK_FN_SIFEL_E2I[6] = { 5, 4, 3, 6, 1, 2 };
1840 //
1841 inline int ECN_convert_faces_brick (bool i2e, int id, femFileFormat fff)
1842 {
1843  switch (fff) {
1844  case FFF_T3d:
1845  case FFF_OOFEM: return id;
1846  case FFF_JKTK:
1847  case FFF_SIFEL: if (i2e) return BRICK_FN_SIFEL_I2E[id] - 1;
1848  else return BRICK_FN_SIFEL_E2I[id] - 1;
1849  default: _errorr("unsupported fem file format");
1850  }
1851  return -1;
1852 }
1853 
1854 // INT.POINTS NUMBERING ///
1855 // IPS_3D_8v_8ip ///
1856 // MIDAS OOFEM SIFEL ///
1857 // 4---------8 +---------+ ///
1858 // /| /| /| /| ///
1859 // / | / | / | / | ///
1860 // / | / | / | / | ///
1861 // 2---------6 | +---------+ | ///
1862 // | | | | | | | | ///
1863 // | 3-----|---7 | +-----|---+ ///
1864 // | / | / | / | / ///
1865 // | / | / | / | / ///
1866 // |/ |/ |/ |/ ///
1867 // 1---------5 +---------+ ///
1868 // ///
1869 inline int ECN_convert_ips_brick (bool i2e, int id, femFileFormat fff, IntPointSet ips)
1870 {
1871  if (ips != IPS_3D_8v_8ip) errol;
1872 
1873  switch (fff) {
1874  case FFF_OOFEM: return id; break;
1875  default: _errorr("unsupported fem file format");
1876  }
1877  return -1;
1878 }
1879 
1880 
1881 
1884 
1885 
1886 //* ********************************************************************************************
1887 //* *** *** *** *** ECN - tetra linear *** *** *** ***
1888 //* ********************************************************************************************
1889 // ///
1890 // NODE NUMBERING ///
1891 // MIDAS + T3d-?, OOFEM, VTK SIFEL ///
1892 // ///
1893 // 4 4 ///
1894 // /|\ /|\ ///
1895 // / | \ / | \ ///
1896 // / | \ / | \ ///
1897 // 1---|---3 1---|---2 ///
1898 // \ | / \ | / ///
1899 // \ | / \ | / ///
1900 // \|/ \|/ ///
1901 // 2 3 ///
1902 // ///
1903 // ///
1904 // EDGE NUMBERING ///
1905 // MIDAS OOFEM ///
1906 // ///
1907 // + + ///
1908 // /|\ /|\ ///
1909 // 4 | 6 / | \ ///
1910 // / 5 \ / | \ ///
1911 // +--3|---+ +---|---+ ///
1912 // \ | / \ | / ///
1913 // 1 | 2 \ | / ///
1914 // \|/ \|/ ///
1915 // + + ///
1916 // ///
1917 // ///
1918 // FACE NUMBERING ///
1919 // MIDAS OOFEM ///
1920 // ///
1921 // + + ///
1922 // /|\ /|\ ///
1923 // / | \ / | \ ///
1924 // / 4 \ / | \ ///
1925 // +-2-|-3-+ +---|---+ ///
1926 // \ 1 / \ | / ///
1927 // \ | / \ | / ///
1928 // \|/ \|/ ///
1929 // + + ///
1930 // ///
1931 
1932 
1933 //* ********************************************************************************************
1934 //* *** *** *** *** ECN - tetra quadr *** *** *** ***
1935 //* ********************************************************************************************
1936 // ///
1937 // NODE NUMBERING ///
1938 // MIDAS + OOFEM, VTK SIFEL ///
1939 // ///
1940 // 7 l3 7 l3 ///
1941 // / / ///
1942 // 4 3 ///
1943 // /|\ /|\ ///
1944 // 8 | 10 10 | 6 ///
1945 // / | \ / | \ ///
1946 // 1---|7--3---> l2 4---|9--2---> l2 ///
1947 // \ 9 / \ 7 / ///
1948 // 5 | 6 8 | 5 ///
1949 // \|/ \|/ ///
1950 // 2 1 ///
1951 // \ \ ///
1952 // \| l1 \| l1 ///
1953 // "" "" ///
1954 // ///
1955 
1956 //* ********************************************************************************************
1957 //* *** *** *** *** MIDAS numbering *** *** *** ***
1958 //* ********************************************************************************************
1960 // EDGE NUMBERING [see give_edge_nodes() for MIDAS numbering] ///
1961 // FACE NUMBERING [see give_face_nodes_edges() for MIDAS numbering] ///
1962 //
1963 
1964 //* ********************************************************************************************
1965 //* *** *** *** *** SIFEL numbering *** *** *** ***
1966 //* ********************************************************************************************
1967 //
1968 // NODE NUMBERING + gauss points
1969 // =============================
1970 // postup:
1971 // - v souboru.cpp najdu fci approx a tam je neco jako bf_lin_1d, dale viz evalN v OOFEMu ///
1972 //
1973 // EDGE NUMBERING - see long selement::alloc(long alloc_bp) in siftop.cpp ///
1974 // FACE NUMBERING [see give_face_nodes_edges() for MIDAS numbering] ///
1975 
1976 
1977 //* ********************************************************************************************
1978 //* *** *** *** *** OOFEM numbering *** *** *** ***
1979 //* ********************************************************************************************
1981 // OOFEM - cislovani uzlu elementu + gauss points
1982 // ==============================================
1983 // postup:
1984 // - okopiruju fci evalN ktera je nekde v fei2dlin...
1985 // pro kazdy answer.at(i) najdu ksi/eta takovy, aby to bylo rovny 1
1986 // i-ty bod pak ma souradnice ksi eta
1987 // - vlezu do gaussintegrationrule.C
1988 // ve fci SetUpPointsOnXXXX jdu na prilusny pocet intpointu
1989 // lokalizuju intpointy
1990 //
1991 //
1992 // fei1dlin ///
1993 // ======== ///
1994 // evalN +------------> ksi ///
1995 // answer.at(1) = ( 1. - ksi ) * 0.5; -1.0 0 1.0 ///
1996 // answer.at(2) = ( 1. + ksi ) * 0.5; +---------|---------+ ///
1997 // 1 2 ///
1998 // SetUpPointsOnLine: + + ///
1999 // c->at(1) = -0.577350269189626; 1 2 ///
2000 // c->at(2) = 0.577350269189626; ///
2001 // ///
2002 // w->at(1) = w->at(2) = 1.0; Lokalizace: ///
2003 // uzel - 1 2 ///
2004 // for ( i = 0; i < 2; i++ ) { gp - 1 2 ///
2005 // coord = new FloatArray(1); ///
2006 // coord->at(1) = c->at(i + 1); ///
2007 // weight = w->at(i + 1); ///
2008 // ( * arry ) [ i ] = new GaussPoint(this, i + 1, coord, weight, mode); ///
2009 // ///
2010 // ///
2011 // fei2dquadlin ///
2012 // ============ ///
2013 // evalN eta ///
2014 // answer.at(1) = ( 1. + ksi ) * ( 1. + eta ) * 0.25; ^ ///
2015 // answer.at(2) = ( 1. - ksi ) * ( 1. + eta ) * 0.25; | ///
2016 // answer.at(3) = ( 1. - ksi ) * ( 1. - eta ) * 0.25; 2 |+1.0 1 ///
2017 // answer.at(4) = ( 1. + ksi ) * ( 1. - eta ) * 0.25; +---------|---------+ ///
2018 // | | | ///
2019 // SetUpPointsOnSquare: | + | + | ///
2020 // c->at(1) = -0.577350269189626; | 2 | 4 | ///
2021 // c->at(2) = 0.577350269189626; -1.0| | |+1.0 ksi ///
2022 // + +------------------> ///
2023 // w->at(1) = 1.0; | | ///
2024 // w->at(2) = 1.0; | 1 3 | ///
2025 // | + + | ///
2026 // * arry = new GaussPoint * [ 4 ]; | | ///
2027 // +---------|---------+ ///
2028 // for ( i = 0; i < 2; i++ ) { 3 -1.0 4 ///
2029 // for ( j = 0; j < 2; j++ ) { ///
2030 // coord = new FloatArray(2); ///
2031 // coord->at(1) = c->at(i + 1); Lokalizace: ///
2032 // coord->at(2) = c->at(j + 1); uzel - 1 2 3 4 ///
2033 // weight = w->at(i + 1) * w->at(j + 1); gp - 4 2 1 3 ///
2034 // ( * arry ) [ 2 * i + j ] = \ ///
2035 // new GaussPoint(this,2*i+j+1,coord,weight,mode); ///
2036 // ///
2037 // ///
2038 // fei3dhexalin dzeta ///
2039 // ============ ^ eta ///
2040 // evalN: | 7 ///
2041 // | / ///
2042 // answer.at(1) = 0.125 * ( 1. - x ) * ( 1. - y ) * ( 1. + z ); | / ///
2043 // answer.at(2) = 0.125 * ( 1. - x ) * ( 1. + y ) * ( 1. + z ); 2----------|----------------------3 ///
2044 // answer.at(3) = 0.125 * ( 1. + x ) * ( 1. + y ) * ( 1. + z ); /| 4 | * 8 /| ///
2045 // answer.at(4) = 0.125 * ( 1. + x ) * ( 1. - y ) * ( 1. + z ); / | | * / | ///
2046 // answer.at(5) = 0.125 * ( 1. - x ) * ( 1. - y ) * ( 1. - z ); / | | * / | ///
2047 // answer.at(6) = 0.125 * ( 1. - x ) * ( 1. + y ) * ( 1. - z ); / | | * / | ///
2048 // answer.at(7) = 0.125 * ( 1. + x ) * ( 1. + y ) * ( 1. - z ); / | | * / | ///
2049 // answer.at(8) = 0.125 * ( 1. + x ) * ( 1. - y ) * ( 1. - z ); / | + * / | ///
2050 // / | * * / | ///
2051 // SetUpPointsOnCube: / | * * / | ///
2052 // c->at(1) = -0.577350269189626; / | * * / | ///
2053 // c->at(2) = 0.577350269189626; / | * * / | ///
2054 // / | * * / | ///
2055 // w->at(1) = 1.0; 1---------------------------------4 | ///
2056 // w->at(2) = 1.0; | 2 | * * 6 | | ///
2057 // | | ** | | ksi ///
2058 // * arry = new GaussPoint * [ nPoints ]; | | O * * * * *|* * *+-----------> ///
2059 // | | | | ///
2060 // for ( i = 0; i < 2; i++ ) { | | | | ///
2061 // for ( j = 0; j < 2; j++ ) { | 6---------------------|-----------7 ///
2062 // for ( k = 0; k < 2; k++ ) { | / 3 | 7 / ///
2063 // coord = new FloatArray(3); | / | / ///
2064 // coord->at(1) = c->at(i + 1); | / | / ///
2065 // coord->at(2) = c->at(j + 1); | / | / ///
2066 // coord->at(3) = c->at(k + 1); | / | / ///
2067 // weight = w->at(i + 1) * w->at(j + 1) * w->at(k + 1); | / | / ///
2068 // ( * arry ) [ 4 * i + 2 * j + k ] = | / | / ///
2069 // new GaussPoint(this,4*i+2*j+k+1,coord,weight,mode); | / | / ///
2070 // | / | / ///
2071 // Lokalizace: | / | / ///
2072 // uzel - 1 2 3 4 5 6 7 8 |/ 1 5 |/ ///
2073 // gp - 2 4 8 6 1 3 7 5 5---------------------------------8 ///
2074 
2075 
2076 } // namespace midaspace
2077 
2078 #endif // MIDAS_ALIAS_H
midaspace::FETSet_si2e
FiniteElementType FETSet_si2e(const char *str, int val, Solver sol, PAGroup pg)
string/int to FET
Definition: alias.h:1062
midaspace::DOFsPerNode_s2e
DOFsPerNode DOFsPerNode_s2e(const char *val)
Definition: alias.h:708
midaspace::FET_s2e
FiniteElementType FET_s2e(const char *str)
string to FET
Definition: alias.h:1053
midaspace::femFileFormat
femFileFormat
Definition: alias.h:632
midaspace::BRICK_EN_SIFEL_I2E
static const int BRICK_EN_SIFEL_I2E[12]
Definition: alias.h:1809
midaspace::PAType_i2e_SIFEL
PAType PAType_i2e_SIFEL(int val)
Definition: alias.h:411
midaspace::IntPointSet_fet2e_rslts
IntPointSet IntPointSet_fet2e_rslts(IntPointSet IPset, FiniteElementType fet)
FET to IPS for results.
Definition: alias.h:1441
midaspace::LinearSolverType_i2e_SIFEL
LinearSolverType LinearSolverType_i2e_SIFEL(int val)
Conversion from "SIFEL int" to "enum" identificator of "linear solver type".
Definition: alias.h:295
midaspace::DOFsPerNode2OOFEMdomain
const char * DOFsPerNode2OOFEMdomain(DOFsPerNode od)
Definition: alias.h:740
midaspace::Solver
Solver
Solver.
Definition: alias.h:188
midaspace::VTKdataset
VTKdataset
VTK data set.
Definition: alias.h:201
midaspace::SStype_s2e
SStype SStype_s2e(const char *val)
Definition: alias.h:962
midaspace::BRICK_FN_SIFEL_I2E
static const int BRICK_FN_SIFEL_I2E[6]
Definition: alias.h:1838
midaspace::MaterialType_e2i_SIFEL
int MaterialType_e2i_SIFEL(MaterialType val, PAGroup pg)
Definition: alias.h:544
midaspace::IPS_inputfile_value_i2e_OOFEM
IntPointSet IPS_inputfile_value_i2e_OOFEM(int val, FiniteElementTypeSet *fets)
val je cislo ze vstupaku oofemu, keyword NIP
Definition: alias.h:1260
midaspace::DOFsPerNode2nDOFs
int DOFsPerNode2nDOFs(DOFsPerNode od)
Definition: alias.h:755
midaspace::TRIANGLE_IPN_OOFEM_3_I2E
static const int TRIANGLE_IPN_OOFEM_3_I2E[3]
Definition: alias.h:1645
midaspace::DOFsPerNode
DOFsPerNode
Definition: alias.h:700
midaspace::FETSet_e2i_SIFEL
int FETSet_e2i_SIFEL(FiniteElementType fet)
Definition: alias.h:1206
gelib.h
General functions.
midaspace::FFF_VLNA
special one time format for sculpture GDF142
Definition: alias.h:651
midaspace::CrossSectType
CrossSectType
Definition: alias.h:435
midaspace::PAType_e2i_SIFEL
int PAType_e2i_SIFEL(PAType val)
Definition: alias.h:421
midaspace::FETSet_e2s_OOFEM
const char * FETSet_e2s_OOFEM(FiniteElementType feto)
Definition: alias.h:1187
midaspace::ECN_convert_edges_brick
int ECN_convert_edges_brick(bool i2e, int id, femFileFormat fff)
Definition: alias.h:1812
midaspace::FFF_VTU
MIDAS i/o vtu ff.
Definition: alias.h:637
midaspace::FFF_SIFEL
sifel i/o native ff
Definition: alias.h:644
midaspace::FiniteElementTypeSet::is_equal_to
bool is_equal_to(const FiniteElementTypeSet fets) const
equality
Definition: alias.h:1034
midaspace::FFF_VTX
MIDAS i/o vt* ff.
Definition: alias.h:648
midaspace::FETSet_e2set
void FETSet_e2set(FiniteElementType fet, FiniteElementTypeSet *set)
FET to FETset.
Definition: alias.h:1113
midaspace::IntPointSet_fet2e_comp
IntPointSet IntPointSet_fet2e_comp(FiniteElementType fet)
FET to IPS for displacement computation (integration of stiffness matrix)
Definition: alias.h:1414
midaspace::MaterialType
MaterialType
Definition: alias.h:505
midaspace::TRIANGLE_IPN_OOFEM_4_I2E
static const int TRIANGLE_IPN_OOFEM_4_I2E[4]
Definition: alias.h:1648
STRCMP
#define STRCMP
Definition: alias.h:44
midaspace::RTN_transpunknowns
unknows in transport, N=ndofs
Definition: alias.h:207
midaspace::BRICK_EN_OOFEM
static const int BRICK_EN_OOFEM[12]
Definition: alias.h:1807
midaspace::CellGeometry_e2i_VTK
int CellGeometry_e2i_VTK(CellGeometry cg)
Definition: alias.h:911
midaspace::femFileFormatEtoS
const char * femFileFormatEtoS(femFileFormat fff)
Definition: alias.h:673
errol
#define errol
Definition: gelib.h:142
midaspace::FFF_VTP
MIDAS i/o vtp ff.
Definition: alias.h:636
midaspace::FFF_OOFEM
oofem i/o native ff
Definition: alias.h:643
midaspace::ECN_convert_ips_triangle
int ECN_convert_ips_triangle(bool i2e, int id, femFileFormat fff, IntPointSet ips)
Definition: alias.h:1651
_errorr2
#define _errorr2(_1, _2)
Definition: gelib.h:145
midaspace::StiffMatrixType_i2e_SIFEL
StiffMatrixType StiffMatrixType_i2e_SIFEL(int val)
Conversion from "SIFEL int" to "enum" identificator of "stiffness matrix type".
Definition: alias.h:271
midaspace::SStype_i2e_SIFEL
SStype SStype_i2e_SIFEL(int val)
bar=1,plbeam=2,spacebeam=5,,plate=15,axisymm=20,shell=25,spacestress=30
Definition: alias.h:971
midaspace::MaterialType_i2e_SIFEL
MaterialType MaterialType_i2e_SIFEL(int val, PAGroup pg)
Definition: alias.h:527
midaspace::CellGeometry
CellGeometry
Definition: alias.h:840
midaspace::BRICK_EN_SIFEL_E2I
static const int BRICK_EN_SIFEL_E2I[12]
Definition: alias.h:1810
midaspace::IPS_give_ip_coord_native
double IPS_give_ip_coord_native(int i, IntPointSet ips, PoinT &coords)
Definition: alias.h:1332
midaspace::ECN_convert_e2i
int ECN_convert_e2i(int id, int compdim, int ord, CellGeometry cg, femFileFormat fff)
External to Internal conversion.
Definition: alias.h:1539
midaspace::IntPointSet
IntPointSet
Definition: alias.h:1248
midaspace::ECN_convert_nodes_quadrangle
int ECN_convert_nodes_quadrangle(bool i2e, int id, femFileFormat fff)
Definition: alias.h:1693
midaspace::SPRpatchType
SPRpatchType
typ spr patche, závisí na typu/geometrii elementů
Definition: alias.h:338
arrays.h
Structs Elem3D, PoinT and VectoR; classes Array, Array1d, Xscal, Dscal, Xvctr, Lvctr, Dvctr, Xmtrx, Lmtrx and Dmtrx.
midaspace::CrossSectType_e2i_SIFEL
int CrossSectType_e2i_SIFEL(CrossSectType val, PAGroup pg)
Definition: alias.h:480
midaspace::TRIANGLE_IPN_OOFEM_3_E2I
static const int TRIANGLE_IPN_OOFEM_3_E2I[3]
Definition: alias.h:1646
midaspace::CellGeometry_i2e_HN
CellGeometry CellGeometry_i2e_HN(int val)
Definition: alias.h:847
midaspace::LinearSolverType
LinearSolverType
Linear solver type.
Definition: alias.h:293
midaspace::MeshGenerator
MeshGenerator
type of mesh generator
Definition: alias.h:191
midaspace::DOFsPerNode2dofBCmask
int * DOFsPerNode2dofBCmask(DOFsPerNode od)
Definition: alias.h:787
midaspace::FFF_T3d
t3d i/o native ff
Definition: alias.h:641
midaspace::ECN_convert_edges_quadrangle
int ECN_convert_edges_quadrangle(bool i2e, int id, femFileFormat fff)
Definition: alias.h:1714
midaspace::RTN_reaction
reaction, N=ndofs
Definition: alias.h:206
midaspace::ECN_convert_nodes_brick
int ECN_convert_nodes_brick(bool i2e, int id, femFileFormat fff)
Definition: alias.h:1779
midaspace::FFF_UNV
MIDAS i/o unv ff.
Definition: alias.h:638
midaspace::BRICK_FN_SIFEL_E2I
static const int BRICK_FN_SIFEL_E2I[6]
Definition: alias.h:1839
midaspace::ECN_convert_ips_brick
int ECN_convert_ips_brick(bool i2e, int id, femFileFormat fff, IntPointSet ips)
Definition: alias.h:1869
midaspace::ECN_convert_faces_brick
int ECN_convert_faces_brick(bool i2e, int id, femFileFormat fff)
Definition: alias.h:1841
midaspace::MMprocessingStoE
MMprocessing MMprocessingStoE(const char *val)
Definition: alias.h:622
midaspace::BRICK_NN_SIFEL
static const int BRICK_NN_SIFEL[8]
Definition: alias.h:1777
midaspace::FEApproximation_s2e
FEApproximation FEApproximation_s2e(const char *val)
Definition: alias.h:944
midaspace::BCType_s2e_OOFEM
BCType BCType_s2e_OOFEM(const char *val)
Definition: alias.h:577
midaspace::DOFtype_i2s_ANSYS
const char * DOFtype_i2s_ANSYS(DOFtype dt)
Definition: alias.h:807
midaspace::ECN_convert_edges_beam
int ECN_convert_edges_beam(bool i2e, int id, femFileFormat fff)
Definition: alias.h:1588
midaspace::MaterialType_s2e_OOFEM
MaterialType MaterialType_s2e_OOFEM(const char *val)
Definition: alias.h:511
midaspace::FETSet_set2s_OOFEM
const char * FETSet_set2s_OOFEM(const FiniteElementTypeSet *set, PAGroup pg)
Definition: alias.h:1232
midaspace::LinearSolverType_e2i_SIFEL
int LinearSolverType_e2i_SIFEL(LinearSolverType val)
Conversion from "enum" to "SIFEL int" identificator of "linear solver type".
Definition: alias.h:305
midaspace::IntPointSet_fets2ips
IntPointSet IntPointSet_fets2ips(const FiniteElementTypeSet *set)
Definition: alias.h:1367
midaspace::FFF_VTK
MIDAS i/o vtk ff.
Definition: alias.h:635
midaspace::FiniteElementType
FiniteElementType
Definition: alias.h:995
_errorr
#define _errorr(_1)
Definition: gelib.h:151
midaspace::RTN_ada_h_act
adaptivity, element characteristic size, actual
Definition: alias.h:209
midaspace::SStype
SStype
type of stress/strain state of element; especially results depends on this variable => described at M...
Definition: alias.h:954
midaspace::DOFtype
DOFtype
DOF type == physical meaning of dof; see help.txt.
Definition: alias.h:698
midaspace::ECN_convert_nodes_beam
int ECN_convert_nodes_beam(bool i2e, int id, femFileFormat fff)
Definition: alias.h:1587
midaspace::FETSet_set2e
FiniteElementType FETSet_set2e(const FiniteElementTypeSet *set, Solver sol, PAGroup pg)
FETset to FET.
Definition: alias.h:1145
midaspace::CrossSectType_i2e_SIFEL
CrossSectType CrossSectType_i2e_SIFEL(int val, PAGroup pg)
Definition: alias.h:461
midaspace::RTN_ada_refder
adaptivity, refined derivatives
Definition: alias.h:208
midaspace::IntPointSet_s2e
IntPointSet IntPointSet_s2e(const char *val)
Definition: alias.h:1305
midaspace::OOFEMdomain2DOFsPerNode
DOFsPerNode OOFEMdomain2DOFsPerNode(const char *od)
Definition: alias.h:726
midaspace::DOFtype_i2s_force_ANSYS
const char * DOFtype_i2s_force_ANSYS(DOFtype dt)
Definition: alias.h:820
midaspace::FFF_ANSYS
ansys i/o native ff
Definition: alias.h:642
midaspace::MMprocessing
MMprocessing
Definition: alias.h:616
midaspace::EntityType_type2dim_jktkT3d
int EntityType_type2dim_jktkT3d(long val)
Conversion from "entity type by t3d and jktk" to "dimension".
Definition: alias.h:317
midaspace::FETSet_si2set
void FETSet_si2set(const char *str, int val, Solver sol, PAGroup pg, FiniteElementTypeSet *set)
Definition: alias.h:1139
midaspace::ECN_convert_edges_triangle
int ECN_convert_edges_triangle(bool i2e, int id, femFileFormat fff)
Definition: alias.h:1624
midaspace::ECN_convert_nodes_triangle
int ECN_convert_nodes_triangle(bool i2e, int id, femFileFormat fff)
Definition: alias.h:1603
midaspace::ResultTypesAtElem
ResultTypesAtElem
Result type at element.
Definition: alias.h:240
midaspace::MaterialType_e2s_OOFEM
const char * MaterialType_e2s_OOFEM(MaterialType val)
Definition: alias.h:517
midaspace::FETSet_set2i_SIFEL
int FETSet_set2i_SIFEL(const FiniteElementTypeSet *set, PAGroup pg)
Definition: alias.h:1237
midaspace::FiniteElementTypeSet
tato struktura by mela obsahovat vsechny potrebne informace pro urceni konkretni implementace konecne...
Definition: alias.h:1019
midaspace::PAType_s2e_OOFEM
PAType PAType_s2e_OOFEM(const char *str)
Definition: alias.h:399
midaspace::DOFsPerNode2rotDOFsPresence
bool DOFsPerNode2rotDOFsPresence(DOFsPerNode od)
Definition: alias.h:772
midaspace::StiffMatrixType
StiffMatrixType
Stiffness matrix type.
Definition: alias.h:269
midaspace::FiniteElementTypeSet::beCopyOf
void beCopyOf(const FiniteElementTypeSet src)
copy
Definition: alias.h:1041
midaspace::IPS_inputfile_value_e2i_OOFEM
int IPS_inputfile_value_e2i_OOFEM(IntPointSet val)
val je cislo ze vstupaku oofemu
Definition: alias.h:1291
midaspace::ECN_convert_faces_triangle
int ECN_convert_faces_triangle(bool i2e, int id, femFileFormat fff)
Definition: alias.h:1634
midaspace::ResultTypesAtNode
ResultTypesAtNode
Result type at node.
Definition: alias.h:204
midaspace::cRTN
count of ...
Definition: alias.h:211
midaspace::CellGeometry_e2i_JKTK
int CellGeometry_e2i_JKTK(CellGeometry cg)
Definition: alias.h:880
midaspace::TRIANGLE_IPN_OOFEM_4_E2I
static const int TRIANGLE_IPN_OOFEM_4_E2I[4]
Definition: alias.h:1649
midaspace::CellGeometry_i2e_VTK
CellGeometry CellGeometry_i2e_VTK(int val)
Definition: alias.h:893
midaspace::RVType
RVType
Result variable type.
Definition: alias.h:194
midaspace::SStype_e2i_SIFEL
int SStype_e2i_SIFEL(SStype val)
Definition: alias.h:980
midaspace::FiniteElementTypeSet::approx
FEApproximation approx
Definition: alias.h:1024
midaspace::IntPointSet_give_number_ips
int IntPointSet_give_number_ips(IntPointSet ips)
give number of int. points
Definition: alias.h:1316
midaspace::EntityType_dim2type_jktkT3d
int EntityType_dim2type_jktkT3d(int val)
Conversion from "dimension" to "entity type by t3d and jktk".
Definition: alias.h:332
midaspace::RTN_ada_h_new
adaptivity, element characteristic size, new
Definition: alias.h:210
midaspace::FFF_POLYLINE
MIDAS input native ff - for mesh of polylines.
Definition: alias.h:647
midaspace::VTKPDtopology
VTKPDtopology
VTK type of cell topology for POLYDATA.
Definition: alias.h:931
midaspace::FFF_JKTK
jktk i/o
Definition: alias.h:639
midaspace::PAGroup
PAGroup
The group of problem analysis.
Definition: alias.h:367
midaspace::FFF_MELNIK
special one time format for bridge in Melnik
Definition: alias.h:650
midaspace::CellGeometry_i2e_JKTK
CellGeometry CellGeometry_i2e_JKTK(int val)
Definition: alias.h:864
midaspace::PAGroup_t2g
PAGroup PAGroup_t2g(PAType val)
Definition: alias.h:383
midaspace::BCType_e2s_OOFEM
const char * BCType_e2s_OOFEM(BCType val)
Definition: alias.h:587
midaspace::StiffMatrixType_e2i_SIFEL
int StiffMatrixType_e2i_SIFEL(StiffMatrixType val)
Conversion from "enum" to "SIFEL int" identificator of "stiffness matrix type".
Definition: alias.h:280
midaspace::femFileFormatStoE
femFileFormat femFileFormatStoE(const char *fff)
Definition: alias.h:653
midaspace::RTN_displacement
displacement, N=ndofs
Definition: alias.h:205
midaspace::FEApproximation
FEApproximation
finite element approximation
Definition: alias.h:937
midaspace::ECN_convert_i2e
int ECN_convert_i2e(int id, int compdim, int ord, CellGeometry cg, femFileFormat fff)
INTERNAL to EXTERNAL conversion.
Definition: alias.h:1504
midaspace::FETSet_e2s_ANSYS
const char * FETSet_e2s_ANSYS(FiniteElementType fet)
Definition: alias.h:1221
midaspace::ECN_convert_ips_quadrangle
int ECN_convert_ips_quadrangle(bool i2e, int id, femFileFormat fff, IntPointSet ips)
Definition: alias.h:1733
midaspace::FFF_MIDAS
MIDAS input native ff - pro specialni potreby.
Definition: alias.h:646
midaspace::FiniteElementTypeSet::expltype
FiniteElementType expltype
Definition: alias.h:1026
This reference manual is part of the MIDAS documentation. Copyright (c) 2005-2013 Ladislav Termit Svoboda. Generated on Fri Mar 21 2014 11:39:43 for MIDAS by doxygen 1.8.6.