meer.h

Zobrazit dokumentaci tohoto souboru.

#ifndef MEER_H
#define MEER_H

#ifdef DEVEL
#include "arrays.h"
#include "gpa.h"
#else
#include "arrays.h"
#include "gpa.h"
#endif


namespace meerspace {

//    SCIA
//    - enorm = MEER_EN_strain_stress;  energeticka norma (L2 je malo vypovidajici), nez posilat matici D, tak je asi jednodussi posilat stain + stress
//    - MEER_EDI_2d_4n_bilinear_2 - tento provek je prozatim defaultne predpokladany
//    
//  v teto funkci by mel byt cely proces adaptivniho vypoctu
//  zatim funguje takto: vypocet chyby
// 
//  domena - cely reseny problem, je rozdelena na regiony dle zvolene veliciny
//  region - mnozina elementu, na kterych je zvolena velicina konzistentni
//           kazdy element je prave v jednom regionu, regid == ident. cislo regionu; cislovano od 0
//  velicina - zvolena velicina, pomoci ktere se pocita chyba reseni
//   - strain - meni se se zmenou prurezu a materialu
//   - stress - meni se se zmenou prurezu
//   - sily   - nemeni se, je to integralni velicina
// 
//  momentalne pouzivam ???
//  stress => region se meni se zmenou prurezu
//            !!! ale na prutu misto stressu ukladam sily, co s tim?
// 
//  dva integracni sety
//  1. integracni set = sada integracnich bodu pro matici tuhosti, v kterych je vypocitano napeti vracene na vystupu
//  2. integracni set = sada integracnich bodu potrebnych pro vypocet rozdilu napeti
// 
// 

// *****************************************************************************************
// *****************************************************************************************
// *************************                  ENUM                  ************************
// *****************************************************************************************
// *****************************************************************************************

enum MEER_ErrorNorm {
  MEER_EN_Void ,           
  MEER_EN_strainDstrain ,  
  MEER_EN_strain_stress ,  
  MEER_EN_stressDstress ,  
  MEER_EN_stress_stress    
};

enum MEER_IPValues {
  MEER_IPV_Void ,
  MEER_IPV_strain ,
  MEER_IPV_stress
};

enum MEER_SPRpatchType {
  MEER_SPRPT_Void ,  
  MEER_SPRPT_2d      
};

enum MEER_SPRboundaryPatchType {
  MEER_SPRbpt_Void ,
  MEER_SPRbpt_basic = 1 ,
  MEER_SPRbpt_nobnd = 2
};


enum MEER_ElemDisplInterpol {
  MEER_EDI_Void ,
  
  MEER_EDI_2d_3n_linear ,
  
  MEER_EDI_2d_4n_bilinear_1 ,
  
  MEER_EDI_2d_4n_bilinear_2
};

class MEER;

//*
//*  structures
//*

struct REGION
{
  long id; // identification number
  
  //* DATA INICIALIZOVANA VE FUNKCI INITIALIZE()
  long nvals;      // počet složek průměrované veličiny (napětí) v integračních bodech. (pro napětí ve 2d je to 3)
  long sprtype;    // typ spr patche, viz enum MEER_SPRpatchType 
  
  // constructor
  REGION() { nvals = sprtype = 0; }
  // destructor
  virtual ~REGION() { }
};

struct NODE
{
  long id;         
  
  //* DATA INICIALIZOVANA VE FUNKCI INITIALIZE()
  PoinT coords;    
  
  //* DATA VYPOCTENA PRI BEHU ADAPTIVNI ANALYZY
  VectoR **normal;
  
  Dmtrx rotmat;
  
  int boundary;
  
  int bp_appli;    // viz fce MEER_SPR_nodal_recovery
  Lvctr bp_elems;  // viz fce MEER_SPR_nodal_recovery
  
  
  // constructor
  NODE() { id = -1; normal = NULL; boundary = 0; bp_appli = 0; rotmat.resize_ignore_vals(3,3); }
  // destructor
  virtual ~NODE() { delete [] normal; }
};

struct ELEMENT
{
  long id;            
  
  //* DATA INICIALIZOVANA VE FUNKCI INITIALIZE()
  long regid;         
  long nnodes;        
  long *nodes;        
  
  long  nIPs1;        
  PoinT *IPs1_coords; 
  
