mstruct_analyse_orientation.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mstruct_analyse_orientation.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:57 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "mstruct_analyse_orientation.h"
#include "mstruct_ves.h"
#include "mstruct_outils.h"
#include "mstruct_definition.h"
#include "mg_cg_forme.h"
#include "mg_cg_groupe_forme.h"
#include "mg_cg_assemblage.h"
#include "mg_cg_modele.h"
#include "magic_plot.h"
#include <string.h>
#include <math.h>
MSTRUCT_ANALYSE_ORIENTATION::MSTRUCT_ANALYSE_ORIENTATION(void): MSTRUCT_ANALYSE()
{
}
 
MSTRUCT_ANALYSE_ORIENTATION::MSTRUCT_ANALYSE_ORIENTATION(MSTRUCT_VES* ves,
                                                         std::string identifiant,
                                                         std::string nom_groupe_forme,
                                                         BOITE_3D* boite_3d,bool avec_fem_maillage): MSTRUCT_ANALYSE(ves,identifiant, nom_groupe_forme, boite_3d)
{
  m_avec_fem_maillage=avec_fem_maillage;
}
 
MSTRUCT_ANALYSE_ORIENTATION::MSTRUCT_ANALYSE_ORIENTATION(MSTRUCT_ANALYSE_ORIENTATION& mdd,bool cpy_data): MSTRUCT_ANALYSE(mdd,cpy_data)
{
  if(cpy_data)
  for(int i=0;i<6;i++)
  {
    m_moyenne[i]=mdd.m_moyenne[i];
    m_ecart_type[i]=mdd.m_ecart_type[i];
    m_min[i]=mdd.m_min[i];
    m_max[i]=mdd.m_max[i];
  }
}
 
MSTRUCT_ANALYSE_ORIENTATION::~MSTRUCT_ANALYSE_ORIENTATION(void)
{
}
 
double* MSTRUCT_ANALYSE_ORIENTATION::get_moyenne(void)
{
  return m_moyenne;
}
 
double* MSTRUCT_ANALYSE_ORIENTATION::get_ecart_type(void)
{
  return m_ecart_type;
}
 
double* MSTRUCT_ANALYSE_ORIENTATION::get_min(void)
{
  return m_min;
}
 
double* MSTRUCT_ANALYSE_ORIENTATION::get_max(void)
{
  return m_max;
}
 
long int MSTRUCT_ANALYSE_ORIENTATION::get_type(void)
{
  return MSTRUCT::TYPE_ANALYSE::ORIENTATION;
}
 
void MSTRUCT_ANALYSE_ORIENTATION::executer(void)
{
  MG_CG_GROUPE_FORME* groupe_forme=NULL;
  FEM_MAILLAGE* fem_maill=NULL;
  if(m_nom_groupe_forme!="ALL") groupe_forme=m_ves->get_mgcg_modele()->get_mgcg_groupe_forme(m_nom_groupe_forme);
  if(m_avec_fem_maillage) fem_maill=m_ves->get_fem_maillage();
  MSTRUCT_OUTILS::statistiques_tenseur_orientation(groupe_forme,m_boite_analyse,m_moyenne,m_ecart_type,m_min,m_max,fem_maill,m_avec_fem_maillage);
}
 
