problem.h

Go to the documentation of this file.

#ifndef MIDAS_PROBLEM_H
#define MIDAS_PROBLEM_H

#include "alias.h"
#include "taux.h"

#include "gpa.h"


namespace midaspace {

enum OperationMode { OM_Void, OM_Convert, OM_Design2design, OM_Design2solver, OM_Solver2design, OM_Test };
enum BlockName { BN_Void, BN_COMM, BN_OFN, BN_ANAL, BN_DOMN, BN_OUTP, BN_CS, BN_MAT, BN_BC, BN_PV, BN_NODES, BN_ELEMS, BN_NL, BN_CEL, BN_CFL, BN_CBL, BN_HN, BN_RAN, BN_LTF, BN_EXTRCT, BN_FIXED };

enum ProbDescBoolOpt {
  PDBO_allElemsProp1 ,          // all elements should have property 0
  PDBO_BondEndRFran ,           // reinforcement node on endface is bonded by: 0 - hangingnodes, 1 - rigidarmnode
  PDBO_uncfrd ,                 // 
  PDBO_MultipNode ,             // multiple nodes    will be eliminated ; after elimination, this bool is set to false
  PDBO_MultipElem ,             // multiple elements will be eliminated ; after elimination, this bool is set to false
  PDBO_preserveGeom ,           // preserve input geometry, zatim je to primitivne, jen pro jeden vtx soubor
  PDBO_RIGIDmatToRAN ,          // convert RIGID material to Rigid Arm
  PDBO_divideQuads,             // divide quadrangles into two triangles
  PDBO_hingedBeamToTruss,       // beam with condensed rotation DOFs is converted to truss
  PDBO_tmpFileWrite2hdd,        // control print sovler input file in solver2design mode
  PDBO_cutRF,                   // cut outside reinforcement bars
  PDBO_OUT_print_property ,     // print 
  PDBO_OUT_print_parent_property ,     // print 
  PDBO_OUT_print_model_parent , // print 
  PDBO_OUT_print_CSusage ,      // print cross section usage
  PDBO_OUT_Test ,               // print test
  PDBO_OUT_MeshQual ,           // print mesh quality file
  PDBO_OUT_MeshStats ,          // print mesh stats
  PDBO_OUT_origelemid ,         // print original element ids
  PDBO_OUT_CabTenOnly ,         //
  PDBO_OUT_charVTK,             // print vtk with IDs of materials, CSs, 
  PDBO_OUT_solverINctrl,        // control print sovler input file in solver2design mode
  PDBO_OUT_args,                // print argumets to extra file
  // T3d
  PDBO_P_mesh_quads,            // print argumets to extra file
  // OOFEM
  PDBO_P_rershell,              // rershell 
  PDBO_P_dw,                    // zatim docasne, nez vyresim ncomp u BC_DW 
  PDBO_P_refder,                // zatim docasne, refder
  //
  PDBO_ansys,                   // docasne jen pro ansys stabilitu
  PDBO_stability,               // docasne jen pro stabilitu v donkym pomoci parametru
  PDBO_Vlna ,                   // for temporary project VLNA
  PDBO_melnik ,                 // for temporary project melnik
  
  cPDBO };                      // count of ...
//PDBO_OUT_Rslts ,              // print results

//*  ********************************************************************************************
//*  *** *** *** ***                        CLASS PROBDESC                        *** *** *** ***
//*  ********************************************************************************************
class Problem
{
  //  ***************************
  //  /**   @name AUXILIARY   **/
  //  ***************************
  //  @{
 public:
  char  *solver_file_ptr;
  size_t solver_file_size; // A null byte '\0' is maintained at the end of the buffer. It is not included in the size value stored at size.
  
  char *args;                                // arguments
  
  // standard output driver
 protected:
  StdoutDriver *so_driver;
 public:
  const StdoutDriver* sodriver(void) const { return so_driver; }
  // @}
  
  
  //  ******************************
  //  /**   @name GENERAL INFO   **/
  //  ******************************
  //  @{
 protected:
  bool PDBO[cPDBO];                          // array with ProbDesc Boolean Options
  