  //* DATA VYPOCTENA PRI BEHU ADAPTIVNI ANALYZY
  VectoR *normal;     
  
  
  // constructor
  ELEMENT() { regid = nnodes = 0; nodes = NULL;  nIPs1 = 0; IPs1_coords = NULL; normal = NULL; }
  // destructor
  virtual ~ELEMENT() { delete [] nodes; delete [] IPs1_coords; delete normal; }
};


// *****************************************************************************************
// *************************            MMM EEE EEE RRR             ************************
// *****************************************************************************************
class MEER
{
  // *****************************************************************************************
  // *************************             VEŘEJNÉ METODY             ************************
  // *****************************************************************************************
  // @{
 public:
  MEER (void);
  virtual ~MEER (void);
  
  double solve (double req_error);
  
  const double* give_error_at_elements_local  (void) const { return errori_loc.give_ptr2val(); }
  const double* give_error_at_elements_global (void) const { return errori_glob.give_ptr2val(); }

  const double* give_abs_error_at_elements  (void) const { return ei_aver.give_ptr2val(); }
  
  const double* give_h_old_at_elems (void) const { return h_old.give_ptr2val(); }
  const double* give_h_new_at_elems (void) const { return h_new.give_ptr2val(); }
  
  // Funkce vrací konstantní ukazatel na pole délky [počet uzlů].
  // V poli jsou uloženy vypočtené hodnoty charakteristické velikosti elementů sítě konečných prvků v místě příslušných uzlů.
  // Tyto hodnoty slouží pro generování nové sítě požadované hustoty.
  // const double* give_h_new_at_nodes    (void) const { return hnewi_node.give_ptr2val(); }
  
  // @}
  
  
  
  // *****************************************************************************************
  // *************************       SOUKROMÉ METODY A ATRIBUTY       ************************
  // *****************************************************************************************
  // @{
 private:
  MEER_IPValues valtype_1, valtype_2;
  Dvctr ***refined_node_values_1;
  Dvctr ***refined_node_values_2;
  
  Dvctr e2i, u2i, errori_loc, errori_glob, ei_aver;
  Dvctr h_old;
  Dvctr h_new;
  //Dvctr hnewi_node;
  
  void MEER_SPR_nodal_recovery (void);
  void MEER_SPR_compute_normals_at_elements (void);
  void MEER_SPR_basic_patch_detection (long regid);
  void MEER_SPR_bp_recovered_nodes_detection  (const NODE *node, GPA<const NODE> &bp_recovered_nodes);
  void MEER_SPR_patch_recovered_nodes_compute (long regid, GPA<const NODE> &bp_recovered_nodes, MEER_IPValues valtype, Dvctr **values, Lvctr &cavalues);
  int  MEER_SPR_give_number_coefficients(long sprtype);
  void MEER_SPR_give_polynom (long sprtype, const PoinT *coords, Dvctr &pol);
  
  void set_boundary_nodes (void);
  
  void MEER_error_estimatior (void);
  double MEER_mesh_refinement (double rerror);
  
  double give_element_characteristic_size (long elementID);
  double eval_interpol_fces_at_IPs2 (long elementID, int ipid, double *answer) const;
  
  // @}
  
  
  
  // *****************************************************************************************
  // *************************       CHRÁNĚNÉ METODY A ATRIBUTY       ************************
  // *****************************************************************************************
  // @{
 protected:
  
  //* *** Chráněné atributy ***
  
  //* GLOBAL VARIABLES
  MEER_ErrorNorm enorm;                    
  double h_max_ratio;                      
  double h_min_ratio;                      
  MEER_SPRboundaryPatchType SPR_boundary;  
  
  bool normal_at_nodes;                    
  
  //* REGIONS
  long   nREGIONs;       
  REGION *REGIONs;       
  
  //* NODES
  long nNODEs;           
  NODE *NODEs;           
  
  //* ELEMENTS
  long    nELEMs;        
  ELEMENT *ELEMs;        
  
  void set_alloc_REGIONs (long n);
  void set_alloc_NODEs (long n);
  void set_alloc_ELEMs (long n);
  
  
  virtual void initialize (void) = 0;
  
  
  virtual void give_superelems_to_node (long nodeID, long &nsuperelems, long *superelems) const = 0;
  
  
  
  virtual MEER_ElemDisplInterpol give_element_EDI    (long elementID) const = 0;
  virtual double give_element_area              (long elementID) const = 0;
  virtual double give_element_thickness         (long elementID) const = 0;
  virtual double give_element_thickness_reduced (long elementID) const = 0;
  
  //virtual long give_number_of_IPs1 (long elementID) const = 0;
  virtual long give_number_of_IPs2 (long elementID) const = 0;
  //virtual double give_coords_of_IPs2 (long elementID, long ipid, double *coo) = 0;
  
  //virtual void   give_IPs1_coords_global  (long elementID, int ipID, double *gcoords) const = 0;
  virtual double give_IPs2_coords_natural (long elementID, int ipID, double *ncoords) const = 0;
  
