module_meer.cpp

Go to the documentation of this file.

#include "module_meer.h"
#include "geometry.h"
#include "cell.h"
#include "point.h"


#ifdef __MEER_MODULE

namespace midaspace {

MEER_interface :: MEER_interface (void) : MEER ()
{
  istep = 0;
  mesh = NULL;
}

MEER_interface :: ~MEER_interface ()
{
  mesh = NULL;
}

void MEER_interface :: local_initialize (Mesh *geom) //, long istep)
{
  // implementacne zavisle promenne
  mesh = geom;                    // trida s celou geometrii
  ((Mesh*)mesh)->regions_init();  // tato fce nastavi hodnotu regid na vsech elementech
}


void MEER_interface :: initialize (void)
{
  long i, regid, nvals;
  int j;
  SPRpatchType sprtype;
  const FElement *felem;
  ResultTypesAtElem rte;
  
  
  //*  ***   charakteristiky ulohy   ***
  
  //* GLOBAL VARIABLES
  switch (mesh->give_Pd()->give_adpa()->give_norm()) {
  case 1: enorm = MEER_EN_strain_stress;  rte = RTE_global_stress;  break;
  case 2: enorm = MEER_EN_stress_stress;  rte = RTE_global_stress;  break;
  default: _errorr ("Unknown norm");
  }
  SPR_boundary = (MEER_SPRboundaryPatchType)mesh->give_Pd()->give_adpa()->give_SPRboudary();
  
  //* NODES
  this->set_alloc_NODEs(mesh->give_Npts());
  
  for (i=0; i<nNODEs; i++) {
    NODEs[i].coords.copy(mesh->give_Pjnt(i)->give_coords());
  }
  
  //* ELEMENTS
  this->set_alloc_ELEMs(mesh->give_Nels());
  
  for (i=0; i<nELEMs; i++) {
    felem = mesh->give_FElem(i);
    
    ELEMs[i].regid  = felem->give_regid();
    ELEMs[i].nnodes = felem->give_nno();
    ELEMs[i].nodes = new long[ELEMs[i].nnodes];
    
    for (j=0; j<ELEMs[i].nnodes; j++)
      ELEMs[i].nodes[j] = felem->give_point(j)->give_ID();
    
    // int. points
    IntPointSet ips = this->give_IPset1(i);
    
    ELEMs[i].nIPs1 = IntPointSet_give_number_ips(ips);
    ELEMs[i].IPs1_coords = new PoinT[ELEMs[i].nIPs1];
    
    for (j=0; j<ELEMs[i].nIPs1; j++)
      felem->give_ip_coords_global (ips, j, ELEMs[i].IPs1_coords[j]);
  }
  
  //* REGIONS
  this->set_alloc_REGIONs(mesh->give_nRegions());
  
  for (i=0; i<nELEMs; i++) {
    regid = ELEMs[i].regid;
    felem = mesh->give_FElem(i);
    
    nvals   = felem->give_result_ncomp(istep, rte);   // pocet hodnot typu rte(napr. stress) na elementu
    sprtype = felem->give_spr_patch_type();           // typ prokladaneho polygonu
    
    if (REGIONs[regid].sprtype) {
      if (REGIONs[regid].nvals   != nvals  ) _errorr("Inconsistent region");
      if (REGIONs[regid].sprtype != sprtype) _errorr("Inconsistent region");
    }
    else {
      REGIONs[regid].nvals   = nvals;
      REGIONs[regid].sprtype = sprtype;
    }
  }
  
  //for (i=0; i<nRegions; i++) {
  //  if (region_nvals  [i] <= 0)  _errorr("Inconsistent region");
  //  if (region_sprtype[i] == 0)  _errorr("Inconsistent region");
  //}
  
}


IntPointSet MEER_interface :: give_IPset1 (long elementID) const
{
  return mesh->give_FElem(elementID)->give_IPset_rslts(mesh->give_rslts_solver());
}
IntPointSet MEER_interface :: give_IPset2 (long elementID) const
{
  return this->give_IPset1(elementID);
}

void MEER_interface :: give_superelems_to_node (long nodeID, long &nsuperelems, long *superelems) const
{
  const GPA<const Element>* superlms = mesh->give_Pjnt(nodeID)->give_superelems();
  
  nsuperelems = superlms->give_size();
  
  for (long i=0; i<nsuperelems; i++)
    superelems[i] = (*superlms)[i]->give_ID();
  
}

// /// compute global coordinates of nodeID-th node
// void MEER_interface :: give_node_coords (long nodeID, double *coords) const
// {
//   const PoinT *coo;
//   coo = mesh->give_Pjnt(nodeID)->give_coords();
//   coo->copy_to(coords);
// }


MEER_ElemDisplInterpol MEER_interface :: give_element_EDI (long elementID) const
{
  IntPointSet ips2 = this->give_IPset2(elementID);
  MEER_ElemDisplInterpol edi;
  
  switch (ips2) {
  case IPS_2D_3v_4ip:
  case IPS_2D_3v_3ip:
  case IPS_2D_3v_1ip:  edi = MEER_EDI_2d_3n_linear;      break;
  case IPS_2D_4v_4ip:  edi = MEER_EDI_2d_4n_bilinear_1;  break;
  default: _errorr ("Unknown ips");
  }
  
  return edi;
}

//double MEER_interface :: give_element_volume (long elementID) const
//{
//  return mesh->give_FElem(elementID)->give_volume();
//}

double MEER_interface :: give_element_thickness (long elementID) const
{
  return mesh->give_FElem(elementID)->give_elemAttribs()->give_cs()->give_thickness();
}
double MEER_interface :: give_element_thickness_reduced (long elementID) const
{
  switch (mesh->give_FElem(elementID)->give_elemAttribs()->give_sst()) {
  case SST_plstress:  return this->give_element_thickness(elementID);  break;
  case SST_3dshell:   return 1.0;  break;  // napeti je integrovano
  default: _errorr ("Unknown ips");
  }
  
  return 0.0;
}

double MEER_interface :: give_element_area (long elementID) const
{
  return mesh->give_FElem(elementID)->give_lav();
}

//long MEER_interface :: give_number_of_IPs1 (long elementID) const
//{
//  return IntPointSet_give_number_ips (this->give_IPset1(elementID));
//}
long MEER_interface :: give_number_of_IPs2 (long elementID) const
{
  return IntPointSet_give_number_ips (this->give_IPset2(elementID));
}

// /// return global coordinates of ipid-th IP of elementID-th element for ip set 1
// /// pole predalokovano na 3
// void   MEER_interface :: give_IPs1_coords_global  (long elementID, int ipID, double *gcoords) const
// {
//   IntPointSet ips = this->give_IPset1(elementID);
//   PoinT coords;
//   mesh->give_FElem(elementID)->give_ip_coords_global (ips, ipID, coords);
//   coords.copy_to(gcoords);
// }

double MEER_interface :: give_IPs2_coords_natural (long elementID, int ipID, double *ncoords) const
{
  IntPointSet ips = this->give_IPset2(elementID);
  PoinT coords;
  double w = IPS_give_ip_coord_native (ipID, ips, coords);
  coords.copy_to(ncoords);
  return w;
}

const double* MEER_interface :: give_IPs1_values (long elementID, int ipID, MEER_IPValues valtype) const
{
  if      (valtype == MEER_IPV_strain) return mesh->give_FElem(elementID)->give_results_dm(istep, RTE_global_strain)->give_ptr2val(ipID, 0);
  else if (valtype == MEER_IPV_stress) return mesh->give_FElem(elementID)->give_results_dm(istep, RTE_global_stress)->give_ptr2val(ipID, 0);
  else errol;
  
  return NULL;
}

const double* MEER_interface :: give_IPs2_values (long elementID, int ipID, MEER_IPValues valtype) const
{
  return this->give_IPs1_values (elementID, ipID, valtype);
}


// /// give weight as return value, and natural coordinates of node-th IP
// double MEER_interface :: give_coords_of_IPs2 (long elementID, long ipid, double *coo)
// {
//   PoinT coords;
//   double w = IPS_give_ip_coord_native (ipid, this->give_IPset2(elementID), coords);    // IP vaha
//   
//   coords.copy_to(coo);
//   return w;
// }

} // namespace midaspace

#endif