mesh.h

Go to the documentation of this file.

//********************************************************************************************************
// code:                          ###  ###  #####   ####  ##  ##
//                       ##  ##   ########  ##     ##  ## ##  ##
//                       ##  ##   ## ## ##  ###    ##     ######
//                       ##  ##   ##    ##  ##     ##  ## ##  ##
//                       #####    ##    ##  #####   ####  ##  ##
//                       ##
//
// name:           mesh.h
// author(s):      Ladislav Svoboda
// language:       C, C++
// license:        This program is free software; you can redistribute it and/or modify
//                 it under the terms of the GNU Lesser General Public License as published by
//                 the Free Software Foundation; either version 2 of the License, or
//                 (at your option) any later version.
//
//                 This program is distributed in the hope that it will be useful,
//                 but WITHOUT ANY WARRANTY; without even the implied warranty of
//                 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//                 GNU Lesser General Public License for more details.
//
//                 You should have received a copy of the GNU Lesser General Public License
//                 along with this program; if not, write to the Free Software
//                 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//********************************************************************************************************
#ifndef MUMECH_MESH_H
#define MUMECH_MESH_H

#include "types.h"

#include <stdlib.h>


namespace mumech {

class Problems;
class Problem;
class mNode;
class mElement;


enum MeshType { MT_VOID, MT_REGULAR, MT_GENERAL };


class Mesh
{
 public:
  // ASSIGNED PROBLEMS
  long id;                        
  int npa;                        
  int np;                         
  const Problems **P;            
  
  // MESH GEOMETRY
  // collapsed dimension
  // -1 = no mesh - no readed geometry
  //  0 = 3d mesh - no axis collapsed
  //  1 = 2d mesh -  x axis collapsed
  //  2 = 2d mesh -  y axis collapsed
  //  3 = 2d mesh -  z axis collapsed
  int coll;
  int md;
  MeshType mtA;
  
  double point1[3];
  double point2[3];
  double delta[3];
  long   nsegs[3];
  
  double volume;                  
  
  
  // MESH COMPONENTS
  long      nNodes;               
  mNode    **Nodes;               
  long      nElems;               
  mElement **Elems;               
  
  
  // MESH RESULTS
  // Bude se drzet vice verzi vysledku, jedna pro kazdy problem, dimenze vysledku je stejna jako dimenze problemu,
  // pri porovnavani dvou vysledku ruznych dimenzi se musi redukovat na tu nejnizsi.
  int nLC;                        
  
  bool **no_dspl_rf;    
  bool **no_strn_rf;    
  bool **no_strs_rf;    
  
  bool **el_dspl_rf;    
  bool **el_strn_rf;    
  bool **el_strs_rf;    
  
  // double **displc;                ///<  averaged computed fields - displacement
  // double **strain;                ///<  averaged computed fields - strain
  // double **stress;                ///<  averaged computed fields - stress
  
  
 public:
  Mesh (long i, const Problems *p);
  Mesh (long i, const Problems *p, const Mesh *src);
  virtual ~Mesh();

  //
  int add_problem (const Problems *p);
  //
  void set_coll (int val);
  
  //
  int give_nlc (void) { if (nLC == -77)  errol;  return nLC; }
  bool give_twodim (void) const { if (md != 2 && md != 3) errol; return (md == 2); }
  
  //
  bool geom_is_readed (void) { return mtA != MT_VOID; }
  
  //int nstrain (void) const { return (this->coll==0 ? 6 : 3); }

  bool equal_dimensions (int pid) const;
  
  bool is_unset (void);
  void scale (const double *s);
  void local2global (const double *origin, const double *TInv);
  
  void shift_id (long snn, long sne);
  
  void read_geometry_file_vtk (const char *vtkMeshFile, int pid, int lc, bool add);
  
  void generate_regular_mesh (const double *p1, const double *p2, const long *n);

  void generate_regularSphereMesh_2d (int n, const double *a);
  void generate_regularSphereMesh_3d (int n, const double *a);

  
  void compute_node_fields (char flag, bool displc_flag, bool strain_flag, bool stress_flag, int pid, int lc, int nLC, PFCmode pfcMode);
  void compute_element_fields (char flag, bool displc_flag, bool strain_flag, bool stress_flag, int pid, int lc, int nLC, PFCmode pfcMode);
  
  
  
  void print_geometry_file_vtk (const char *rsltFileName, int pid, int lc, int nLC);


   
  
  double give_total_energy (int pid, int lc);
  double give_homog_energy (int lc, int pid=0);
  void integrate_energy_at_elems (int lc, int nLC);
  double give_error (int pid1, int pid2, int lc);
  
  
  double give_total_volume (void) const;
  
  double give_regular_element_volume (void) const;

 protected:
  void set_and_alloc_nNodes (long nn);
  void set_and_alloc_nElems (long ne);
  
 private:
  
  int file_type_s2e (const char *s);
  void set_node_rslt_flags (bool displc_flag, bool strain_flag, bool stress_flag, int pid, int lc, int nLC);
  void set_elem_rslt_flags (bool displc_flag, bool strain_flag, bool stress_flag, int pid, int lc, int nLC);
  
  
  void average_fields (bool displc_flag, bool strain_flag, bool stress_flag, int lc, int nLC);
  
  

};//end of class declaration

} // end of namespace mumech

#endif // end of MUMECH_MESH_H

/*end of file*/