  //*  *** OPERATION MODE ***
  OperationMode OM;                          // operation mode
  
  //*  *** INPUT ***
  char     *IN_Path;                         // path for input files
  FiLe     *IN_ctrlfile;                     // control file
  GPA<FiLe> IN_mdlFiLes;                     // files with models
  GPA<FiLe> IN_mshFiLes;                     // files with meshes
  FiLe     *IN_VTKaddata;                    // file with additional data of VTK format - full
  FiLe     *IN_VTKaddatasprs;                // file with additional data of VTK format - sparse
  FiLe     *IN_file_results;                 // file with results - main output form analysis package
  FiLe     *IN_file_results_addataVTK;       // file with results - additional data of VTK format [full]
  FiLe     *IN_file_bgm;                     // file with back ground mesh
  double    IN_meshGen_elemSize;             // mesh generation - size of generated elements
  int       IN_meshGen_elemCount;            // mesh generation - count of generated elements at one model element
  long      IN_numdom;                       // nuber of domains: for parallel computation is >1, for sequent is equal to 1
  
  //*  *** PROCESS ***
  Solver     P_solver;                       // type of solver
  FiLe      *P_solverbinary;                 // binary commad
  int        P_solverver;                    // version of solver; OOFEM 1.9 => P_solverver == 19
  //
  MeshGenerator P_mesher;                    // type of mesher = mesh generator
  FiLe         *P_mesherbinary;              // binary commad
  AdaptivityParameters *adpa;                  // adaptivity parameters
  
  
  //*  *** OUTPUT ***
  char     *OUT_Path;                        // path for output file
  FiLe     *OUT_moFILE;                      // main output base file name
  long      OUT_printStep;                   // first, last and printStep-th step will be printed

  //* temporary
  int       P_melnik;                        // temporary for melnik project
  
  //* STATE
  bool fulldata;                             // full data for structural analysis; false == geometry data only;
  bool readedchars;                          // characteristics was readed
  
 public:
  //*  *** SET ***
  void set_PDBO          (ProbDescBoolOpt pdbo, bool val) { PDBO[pdbo] = val; }
  //
  void set_OM            (OperationMode val) { OM            = val; }
  //
  void set_IN_Path                   (char         *val) { IN_Path                   = val; }
  void set_IN_ctrlfile               (FiLe         *val) { IN_ctrlfile               = val; }
  void set_IN_VTKaddata              (FiLe         *val) { IN_VTKaddata              = val; }
  void set_IN_VTKaddatasprs          (FiLe         *val) { IN_VTKaddatasprs          = val; }
  void set_IN_file_results           (FiLe         *val) { IN_file_results           = val; }
  void set_IN_file_results_addataVTK (FiLe         *val) { IN_file_results_addataVTK = val; }
  void set_IN_bgm                    (FiLe         *val) { IN_file_bgm               = val; }
  void set_IN_meshGen_elemSize       (double        val) { IN_meshGen_elemSize       = val; }
  void set_IN_meshGen_elemCount      (int           val) { IN_meshGen_elemCount      = val; }
  void set_IN_numdom                 (long          val) { IN_numdom                 = val; }
  void add_IN_mdlFiLe                (FiLe         *val) { IN_mdlFiLes.add(val); }
  void add_IN_mshFiLe                (FiLe         *val) { IN_mshFiLes.add(val); }
  //
  void set_OUT_Path            (char         *val) { OUT_Path      = val; }
  void set_OUT_moFILE          (FiLe         *val) { OUT_moFILE    = val; }
  void set_OUT_printStep       (long          val) { OUT_printStep = val; if (val<1) _errorr("OUT_printStep should be greater then zero"); }
  //
  void set_melnik              (int           val) { P_melnik      = val; }
  //
  void set_readedchars         (bool          val) { readedchars   = val; }
  //
  //void set_P_Solver            (enumSolver    val) { P_solver       = val; }
  //void set_P_solverbinary      (FiLe         *val) { P_solverbinary = val; }
  void set_OOFEM_ver           (int           val) { P_solverver    = val; }
  void set_P_binary_solver     (FiLe *val, Solver        val2) { P_solverbinary= val;  P_solver = val2; }
  //
  void set_P_binary_mesher     (FiLe *val, MeshGenerator val2) { P_mesherbinary= val;  P_mesher = val2; }
  //
  long set_adpa                (char **argv) { adpa = new AdaptivityParameters();  return adpa->initialize_from(argv); }
  