  virtual const double* give_IPs1_values (long elementID, int ipID, MEER_IPValues valtype) const = 0;
  
  virtual const double* give_IPs2_values (long elementID, int ipID, MEER_IPValues valtype) const = 0;
  
  // @}
  
  
  
  // *****************************************************************************************
  // *************************              DEBUG METODY              ************************
  // *****************************************************************************************
  // @{
 public:
  
  Dvctr*** give_refined_node_values_1 (void) const { return refined_node_values_1; }
  Dvctr*** give_refined_node_values_2 (void) const { return refined_node_values_2; }
  
  const double* give_e2i    (void) const { return e2i.give_ptr2val(); }
  //const double* give_eia    (void) const { return ei_aver.give_ptr2val(); }
  //const double* give_h_new_at_nodes    (void) const { return hnewi_node.give_ptr2val(); }
  const VectoR* give_normal_at_elem (long id) const { return ELEMs[id].normal; }
  const VectoR* give_normal_at_node_and_region (long id, long regid) const {  return  NODEs[id].normal[regid]; }
  const Dmtrx*  give_rotmat_at_node            (long id)             const {  return &NODEs[id].rotmat; }
  
  // @}
  
};

} // namespace meerspace

#endif // MEER_H




//    /*
//      Vytah z pdf, naladuj to do popisu trid.
//      
//  void give_superelems_to_node (long nodeID, long &nsuperelems, long *superelems)
//  Funkce vrací identifikační čísla elementů přilehlých k danému uzlu, tj. elementů,na kterých uzel leží.
//  Vstupní parametry:
//  long nodeID – ID uzlu.
//  Výtupní parametry:
//  long &nsuperelems – počet přilehlých elementů.
//  long *superelems – pole identifikačních čísel přilehlých elementů délky nsuperelems, pole je předem alokováno na délku 64.
//  void give_node_coords (long nodeID, double *coords)
//  Funkce vrací globální souřadnice daného uzlu.
//  Vstupní parametry:
//  long nodeID – ID uzlu.
//  Výtupní parametry:
//  double *coords – pole se souřadnicemi (předem alokované na délku 3).
//  double give_element_volume (long elementID)
//  Funkce jako návratovou hodnotu vrací objem elementu s ID elementID. U plošných/prutových prvků je objem počítán jako plocha/délka přenásobená tlouštkou/plochou průřezu.
//  long give_number_of_IPs1 (long elementID)
//  Funkce jako návratovou hodnotu vrací počet integračních bodů sady IPs1 elementu s ID elementID.
//  long give_number_of_IPs2 (long elementID)
//  Funkce jako návratovou hodnotu vrací počet integračních bodů sady IPs2 elementu s ID elementID.
//  void give_EDI_natcoords_weight_IPs1 (long elementID, int ipID, MEER_ElemDisplInterpol &edi, double *ncoords, double &w)
//  Funkce zaprvé vrací typ interpolace posunů po prvku s ID elementID pomocí výčtového typu
//  enum MEER_ElemDisplInterpol { MEER_EDI_Void, MEER_EDI_2d_3n_linear, MEER_EDI_2d_4n_bilinear },
//  kde 2d značí dimenzi elementu, 3n značí počet uzlů na elementu a linear popisuje stupeň aproximace.
//  Dále funkce vrací přirozené souřadnice a váhu integračního bodu s ID ipID na elementu s ID elementID pro integrační sadu IPs1.
//  Vstupní parametry:
//  long elementID – ID elementu.
//  long nodeID – ID uzlu.
//  Výtupní parametry:
//  MEER_ElemDisplInterpol &edi – typ interpolace posunů po prvku.
//  double *ncoords – pole s přirozenými souřadnicemi integračního bodu (předem alokované na délku 3).
//  double &w – váha integračního bodu.
//  void give_EDI_natcoords_weight_IPs2 (long elementID, int ipID, MEER_ElemDisplInterpol &edi, double *ncoords, double &w)
//  Viz předchozí funkce. Hodnoty odpovídají integrační sadě IPs2.
//  const double* give_IP1_values (long elementID, int ipID)
//  Funkce jako návratovou hodnotu vrací konstantní ukazatel na pole typu double, v kterém jsou uloženy hodnoty napětí pro integrační bod s ID ipID na elementu s ID elementID pro integrační sadu IPs1.
//  const double* give_IP2_values (long elementID, int ipID)
//  Funkce jako návratovou hodnotu vrací konstantní ukazatel na pole typu double, v kterém jsou uloženy hodnoty napětí pro integrační bod s ID ipID na elementu s ID elementID pro integrační sadu IPs2.
//    */