mg_element_topologique.cpp

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mg_element_topologique.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:54 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
 
#include "gestionversion.h"
#include "mg_element_topologique.h"
#include <math.h>
 
 
int MG_ELEMENT_TOPOLOGIQUE::pas_echantillon=20;
double MG_ELEMENT_TOPOLOGIQUE::epsilon_echantillon=1;
double MG_ELEMENT_TOPOLOGIQUE::angle_dev_echantillon=0.5;
int MG_ELEMENT_TOPOLOGIQUE::oldval_pas_echantillon=1;
 
 
 
 
MG_ELEMENT_TOPOLOGIQUE::MG_ELEMENT_TOPOLOGIQUE(std::string id):MG_IDENTIFICATEUR(),nouveau_numero(-1),idoriginal(id)
{
ini_param();
}
 
 
 
MG_ELEMENT_TOPOLOGIQUE::MG_ELEMENT_TOPOLOGIQUE(unsigned long num,std::string id):MG_IDENTIFICATEUR(num),nouveau_numero(-1),idoriginal(id)
{
ini_param();
}
 
MG_ELEMENT_TOPOLOGIQUE::MG_ELEMENT_TOPOLOGIQUE(MG_ELEMENT_TOPOLOGIQUE& mdd):MG_IDENTIFICATEUR(),nouveau_numero(-1),idoriginal(mdd.idoriginal)
{
ini_param();
}
 
 
MG_ELEMENT_TOPOLOGIQUE::~MG_ELEMENT_TOPOLOGIQUE()
{
}
 
 
 
 
TPL_SET<MG_ELEMENT_MAILLAGE*>*  MG_ELEMENT_TOPOLOGIQUE::get_lien_maillage(void)
{
    return &lien_maillage;
}
 
TPL_LISTE_ENTITE<FEM_ELEMENT_MAILLAGE*>*  MG_ELEMENT_TOPOLOGIQUE::get_lien_fem_maillage(void)
{
    return &lien_fem_maillage;
}
 
int MG_ELEMENT_TOPOLOGIQUE::est_topologie_sousjacente(MG_ELEMENT_TOPOLOGIQUE *ele)
{
if (lst_topo_sous_jacente.get_nb()==0) get_topologie_sousjacente(&lst_topo_sous_jacente); 
int retour=lst_topo_sous_jacente.existe(ele);
return retour;
}
 
void MG_ELEMENT_TOPOLOGIQUE::change_nouveau_numero(int num)
{
    nouveau_numero=num;
}
 
int MG_ELEMENT_TOPOLOGIQUE::get_nouveau_numero(void)
{
    return nouveau_numero;
}
 
char MG_ELEMENT_TOPOLOGIQUE::get_formulation_ccf(int num)
{
return tabccf[num].formulation;  
}
 
 
void MG_ELEMENT_TOPOLOGIQUE::get_type_ccf(int num,char* nom)
{
strcpy(nom,tabccf[num].type.c_str());
}
 
 
 
std::string MG_ELEMENT_TOPOLOGIQUE::get_effort_suiv(int num)
{
return tabccf[num].effortsuiv;
}    
 
void MG_ELEMENT_TOPOLOGIQUE::change_effort_suiv(int num,std::string suiv)
{
tabccf[num].effortsuiv=suiv;
}    
 
void MG_ELEMENT_TOPOLOGIQUE::change_type_ccf(int num,char* nom)
{
tabccf[num].type=nom;
}
 
double MG_ELEMENT_TOPOLOGIQUE::get_valeur_ccf(int num)
{
    return tabccf[num].ccfvaleur;
}
std::string MG_ELEMENT_TOPOLOGIQUE::get_formule_ccf(int num)
{
    return tabccf[num].ccfformule;
}
int MG_ELEMENT_TOPOLOGIQUE::get_formule_nb_variable(int num)
{
    return tabccf[num].variables.size();
}
std::string MG_ELEMENT_TOPOLOGIQUE::get_formule_variable(int num,int num2)
{
    return tabccf[num].variables[num2];
}
unsigned long MG_ELEMENT_TOPOLOGIQUE::get_id_ccf(int num)
{
    return (unsigned long)(tabccf[num].ccfvaleur);
}
 
void MG_ELEMENT_TOPOLOGIQUE::change_valeur_ccf(int num,double val)
{
    tabccf[num].ccfvaleur=val;
}
 
void MG_ELEMENT_TOPOLOGIQUE::change_formule_ccf(int num,std::string val)
{
    tabccf[num].ccfformule=val;
}
 
void MG_ELEMENT_TOPOLOGIQUE::change_id_ccf(int num,unsigned long val)
{
    tabccf[num].ccfvaleur=val;
}
 
 
int MG_ELEMENT_TOPOLOGIQUE::get_nb_ccf(void)
{
    return tabccf.size();
}
 