  //
  const FiLe*   give_P_solverbinary (void) const { return P_solverbinary; }
  //
  MeshGenerator give_P_mesher (void) const { return P_mesher; }
  const FiLe*   give_P_mesherbinary (void) const { return P_mesherbinary; }
  AdaptivityParameters* give_adpa (void) const { return adpa; }
  
  //
  void set_defautlt_meshGen_elemSize (void);
  
  //*  *** GET ***
  bool give_PDBO (ProbDescBoolOpt pdbo)   const { return PDBO[pdbo]; }
  //
  OperationMode give_OM            (void) const { return OM; }
  //
  const char*    give_IN_Path                   (void) const { return IN_Path;      }
  const FiLe*    give_IN_file_results           (void) const { return IN_file_results; }
  const FiLe*    give_IN_file_results_addataVTK (void) const { return IN_file_results_addataVTK; }
  const FiLe*    give_IN_file_bgm               (void) const { return IN_file_bgm; }
  double         give_IN_meshGen_elemSize       (void) const { if (IN_meshGen_elemSize < 0) ((Problem*)this)->set_defautlt_meshGen_elemSize();  return IN_meshGen_elemSize; }
  int            give_IN_meshGen_elemCount      (void) const { return IN_meshGen_elemCount; }
  //
  int            give_P_OOFEM_ver               (void) const { return P_solverver;   }
  //
  const char*    give_OUT_Path            (void) const { return OUT_Path;      }
  const FiLe*    give_OUT_moFILE          (void) const { return OUT_moFILE;    }
  long           give_OUT_printStep       (void) const { return OUT_printStep; }
  //
  int            give_melnik              (void) const { return P_melnik; }
  //
  bool           give_fulldata            (void) const { return fulldata;      }
  // @}
  
  
  //  ***************************
  //  /**   @name MESH DATA   **/
  //  ***************************
  //  @{
  //*  ***  HEAD  ***
 protected:
  char *comment;                                      // problem comment
  ProblemAnalysis *ProbAnal;                          // problem analysis
  
  //*  PROBLEM_DOMAIN
  DOFsPerNode DOFspnod;                               // domain type == default DOFs per node (see help.txt)
  int *DOFbc_mask;                                    // DOF boundary conditions mask
  // ...
  char *output_file;                                  // name of output file of solved problem
  
  //  [OOFEM] only
  char *OOF_output_rec;                               // OOFEM line of output
  
  //  [SIFEL] only - dej jim predponu SIF_
  int stdout_print_level;                             // level of information print to standard output
  //
  int text_output;                                    // text output [SIFEL]
  int to_nodes, to_nodes_type;                        // nodes, type
  int ton_displ, ton_displ_type;                      // displacement, type
  int ton_strain, ton_strain_type, ton_strain_transf; // strain, type, transf
  int ton_stress, ton_stress_type, ton_stress_transf; // stress, type, transf
  int ton_other, ton_other_type;                      // other, type, transf
  int ton_react;                                      // reactions
  int to_elems, to_elems_type;                        // elements, type
  int toe_strain, toe_strain_type, toe_strain_transf; // strain, type, transf
  int toe_stress, toe_stress_type, toe_stress_transf; // stress, type, transf
  int toe_other, toe_other_type;                      // other, type, transf
  int toe_nevim;                                      // ???
  //
  int grafic_output;                                  // grafic output
  