MSTRUCT_ANALYSE_ORIENTATION * MSTRUCT_ANALYSE_ORIENTATION::calculer_ecart(std::string identifiant, double* tenseur_compare, int type_ecart)
{
  MSTRUCT_ANALYSE_ORIENTATION* ecart = new MSTRUCT_ANALYSE_ORIENTATION();
  ecart->m_identifiant=identifiant;
  for(int i=0;i<6;i++)
  {
    if(type_ecart==MSTRUCT::TYPE_COMPARAISON::ECART_RELATIF)
    {
      if(std::fabs(tenseur_compare[i])>1.0e-16) ecart->get_moyenne()[i]=(m_moyenne[i]-tenseur_compare[i])/tenseur_compare[i];
      else ecart->get_moyenne()[i]=nan("");
      ecart->get_ecart_type()[i]=nan("");
      ecart->get_min()[i]=nan("");
      ecart->get_max()[i]=nan("");
    }
    if(type_ecart==MSTRUCT::TYPE_COMPARAISON::ECART_RELATIF_ABSOLUE)
    {
      if(std::fabs(tenseur_compare[i])>1.0e-16) ecart->get_moyenne()[i]=std::fabs((m_moyenne[i]-tenseur_compare[i])/tenseur_compare[i]);
      else ecart->get_moyenne()[i]=nan("");
      ecart->get_ecart_type()[i]=nan("");
      ecart->get_min()[i]=nan("");
      ecart->get_max()[i]=nan("");
    }
    else if(type_ecart==MSTRUCT::TYPE_COMPARAISON::ECART_ABSOLUE)
    {
      ecart->get_moyenne()[i]=std::fabs(m_moyenne[i]-tenseur_compare[i]);
      ecart->get_ecart_type()[i]=nan("");
      ecart->get_min()[i]=nan("");
      ecart->get_max()[i]=nan("");
    }
    else if(type_ecart==MSTRUCT::TYPE_COMPARAISON::ECART_QUADRATIQUE)
    {
      double val=(m_moyenne[i]-tenseur_compare[i]);
      ecart->get_moyenne()[i]=val*val;
      ecart->get_ecart_type()[i]=nan("");
      ecart->get_min()[i]=nan("");
      ecart->get_max()[i]=nan("");
    }
  }
  return ecart;
}
 
 
void MSTRUCT_ANALYSE_ORIENTATION::exporter(std::ofstream& ofstrm, long i, bool avec_entete, bool avec_graph, char* prefix_graph)
{
  if(avec_entete) ofstrm << "#(1) [ORIENTATION](2-7) [±](8-13) [min](14-19) [max](20-25)" << std::endl;
  ofstrm << i << " ";
  for(int j=0;j<6;j++)
  {
    ofstrm << m_moyenne[j] << " ";
  }
  for(int j=0;j<6;j++)
  {
    ofstrm << m_ecart_type[j] << " ";
  }
  for(int j=0;j<6;j++)
  {
    ofstrm << m_min[j] << " ";
  }
  for(int j=0;j<6;j++)
  {
    ofstrm << m_max[j] << " ";
  }
  ofstrm << std::endl;
  if(avec_graph)
  {
    OT_TENSEUR tenseur_orientation(3,3);
    tenseur_orientation(0,0)=m_moyenne[0];
    tenseur_orientation(1,1)=m_moyenne[1];
    tenseur_orientation(2,2)=m_moyenne[2];
    tenseur_orientation(0,1)=m_moyenne[3];
    tenseur_orientation(0,2)=m_moyenne[4];
    tenseur_orientation(1,2)=m_moyenne[5];
    tenseur_orientation(1,0)=m_moyenne[3];
    tenseur_orientation(2,0)=m_moyenne[4];
    tenseur_orientation(2,1)=m_moyenne[5];
    OT_TENSEUR tenseur_orientation_ecart_type(3,3);
    tenseur_orientation_ecart_type(0,0)=m_ecart_type[0];
    tenseur_orientation_ecart_type(1,1)=m_ecart_type[1];
    tenseur_orientation_ecart_type(2,2)=m_ecart_type[2];
    tenseur_orientation_ecart_type(0,1)=m_ecart_type[3];
    tenseur_orientation_ecart_type(0,2)=m_ecart_type[4];
    tenseur_orientation_ecart_type(1,2)=m_ecart_type[5];
    tenseur_orientation_ecart_type(1,0)=m_ecart_type[3];
    tenseur_orientation_ecart_type(2,0)=m_ecart_type[4];
    tenseur_orientation_ecart_type(2,1)=m_ecart_type[5];
    char nom_plot[500];
    sprintf(nom_plot,"%s/tenseur_%s.plt",prefix_graph,m_identifiant.c_str());
    MAGIC_PLOT magic_plot;
    magic_plot.tenseur_couleur=MAGIC_PLOT::COULEUR::GRIS;
    magic_plot.tenseur_titre="Tenseur d'orientation";
    magic_plot.tenseur_titrebarcouleur="";
    magic_plot.plot_script_tenseur(2,tenseur_orientation,tenseur_orientation_ecart_type,nom_plot,true);
  }
}
 
void MSTRUCT_ANALYSE_ORIENTATION::enregistrer(std::ofstream& ofstrm)
{
  long type_analyse=get_type();
  ofstrm.write((char*)&type_analyse,sizeof(long));
  MSTRUCT_ANALYSE::enregistrer(ofstrm);
  ofstrm.write((char*)&m_avec_fem_maillage,sizeof(bool));
  for(int i=0;i<6;i++)
  {
    ofstrm.write((char*)&m_moyenne[i],sizeof(double));
    ofstrm.write((char*)&m_ecart_type[i],sizeof(double));
    ofstrm.write((char*)&m_min[i],sizeof(double));
    ofstrm.write((char*)&m_max[i],sizeof(double));
  }
}
 
void MSTRUCT_ANALYSE_ORIENTATION::ouvrir(std::ifstream& ifstrm)
{
  MSTRUCT_ANALYSE::ouvrir(ifstrm);
  ifstrm.read((char*)&m_avec_fem_maillage,sizeof(bool));
  for(int i=0;i<6;i++)
  {
    ifstrm.read((char*)&m_moyenne[i],sizeof(double));
    ifstrm.read((char*)&m_ecart_type[i],sizeof(double));
    ifstrm.read((char*)&m_min[i],sizeof(double));
    ifstrm.read((char*)&m_max[i],sizeof(double));
  }
}
 
void MSTRUCT_ANALYSE_ORIENTATION::affiche_contenu(fonction_affiche* fonc)
{
  MSTRUCT_ANALYSE::affiche_contenu(fonc);
  char ligne[5000];
  sprintf(ligne,"MSTRUCT_ANALYSE_ORIENTATION");
  fonc(ligne);
  char valeur[100];
  sprintf(ligne,"-> Moyenne :    [");  
  for(int i=0;i<5;i++)
  {
    sprintf(valeur,"%lf,",m_moyenne[i]);
    strcat(ligne,valeur);
  }
  sprintf(valeur,"%lf]",m_moyenne[5]);
  strcat(ligne,valeur);
  fonc(ligne);
  sprintf(ligne,"-> Ecart-type : [");  
  for(int i=0;i<5;i++)
  {
    sprintf(valeur,"%lf,",m_ecart_type[i]);
    strcat(ligne,valeur);
  }
  sprintf(valeur,"%lf]",m_ecart_type[5]);
  strcat(ligne,valeur);
  fonc(ligne);
  sprintf(ligne,"-> Min :        [");  
  for(int i=0;i<5;i++)
  {
    sprintf(valeur,"%lf,",m_min[i]);
    strcat(ligne,valeur);
  }
  sprintf(valeur,"%lf]",m_min[5]);
  strcat(ligne,valeur);
  fonc(ligne);
  sprintf(ligne,"-> Max :        [");  
  for(int i=0;i<5;i++)
  {
    sprintf(valeur,"%lf,",m_max[i]);
    strcat(ligne,valeur);
  }
  sprintf(valeur,"%lf]",m_max[5]);
  strcat(ligne,valeur);
  fonc(ligne);
}