void MG_ELEMENT_TOPOLOGIQUE::ajouter_ccf(char *nom,double val,std::string suiv)
{
    std::string stnom=nom;
    for (int i=0;i<get_nb_ccf();i++)
      {
      if (tabccf[i].type==stnom)
          {
            tabccf[i].formulation='N';
            tabccf[i].ccfvaleur=val;
            return;
            }
      if ((stnom=="Da") || (stnom=="Dt"))
      if ((tabccf[i].type=="Dx") || (tabccf[i].type=="Dy")|| (tabccf[i].type=="Dz") || (tabccf[i].type=="Rx")|| (tabccf[i].type=="Ry")|| (tabccf[i].type=="Rz") )
              return;
      if ((tabccf[i].type=="Da") || (tabccf[i].type=="Dt"))
      if ((stnom=="Dx") || (stnom=="Dy")|| (stnom=="Dz") || (stnom=="Rx")|| (stnom=="Ry")|| (stnom=="Rz") )
              return;
      }
    CCF nccf;
    nccf.formulation='N';
    nccf.type=nom;
    nccf.ccfvaleur=val;
    nccf.effortsuiv=suiv;
    tabccf.push_back(nccf);
}
 
 
 
void MG_ELEMENT_TOPOLOGIQUE::ajouter_ccf(char *nom,std::string formule,std::vector<std::string> &listvariable,std::string suiv)
{
    std::string stnom=nom;
    for (int i=0;i<get_nb_ccf();i++)
      {
      if (tabccf[i].type==stnom)
          {
            tabccf[i].formulation='F';
            tabccf[i].ccfformule=formule;
            tabccf[i].variables=listvariable;
            return;
            }
      if ((stnom=="Da") || (stnom=="Dt"))
      if ((tabccf[i].type=="Dx") || (tabccf[i].type=="Dy")|| (tabccf[i].type=="Dz") || (tabccf[i].type=="Rx")|| (tabccf[i].type=="Ry")|| (tabccf[i].type=="Rz") )
              return;
      if ((tabccf[i].type=="Da") || (tabccf[i].type=="Dt"))
      if ((stnom=="Dx") || (stnom=="Dy")|| (stnom=="Dz") || (stnom=="Rx")|| (stnom=="Ry")|| (stnom=="Rz") )
              return;
      }
    CCF nccf;
    nccf.formulation='F';
    nccf.type=nom;
    nccf.ccfformule=formule;
    nccf.variables=listvariable;
    nccf.effortsuiv=suiv;
    tabccf.push_back(nccf);
}
 
void MG_ELEMENT_TOPOLOGIQUE::ajouter_ccf(char *nom,unsigned long id,std::string suiv)
{
    std::string stnom=nom;
    for (int i=0;i<get_nb_ccf();i++)
      {
      if (tabccf[i].type==stnom)
          {
            tabccf[i].formulation='I';
            tabccf[i].ccfvaleur=id;
            return;
            }
      if ((stnom=="Da") || (stnom=="Dt"))
      if ((tabccf[i].type=="Dx") || (tabccf[i].type=="Dy")|| (tabccf[i].type=="Dz") || (tabccf[i].type=="Rx")|| (tabccf[i].type=="Ry")|| (tabccf[i].type=="Rz") )
              return;
      if ((tabccf[i].type=="Da") || (tabccf[i].type=="Dt"))
      if ((stnom=="Dx") || (stnom=="Dy")|| (stnom=="Dz") || (stnom=="Rx")|| (stnom=="Ry")|| (stnom=="Rz") )
              return;
      }
    CCF nccf;
    nccf.formulation='I';
    nccf.type=nom;
    nccf.ccfvaleur=id;
    nccf.effortsuiv=suiv;
    tabccf.push_back(nccf);
}
 
void MG_ELEMENT_TOPOLOGIQUE::supprimer_ccf(int num)
{
    std::vector<CCF>::iterator it=tabccf.begin();
    for (int j=0;j<num;j++) 
        it++;
    tabccf.erase(it);
  
}
 
void MG_ELEMENT_TOPOLOGIQUE::transfert_ccf(MG_ELEMENT_TOPOLOGIQUE &a1)
{
    int n1 = a1.get_nb_ccf();
    
    while (get_nb_ccf())
    {
        supprimer_ccf(0);
    }
 
    for (int i=0; i<n1; i++)
    {
       CCF nccf=a1.tabccf[i]; 
        tabccf.push_back(nccf);
      
    }
}
 
void MG_ELEMENT_TOPOLOGIQUE::copie_ccf(MG_ELEMENT_TOPOLOGIQUE &a1)
{
    int nbccf=a1.get_nb_ccf();
    for (int i=0;i<nbccf;i++)
        {
        char type[3]; 
        std::string formulation;
        a1.get_type_ccf(i,type);
        formulation = a1.get_formulation_ccf(i);
        std::string suiv = a1.get_effort_suiv(i);
    if(formulation == "N")
        {
        double val=a1.get_valeur_ccf(i);
        ajouter_ccf(type,val,suiv);
        }
    if(formulation == "I")
        {
        unsigned long id=a1.get_id_ccf(i);
        ajouter_ccf(type,id,suiv);
        }
    if(formulation == "F")
        {
        std::vector<std::string> listvariable;
        std::string formule;
        formule =a1.get_formule_ccf(i);
        for(int l=0;a1.get_formule_nb_variable(i);l++)
                listvariable.push_back(a1.get_formule_variable(i,l));
        ajouter_ccf(type,formule,listvariable,suiv);
        }
    }
}
 