 public:
  //*  *** SET ***
  void set_DOFspnod (DOFsPerNode val) { DOFspnod  = val; }
  //*  *** GET ***
  PAGroup      give_analgroup    (void) const ; //{ return ProbAnal->give_analgroup(); }
  PAType       give_analtype     (void) const ; //{ return ProbAnal->give_analtype(); }
  PAType       give_analloctype  (void) const ; //{ return ProbAnal->give_analloctype(); }
  long         give_nsteps       (void) const ; //{ return ProbAnal->give_nsteps(); }
  
  const char*  give_output_file  (void) const { return output_file; }
  DOFsPerNode  give_DOFspnod     (void) const { return DOFspnod; }
  int          give_global_nDOFs (void) const { return DOFsPerNode2nDOFs(DOFspnod); }
  const int*   give_DOFbc_mask   (void) const { if (!DOFbc_mask) ((Problem*)this)->DOFbc_mask = DOFsPerNode2dofBCmask (DOFspnod);  return DOFbc_mask; }
  //
  bool rotDOFsPresence  (void) const { return DOFsPerNode2rotDOFsPresence (DOFspnod); }
  
  
  //*  ***   ATTRIBUTES   ***
 protected:
  //
  GPA<CrossSection>     CSs;         // cross-sections
  GPA<Material>         Mats;        // materials
  GPA<BoundaryCond>     BCs;         // boundary conditions
  //
  GPA<PointDOFsBCPM>    PVs;         // prescribed values
  GPA<LoadTimeFunction> OOltfs;      // OOFEM load time functione
  GPA<Attribute>        OOextrs;     // OOFEM extract lines
  //
  GPA<ABC_NLoad>        NLs;         // NL  - Assignment of Nodal Loads
  GPA<ABC_CELoad>       CELs;        // CEL - Assignment of Constant Edge Loads
  GPA<ABC_CFLoad>       CFLs;        // CFL - Assignment of Constant Face Loads
  GPA<ABC_CBLoad>       CBLs;        // CBL - Assignment of Constant Body Loads
  GPA<AssignFix>        Fixed;       // Fixed - Assignment of fixed entities to elements
  //
      ElemAttribs *domainElAt;       // superior element attributes according to   domain of owner
  GPA<ElemAttribs>   geomElAt;       // superior element attributes according to geometry of owner
  //
  GPA<PointAttribs>     NdAts;       // general node attributes
  GPA<ElemAttribs>      ElAts;       // superior element attributes according to property of owner
  //
  //Lvctr                 FixElems;    // array of IDs of elements with fixed nodes
  //GPA<Lvctr>            FixNodes;    // array of IDs of nodes fixed to elems
  
  //
  Lvctr              sifMats;      // counts of sifel materials
  Lvctr              sifCSs;       // counts of sifel cross sections
  Lvctr              sifBCs;       // counts of sifel boundary conditions
  
  
 public:
  //*  *** SET ***
  void domainElAt_initialize_from (const char *str                 );
  void   geomElAt_initialize_from (const char *str, CellGeometry cg);
  void set_domainElAt (FEApproximation val);
  //void set_domainElAt (LCSdirection dir, LCStype typ, long num) { if (lcs) _errorr("e");  lcs = new LocalCoordSystem(dir, typ, num); }
  //
  void alloc_geomElAt (CellGeometry cg);
  void set_geomElAt (CellGeometry cg, DOFsPerNode val);
  void set_geomElAt (CellGeometry cg, SStype val);
  void set_geomElAt (CellGeometry cg, FEApproximation val);
  void set_FETS (const char *skupina, const char *str);
  void set_lcs (LCSdirection dir, LCStype typ, long num);
  
  //
  const BoundaryCond* add_find_BC (BoundaryCond* val); // find identical or add new BC
  const BoundaryCond* add_uniq_BC (BoundaryCond* val); // add new BC
  void add_sifMats (int i) { sifMats[i]++; }
  void add_sifCSs  (int i) { sifCSs [i]++; }
  void add_sifBCs  (int i) { sifBCs [i]++; }
  const BoundaryCond* switch_BC (const BoundaryCond* bc, DOFsPerNode dpn_old, DOFsPerNode dpn_new);
  