std::string MG_ELEMENT_TOPOLOGIQUE::get_idoriginal(void)
{
    return idoriginal;
}
 
void MG_ELEMENT_TOPOLOGIQUE::change_idoriginal(std::string id)
{
  idoriginal=id;
}
 
 
bool MG_ELEMENT_TOPOLOGIQUE::get_valeur_ccf(char* nom,double &val)
{
int nb=get_nb_ccf();
for (int i=0;i<nb;i++)
  {
      char type[3];
      get_type_ccf(i,type);
     std::string stnom=nom;
     std::string sttype=type;
     if (nom==sttype)
          {
            val=get_valeur_ccf(i);
            return true;
          }
  }
return false;
}
 
int MG_ELEMENT_TOPOLOGIQUE::get_num_ccf(char* nom)
{
  int nb=get_nb_ccf();
  for (int i=0;i<nb;i++)
    {
        char type[3];
        get_type_ccf(i,type);
      std::string stnom=nom;
      std::string sttype=type;
      if (nom==sttype)
            {
              return i;
            }
    }
return 0.;
}
 
 
bool MG_ELEMENT_TOPOLOGIQUE::get_formulation_ccf(char* nom,char &c)
{
int nb=get_nb_ccf();
for (int i=0;i<nb;i++)
  {
     char type[3];
     get_type_ccf(i,type);
     std::string stnom=nom;
     std::string sttype=type;
     if (nom==sttype)
          {
            c=get_formulation_ccf(i);
            return true;
          }
  }
return false;
}
 
void MG_ELEMENT_TOPOLOGIQUE::enregistrer_ccf(std::ostream& o,double version)
{
int nb=get_nb_ccf();
o << get_nb_ccf();
if (nb!=0) o<<",(";
for (int i=0;i<nb;i++)
  {
  char formulation=get_formulation_ccf(i);
  char type[10];
  get_type_ccf(i,type);
  o << "(" << formulation << "," << type << ","  << get_effort_suiv(i) << ",";
  if (formulation=='F') 
    {
    o << get_formule_ccf(i) << "," << get_formule_nb_variable(i);
    if (get_formule_nb_variable(i)>0)
      {
      o << ",(";
      for (int j=0;j<get_formule_nb_variable(i);j++)
          {
            o << get_formule_variable(i,j);
          if (j!=get_formule_nb_variable(i)-1) o << ",";
            
          }
      o << ")";
      }
      
    }
      
  else if (formulation=='I') o << (unsigned long)get_valeur_ccf(i) ;
  else o << get_valeur_ccf(i) ;
  o <<")";
  if (i!=nb-1) o << ",";
  }
 if (nb!=0) o << ")";
 
  
}
 
 
void MG_ELEMENT_TOPOLOGIQUE::enregistrer_contraintes(std::ostream& o,double version)
{
int nb=get_nb_contrainte();
o << "(";
for (int i=0;i<nb;i++)
  {
  o << get_contrainte(i); 
  if (i!=nb-1) o << ",";
  }
  o << ")";
      
}
  
 
bool MG_ELEMENT_TOPOLOGIQUE::est_orthotrope_mecanique(void)
{
double E;  
bool test=get_valeur_ccf((char*)"E1",E);
return test;  
}
 
 
void MG_ELEMENT_TOPOLOGIQUE::ini_param(void)
{
static int passe=0;
if (passe==0)
 {
 passe=1;
 
 OT_PARAMETRES param;
 char fichier[500];
 sprintf(fichier,"%s/.magic",getenv("HOME"));
 param.lire(fichier);
 int val=(int)param.get_valeur("Echantillon_face");
 if (val!=0) pas_echantillon=val;
 double val2=(double)param.get_valeur("Epsilon_face");
 if (fabs(val2)>1e-10) epsilon_echantillon=val2;
 double val3=(double)param.get_valeur("Angle_dev_face");
 if (fabs(val3)>1e-10) angle_dev_echantillon=val3;
 }
    
}
 
 
void MG_ELEMENT_TOPOLOGIQUE::ajouter_contrainte(double val)
{
if (!est_une_topo_element()) return;
contraintes.push_back(val);
}
 
 
double MG_ELEMENT_TOPOLOGIQUE::get_contrainte(int i)
{
return contraintes[i];
}
 
 
int MG_ELEMENT_TOPOLOGIQUE::get_nb_contrainte(void)
{
if (!est_une_topo_element()) return 0;
return contraintes.size();
}