  //*  *** GET ***
  const GPA<BoundaryCond>* give_BCs (void) const { return &BCs; }
  //
  CrossSection*  give_CS      (long i) const { return CSs .at_or_null(i); }
  Material*      give_Mat     (long i) const { return Mats.at_or_null(i); }
  BoundaryCond*  give_BC      (long i) const { return BCs .at_or_null(i); }
  PointDOFsBCPM* give_PV      (long i) const { return PVs .at_or_null(i); }
  long           give_sifMats (long i) const { return sifMats[i]; }
  long           give_sifCSs  (long i) const { return sifCSs [i]; }
  long           give_sifBCs  (long i) const { return sifBCs [i]; }
  
  long          give_cCS     (void)   const { return CSs(); }
  
  CrossSection* give_CS_of_type (CrossSectType type, int id) const;
  Material*     give_Mat_of_type (MaterialType type, int id) const;
  
  ElemAttribs* give_ElAt_of_domain (void)            const { return domainElAt; }
  ElemAttribs* give_ElAt_with_geom (CellGeometry eg) const { return geomElAt[eg]; }
  ElemAttribs* give_ElAt_with_prop (long prop)       const;
  
  PointAttribs* give_NdAt_with_prop (long prop) const;
  PointAttribs* givealloc_NdAt_with_prop (long prop);
  
  const CrossSection* give_3dCS(void);
  
  // rm material MAT_RIGID
  void rm_MAT_RIGID (void);
  
  
  //*  ***   GEOMETRY   ***
 protected:
  GPA<Model>            Models;    // model - geometry information about model
  GPA<Mesh>             Meshes;    // mesh - geometry information about mesh
  
 public:
  //*  *** SET ***
  void add_mesh   (Mesh *val)         { Meshes.add(val); }
  void wedge_mesh (long i, Mesh *val) { Meshes.wedge(i, val); }
  //*  *** GET ***
  Model* give_Model  (long i) const { return Models.at_or_null(i); }
  Mesh*  give_Mesh   (long i) const { return Meshes.at_or_null(i); }
  long   give_cModel (void)   const { return Models(); }
  long   give_cMesh  (void)   const { return Meshes(); }
  //
  Geometry* give_primary_geometry (void) const;
  // @}
  
  
  
  //  *********************************
  //  /**   @name GENERAL METHODS   **/
  //  *********************************
  //  @{
 public:
  Problem (StdoutDriver *sodrv);
  ~Problem ();
  
  void solve (void);
  void main_OM_design2solver2design (void);
  void main_OM_testing (void);
  
  void initialization (void);
  void finitialization (void);
  void checkConsistency (void) const;
  
  void loadedSurfaces (FILE *stream, FElement *elem);
  void model_meshing (void);
  void switch_node_pointer (Point *oldnod, Point *newnod);
  
  //*  *** READ ***
  void read_head_and_chars (Stream *stream, char &DATASET);
  
  void read_ctrlfile (void);
  void read_characteristics (Stream *stream);
  void read_characteristics_core (Stream *stream, const char *key);
  void read_block_analysis (Stream *stream);
  void read_block_output (Stream *stream);
  void read_block (Stream *stream, BlockName bn);
  //
  void read_models (void);
  void read_meshes (void);
  void read_geometry_VTK      (Geometry* geom, const char *filename);
  void read_geometry_VTK_core (Geometry* geom, Stream *stream);
  void read_addata_VTK        (Geometry* geom, const char *filename, bool sparse);
  void read_mesh_OOFEM        (Mesh*     mesh, const char *filename);
  void read_mesh_SIFEL        (Mesh*     mesh, const char *filename);
  void read_polylines     (const char *filename);
  void read_polylines_vtx (const char *filename);
  void read_addata (bool mdl);
  void read_addataRSLT (bool mdl);
  
  //*  ***  PRINT OUTPUT  ***
  void print_control (void) const;
  void print_input_OOFEM (void);
  void print_input_SIFEL (void) const;
  void print_input_ANSYS (void) const;
  // @}
  
};

} // namespace midaspace

#endif // MIDAS_PROBLEM_H