microstructure/src/mstruct_analyse.cpp

#include "mstruct_analyse.h"
#include "parse.h"
#include "pars_argument.h"
#include "mg_cg_modele.h"
#include "mstruct_outils.h"
#include "mg_cg_groupe_forme.h"
#include "mg_cg_assemblage.h"
#include "magic_plot.h"
#include <mg_gestionnaire.h>

MSTRUCT_ANALYSE::MSTRUCT_ANALYSE(void)
{
  m_identifiant="";
  m_boite_analyse=NULL;
  m_nom_groupe_forme="";
}

MSTRUCT_ANALYSE::MSTRUCT_ANALYSE(std::string identifiant, std::string nom_groupe_forme, BOITE_3D* boite_3d , long nb_ves)
{
  m_identifiant=identifiant;
  if(boite_3d!=NULL) m_boite_analyse=new BOITE_3D(*boite_3d);
  else m_boite_analyse=NULL;
  m_nom_groupe_forme=nom_groupe_forme;
  m_nb_ves=nb_ves;
}

MSTRUCT_ANALYSE::MSTRUCT_ANALYSE(MSTRUCT_ANALYSE& mdd)
{
  m_identifiant=mdd.m_identifiant;
  if(mdd.m_boite_analyse!=NULL) m_boite_analyse=new BOITE_3D(*mdd.m_boite_analyse);
  else m_boite_analyse=NULL;
  m_nom_groupe_forme=mdd.m_nom_groupe_forme;
  m_nb_ves=mdd.m_nb_ves;
}

MSTRUCT_ANALYSE::~MSTRUCT_ANALYSE(void)
{
  if(m_boite_analyse!=NULL) delete m_boite_analyse;
}

void MSTRUCT_ANALYSE::change_identifiant(std::string identifiant)
{
  m_identifiant=identifiant;
}

std::string MSTRUCT_ANALYSE::get_identifiant(void)
{
  return m_identifiant;
}

void MSTRUCT_ANALYSE::change_boite_analyse(BOITE_3D boite_3d)
{
  delete m_boite_analyse;
  m_boite_analyse=new BOITE_3D(boite_3d);
}

BOITE_3D* MSTRUCT_ANALYSE::get_boite_analyse(void)
{
  return m_boite_analyse;
}

void MSTRUCT_ANALYSE::change_nom_groupe_forme(std::string nom_groupe_forme)
{
  m_nom_groupe_forme=nom_groupe_forme;
}

std::string MSTRUCT_ANALYSE::get_nom_groupe_forme(void)
{
  return m_nom_groupe_forme;
}

long int MSTRUCT_ANALYSE::get_nb_ves(void)
{
  return m_nb_ves;
}


void MSTRUCT_ANALYSE::enregistrer(std::ofstream& ofstrm)
{
  size_t len_identifiant = m_identifiant.size();
  ofstrm.write((char*)&len_identifiant,sizeof(size_t));
  ofstrm.write(m_identifiant.c_str(),m_identifiant.size());
  
  size_t len_nom_groupe_forme = m_nom_groupe_forme.size();
  ofstrm.write((char*)&len_nom_groupe_forme,sizeof(size_t));
  ofstrm.write(m_nom_groupe_forme.c_str(),m_nom_groupe_forme.size());
  
  bool avec_boite;
  if(m_boite_analyse==NULL) avec_boite=false;
  else avec_boite=true;
  ofstrm.write((char*)&avec_boite,sizeof(bool));
  if(avec_boite)
  {
    double xmin=m_boite_analyse->get_xmin();
    ofstrm.write((char*)&xmin,sizeof(double));
    double ymin=m_boite_analyse->get_ymin();
    ofstrm.write((char*)&ymin,sizeof(double));
    double zmin=m_boite_analyse->get_zmin();
    ofstrm.write((char*)&zmin,sizeof(double));
    double xmax=m_boite_analyse->get_xmax();
    ofstrm.write((char*)&xmax,sizeof(double));
    double ymax=m_boite_analyse->get_ymax();
    ofstrm.write((char*)&ymax,sizeof(double));
    double zmax=m_boite_analyse->get_zmax();
    ofstrm.write((char*)&zmax,sizeof(double));
  }
  ofstrm.write((char*)&m_nb_ves,sizeof(long));
}

void MSTRUCT_ANALYSE::ouvrir(std::ifstream& ifstrm)
{
  size_t len_identifiant;
  ifstrm.read((char*)&len_identifiant,sizeof(size_t));
  char *temp_identifiant = new char[len_identifiant+1];
  ifstrm.read(temp_identifiant,len_identifiant);
  temp_identifiant[len_identifiant]='\0';
  m_identifiant=temp_identifiant;
  delete [] temp_identifiant;
  
  size_t len_nom_groupe_forme;
  ifstrm.read((char*)&len_nom_groupe_forme,sizeof(size_t));
  char *temp_nom_groupe_forme = new char[len_nom_groupe_forme+1];
  ifstrm.read(temp_nom_groupe_forme,len_nom_groupe_forme);
  temp_nom_groupe_forme[len_nom_groupe_forme]='\0';
  m_nom_groupe_forme=temp_nom_groupe_forme;
  delete [] temp_nom_groupe_forme;
  
  bool avec_boite;
  ifstrm.read((char*)&avec_boite,sizeof(bool));
  
  if(avec_boite)
  {  
    double xmin;
    ifstrm.read((char*)&xmin,sizeof(double));
    double ymin;
    ifstrm.read((char*)&ymin,sizeof(double));
    double zmin;
    ifstrm.read((char*)&zmin,sizeof(double));
    double xmax;
    ifstrm.read((char*)&xmax,sizeof(double));
    double ymax;
    ifstrm.read((char*)&ymax,sizeof(double));
    double zmax;
    ifstrm.read((char*)&zmax,sizeof(double));
    m_boite_analyse = new BOITE_3D(xmin,ymin,zmin,xmax,ymax,zmax);
  }
  else m_boite_analyse=NULL;  
  ifstrm.read((char*)&m_nb_ves,sizeof(long));
}

void MSTRUCT_ANALYSE::affiche_contenu(fonction_affiche* fonc)
{
  char ligne[5000];
  sprintf(ligne,"MSTRUCT_ANALYSE");
  fonc(ligne);
  sprintf(ligne,"-> Identifiant : %s", m_identifiant.c_str());
  fonc(ligne);
  if(m_boite_analyse!=NULL) sprintf(ligne,"-> Boite_3D : [%lf,%lf,%lf,%lf,%lf,%lf]", m_boite_analyse->get_xmin(),
                                                                                  m_boite_analyse->get_ymin(),
                                                                                  m_boite_analyse->get_zmin(),
                                                                                  m_boite_analyse->get_xmax(),
                                                                                  m_boite_analyse->get_ymax(),
                                                                                  m_boite_analyse->get_zmax());
  else sprintf(ligne,"-> Boite_3D : NULL");
  fonc(ligne);
  if(m_nom_groupe_forme!="") sprintf(ligne,"-> MG_CG_GROUPE_FORME : %s",m_nom_groupe_forme.c_str());
  else sprintf(ligne,"-> MG_CG_GROUPE_FORME : NULL");
  fonc(ligne);
  sprintf(ligne,"-> NB ves : %li", m_nb_ves);
  fonc(ligne);
}


MSTRUCT_ANALYSE_CHAMP::MSTRUCT_ANALYSE_CHAMP(void): MSTRUCT_ANALYSE()
{
}

MSTRUCT_ANALYSE_CHAMP::MSTRUCT_ANALYSE_CHAMP(std::string identifiant, long int id_fem_solution, int nb_champ, double largeur_colonne, std::string nom_groupe_forme, BOITE_3D* boite_3d): MSTRUCT_ANALYSE(identifiant,nom_groupe_forme,boite_3d)
{
  m_id_fem_solution=id_fem_solution;
  m_nb_champ=nb_champ;
  m_moyenne = new double[m_nb_champ];
  m_ecart_type = new double[m_nb_champ];
  m_min = new double[m_nb_champ];
  m_max = new double[m_nb_champ];
  m_tab_histogramme=new OT_HISTOGRAMME*[m_nb_champ];
  for(int i=0;i<m_nb_champ;i++)
  {
    m_tab_histogramme[i] = new OT_HISTOGRAMME(largeur_colonne);
  }  
}

MSTRUCT_ANALYSE_CHAMP::MSTRUCT_ANALYSE_CHAMP(std::vector< MSTRUCT_ANALYSE_CHAMP* >& vector_analyse_champ): MSTRUCT_ANALYSE()
{
  std::vector<MSTRUCT_ANALYSE_CHAMP*>::iterator it_analyse=vector_analyse_champ.begin();
  MSTRUCT_ANALYSE_CHAMP* analyse = *it_analyse;
  m_identifiant=analyse->get_identifiant();
  if(analyse->get_boite_analyse()!=NULL) change_boite_analyse(*analyse->get_boite_analyse());
  m_nom_groupe_forme=analyse->get_nom_groupe_forme();
  m_nb_ves=vector_analyse_champ.size();
  m_id_fem_solution=-1;
  m_nb_champ=analyse->get_nb_champ();
  double largeur_colonne=analyse->get_distribution(0)->get_largeur_colonne();
  m_moyenne = new double[m_nb_champ];
  m_ecart_type = new double[m_nb_champ];
  m_min = new double[m_nb_champ];
  m_max = new double[m_nb_champ];
  m_tab_histogramme=new OT_HISTOGRAMME*[m_nb_champ];
  for(int i=0;i<m_nb_champ;i++)
  {
    m_tab_histogramme[i] = new OT_HISTOGRAMME(largeur_colonne);
  }  
  for(int i=0;i<m_nb_champ;i++)
  {
    m_moyenne[i]=0;
    m_ecart_type[i]=0;
    m_min[i]=std::numeric_limits< double >::max();
    m_max[i]=std::numeric_limits< double >::min();
  }
  for(it_analyse=vector_analyse_champ.begin();it_analyse!=vector_analyse_champ.end();it_analyse++)
  {
    analyse = *it_analyse;
    for(int i=0;i<m_nb_champ;i++)
    {
      m_moyenne[i]+=analyse->get_moyenne()[i];
      if(analyse->get_tenseur_min()[i]<m_min[i]) m_min[i]=analyse->get_tenseur_min()[i];
      if(analyse->get_tenseur_max()[i]>m_max[i]) m_max[i]=analyse->get_tenseur_max()[i];
      std::map<long,double>::iterator it_his;
      double val;
      long l;
      int k=analyse->get_distribution(i)->get_premiere_valeur(it_his,val,l);
      while(k!=0)
      {
        m_tab_histogramme[i]->ajouter_valeur(l,val/m_nb_ves);
        k=analyse->get_distribution(i)->get_suivante_valeur(it_his,val,l);
      }
    }
  }
  for(int i=0;i<m_nb_champ;i++)
  {
    m_moyenne[i]=m_moyenne[i]/m_nb_ves;
  }
  if(m_nb_ves>1)
  {
    for(it_analyse=vector_analyse_champ.begin();it_analyse!=vector_analyse_champ.end();it_analyse++)
    {
      analyse = *it_analyse;
      for(int i=0;i<m_nb_champ;i++)
      {
        m_ecart_type[i]+=(analyse->get_moyenne()[i]-m_moyenne[i])*(analyse->get_moyenne()[i]-m_moyenne[i]);
      }
    }
    for(int i=0;i<m_nb_champ;i++)
    {
      m_ecart_type[i]=sqrt(m_ecart_type[i]*(1.0/(m_nb_ves-1.0)));
    }  
  }
}

MSTRUCT_ANALYSE_CHAMP::MSTRUCT_ANALYSE_CHAMP(MSTRUCT_ANALYSE_CHAMP& mdd): MSTRUCT_ANALYSE(mdd)
{
  m_id_fem_solution=mdd.m_id_fem_solution;
  m_nb_champ=mdd.m_nb_champ;
  m_moyenne = new double[m_nb_champ];
  m_ecart_type = new double[m_nb_champ];
  m_min = new double[m_nb_champ];
  m_max = new double[m_nb_champ];
  m_tab_histogramme=new OT_HISTOGRAMME*[m_nb_champ];
  for(int i=0;i<m_nb_champ;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];
    m_tab_histogramme[i]=mdd.m_tab_histogramme[i];
  } 
}

MSTRUCT_ANALYSE_CHAMP::~MSTRUCT_ANALYSE_CHAMP(void)
{
  if(m_nb_champ>0)
  {
    delete [] m_moyenne;
    delete [] m_ecart_type;
    delete [] m_min;
    delete [] m_max;
    for(int i=0;i<m_nb_champ;i++) delete m_tab_histogramme[i];
    delete [] m_tab_histogramme;
  }
}

long int MSTRUCT_ANALYSE_CHAMP::get_id_fem_solution(void)
{
  return m_id_fem_solution;
}

int MSTRUCT_ANALYSE_CHAMP::get_nb_champ(void)
{
  return m_nb_champ;
}

double* MSTRUCT_ANALYSE_CHAMP::get_moyenne(void)
{
  return m_moyenne;
}

double* MSTRUCT_ANALYSE_CHAMP::get_tenseur_ecart_type(void)
{
  return m_ecart_type;
}

double* MSTRUCT_ANALYSE_CHAMP::get_tenseur_min(void)
{
  return m_min;
}

double* MSTRUCT_ANALYSE_CHAMP::get_tenseur_max(void)
{
  return m_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_CHAMP::get_distribution(int num_champ)
{
  return m_tab_histogramme[num_champ];
}

long int MSTRUCT_ANALYSE_CHAMP::get_type(void)
{
  return TYPE_ANALYSE::CHAMP;
}

void MSTRUCT_ANALYSE_CHAMP::executer(MSTRUCT_VES* ves)
{
  FEM_SOLUTION* fem_sol = ves->get_mg_gestionnaire()->get_fem_solutionid(m_id_fem_solution);
  MG_CG_GROUPE_FORME* groupe_forme=NULL;
  if(m_nom_groupe_forme!="ALL") groupe_forme=ves->get_mgcg_modele()->get_mgcg_groupe_forme(m_nom_groupe_forme);  
  MSTRUCT_OUTILS::statistiques_champ_volumique(fem_sol,groupe_forme,m_boite_analyse,m_moyenne,m_ecart_type,m_min,m_max,m_tab_histogramme);  
}

void MSTRUCT_ANALYSE_CHAMP::exporter(std::ofstream& ofstrm, long i, bool avec_entete, bool avec_histo, char* prefix_histo)
{
  if(avec_entete) ofstrm << "#(1) [CHAMP](2-nb_champ) [±] [min] [max]" << std::endl;
  ofstrm << i << " ";
  for(int j=0;j<m_nb_champ;j++)
  {
    ofstrm << m_moyenne[j] << " ";
  }
  for(int j=0;j<m_nb_champ;j++)
  {
    ofstrm << m_ecart_type[j] << " ";
  }
  for(int j=0;j<m_nb_champ;j++)
  {
    ofstrm << m_min[j] << " ";
  }
  for(int j=0;j<m_nb_champ;j++)
  {
    ofstrm << m_max[j] << " ";
  }
  ofstrm << std::endl;
  if(avec_histo)
    for(int j=0;j<m_nb_champ;j++)
    {
      char nom_fichier[500];
      sprintf(nom_fichier,"%s/histo_%s_%i.txt",prefix_histo,m_identifiant.c_str(),j);
      std::ofstream of_histo(nom_fichier,std::ios::out|std::ios::trunc);
      of_histo.precision(16);
      of_histo.setf(std::ios::showpoint);
      m_tab_histogramme[j]->exporter(of_histo);
      of_histo.close();
      
      if(m_nb_champ==6)
      {
        OT_TENSEUR tenseur(3,3);
        tenseur(0,0)=m_moyenne[0];
        tenseur(1,1)=m_moyenne[1];
        tenseur(2,2)=m_moyenne[2];
        tenseur(0,1)=m_moyenne[3];
        tenseur(0,2)=m_moyenne[4];
        tenseur(1,2)=m_moyenne[5];
        tenseur(1,0)=m_moyenne[3];
        tenseur(2,0)=m_moyenne[4];
        tenseur(2,1)=m_moyenne[5];
        OT_TENSEUR tenseur_ecart_type(3,3);
        tenseur_ecart_type(0,0)=m_ecart_type[0];
        tenseur_ecart_type(1,1)=m_ecart_type[1];
        tenseur_ecart_type(2,2)=m_ecart_type[2];
        tenseur_ecart_type(0,1)=m_ecart_type[3];
        tenseur_ecart_type(0,2)=m_ecart_type[4];
        tenseur_ecart_type(1,2)=m_ecart_type[5];
        tenseur_ecart_type(1,0)=m_ecart_type[3];
        tenseur_ecart_type(2,0)=m_ecart_type[4];
        tenseur_ecart_type(2,1)=m_ecart_type[5];
        char nom_plot[500];
        sprintf(nom_plot,"%s/tenseur_%s.plt",prefix_histo,m_identifiant.c_str());
        MAGIC_PLOT magic_plot;
        magic_plot.tenseur_couleur=MAGIC_PLOT::COULEUR::GRIS;
        magic_plot.tenseur_titre="Tenseur champ";
        magic_plot.tenseur_titrebarcouleur="";
        magic_plot.plot_script_tenseur(2,tenseur,tenseur_ecart_type,nom_plot,true);
      }
    }
}

void MSTRUCT_ANALYSE_CHAMP::enregistrer(std::ofstream& ofstrm)
{
  long type_analyse=get_type();
  ofstrm.write((char*)&type_analyse,sizeof(long));
  MSTRUCT_ANALYSE::enregistrer(ofstrm);
  ofstrm.write((char*)&m_id_fem_solution,sizeof(long));
  ofstrm.write((char*)&m_nb_champ,sizeof(int));
  for(int i=0;i<m_nb_champ;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));
    m_tab_histogramme[i]->enregistrer_bin(ofstrm);
  }
}

void MSTRUCT_ANALYSE_CHAMP::ouvrir(std::ifstream& ifstrm)
{
  MSTRUCT_ANALYSE::ouvrir(ifstrm);
  ifstrm.read((char*)&m_id_fem_solution,sizeof(long));
  ifstrm.read((char*)&m_nb_champ,sizeof(int));
  m_moyenne = new double[m_nb_champ];
  m_ecart_type = new double[m_nb_champ];
  m_min = new double[m_nb_champ];
  m_max = new double[m_nb_champ];
  m_tab_histogramme=new OT_HISTOGRAMME*[m_nb_champ];
  for(int i=0;i<m_nb_champ;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));
    m_tab_histogramme[i] = new OT_HISTOGRAMME();
    m_tab_histogramme[i]->ouvrir_bin(ifstrm);
  }
}

void MSTRUCT_ANALYSE_CHAMP::affiche_contenu(fonction_affiche* fonc)
{
  MSTRUCT_ANALYSE::affiche_contenu(fonc);
  char ligne[5000];
  sprintf(ligne,"MSTRUCT_ANALYSE_CHAMP");
  fonc(ligne);
  sprintf(ligne,"-> ID FEM solution : %li", m_id_fem_solution);
  fonc(ligne);
  sprintf(ligne,"-> NB champ : %i", m_nb_champ);
  fonc(ligne);
  char valeur[100];
  sprintf(ligne,"-> Moyenne :    [");  
  for(int i=0;i<m_nb_champ-1;i++)
  {
    sprintf(valeur,"%lf,",m_moyenne[i]);
    strcat(ligne,valeur);
  }
  sprintf(valeur,"%lf]",m_moyenne[m_nb_champ-1]);
  strcat(ligne,valeur);
  fonc(ligne);
  sprintf(ligne,"-> Ecart-type : [");  
  for(int i=0;i<m_nb_champ-1;i++)
  {
    sprintf(valeur,"%lf,",m_ecart_type[i]);
    strcat(ligne,valeur);
  }
  sprintf(valeur,"%lf]",m_ecart_type[m_nb_champ-1]);
  strcat(ligne,valeur);
  fonc(ligne);
  sprintf(ligne,"-> Min :        [");  
  for(int i=0;i<m_nb_champ-1;i++)
  {
    sprintf(valeur,"%lf,",m_min[i]);
    strcat(ligne,valeur);
  }
  sprintf(valeur,"%lf]",m_min[m_nb_champ-1]);
  strcat(ligne,valeur);
  fonc(ligne);
  sprintf(ligne,"-> Max :        [");  
  for(int i=0;i<m_nb_champ-1;i++)
  {
    sprintf(valeur,"%lf,",m_max[i]);
    strcat(ligne,valeur);
  }
  sprintf(valeur,"%lf]",m_max[m_nb_champ-1]);
  strcat(ligne,valeur);
  fonc(ligne);
  for(int i=0;i<m_nb_champ;i++)
  {
    sprintf(ligne,"-> OT_HISTOGRAMME[%i] : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)",i,
                                                                                                        m_tab_histogramme[i]->get_nb_colonne(),
                                                                                                        m_tab_histogramme[i]->get_largeur_colonne(),
                                                                                                        m_tab_histogramme[i]->get_x_min(),
                                                                                                        m_tab_histogramme[i]->get_x_max());
    fonc(ligne);
  }
}


MSTRUCT_ANALYSE_ORIENTATION::MSTRUCT_ANALYSE_ORIENTATION(void): MSTRUCT_ANALYSE()
{
}

MSTRUCT_ANALYSE_ORIENTATION::MSTRUCT_ANALYSE_ORIENTATION(std::string identifiant,
                                                                 std::string nom_groupe_forme,
                                                                 BOITE_3D* boite_3d): MSTRUCT_ANALYSE(identifiant, nom_groupe_forme, boite_3d)
{
}

MSTRUCT_ANALYSE_ORIENTATION::MSTRUCT_ANALYSE_ORIENTATION(MSTRUCT_ANALYSE_ORIENTATION& mdd): MSTRUCT_ANALYSE(mdd)
{
  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(std::vector< MSTRUCT_ANALYSE_ORIENTATION* >& vector_analyse_orientation): MSTRUCT_ANALYSE()
{
  std::vector<MSTRUCT_ANALYSE_ORIENTATION*>::iterator it_analyse=vector_analyse_orientation.begin();
  MSTRUCT_ANALYSE_ORIENTATION* analyse = *it_analyse;
  m_identifiant=analyse->get_identifiant();
  if(analyse->get_boite_analyse()!=NULL) change_boite_analyse(*analyse->get_boite_analyse());
  m_nom_groupe_forme=analyse->get_nom_groupe_forme();
  m_nb_ves=vector_analyse_orientation.size();
  for(int i=0;i<6;i++)
  {
    m_moyenne[i]=0;
    m_ecart_type[i]=0;
    m_min[i]=std::numeric_limits< double >::max();
    m_max[i]=std::numeric_limits< double >::min();
  }
  for(it_analyse=vector_analyse_orientation.begin();it_analyse!=vector_analyse_orientation.end();it_analyse++)
  {
    analyse = *it_analyse;
    for(int i=0;i<6;i++)
    {
      m_moyenne[i]+=analyse->get_moyenne()[i];
      if(analyse->get_min()[i]<m_min[i]) m_min[i]=analyse->get_min()[i];
      if(analyse->get_max()[i]>m_max[i]) m_max[i]=analyse->get_max()[i];
    }
  }
  for(int i=0;i<6;i++)
  {
    m_moyenne[i]=m_moyenne[i]/m_nb_ves;
  }
  if(m_nb_ves>1)
  {
    for(it_analyse=vector_analyse_orientation.begin();it_analyse!=vector_analyse_orientation.end();it_analyse++)
    {
      analyse = *it_analyse;
      for(int i=0;i<6;i++)
      {
        m_ecart_type[i]+=(analyse->get_moyenne()[i]-m_moyenne[i])*(analyse->get_moyenne()[i]-m_moyenne[i]);
      }
    }
    for(int i=0;i<6;i++)
    {
      m_ecart_type[i]=sqrt(m_ecart_type[i]*(1.0/(m_nb_ves-1.0)));
    }
  }
}


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 TYPE_ANALYSE::ORIENTATION;
}

void MSTRUCT_ANALYSE_ORIENTATION::executer(MSTRUCT_VES* ves)
{
  MG_CG_GROUPE_FORME* groupe_forme=NULL;
  if(m_nom_groupe_forme!="ALL") groupe_forme=ves->get_mgcg_modele()->get_mgcg_groupe_forme(m_nom_groupe_forme);
  MSTRUCT_OUTILS::statistiques_tenseur_orientation(groupe_forme,m_boite_analyse,m_moyenne,m_ecart_type,m_min,m_max);
}

void MSTRUCT_ANALYSE_ORIENTATION::exporter(std::ofstream& ofstrm, long i, bool avec_entete, bool avec_histo, char* prefix_histo)
{
  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_histo)
  {
    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_histo,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);
  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);
  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);
}


MSTRUCT_ANALYSE_ORIENTATION_PONDEREE::MSTRUCT_ANALYSE_ORIENTATION_PONDEREE(void): MSTRUCT_ANALYSE_ORIENTATION()
{
}

MSTRUCT_ANALYSE_ORIENTATION_PONDEREE::MSTRUCT_ANALYSE_ORIENTATION_PONDEREE(std::string identifiant,
                                                                           std::string nom_groupe_forme,
                                                                           BOITE_3D* boite_3d,
                                                                           bool avec_fem_maillage): MSTRUCT_ANALYSE_ORIENTATION(identifiant, nom_groupe_forme, boite_3d),m_avec_fem_maillage(avec_fem_maillage)
{
}

MSTRUCT_ANALYSE_ORIENTATION_PONDEREE::MSTRUCT_ANALYSE_ORIENTATION_PONDEREE(MSTRUCT_ANALYSE_ORIENTATION_PONDEREE& mdd): MSTRUCT_ANALYSE_ORIENTATION(mdd)
{
}

MSTRUCT_ANALYSE_ORIENTATION_PONDEREE::MSTRUCT_ANALYSE_ORIENTATION_PONDEREE(std::vector< MSTRUCT_ANALYSE_ORIENTATION* >& vector_analyse_orientation): MSTRUCT_ANALYSE_ORIENTATION(vector_analyse_orientation)
{
}

MSTRUCT_ANALYSE_ORIENTATION_PONDEREE::~MSTRUCT_ANALYSE_ORIENTATION_PONDEREE(void)
{
}

long int MSTRUCT_ANALYSE_ORIENTATION_PONDEREE::get_type(void)
{
  return TYPE_ANALYSE::ORIENTATION_PONDEREE;
}

bool MSTRUCT_ANALYSE_ORIENTATION_PONDEREE::get_avec_fem_maillage(void)
{
  return m_avec_fem_maillage;
}

void MSTRUCT_ANALYSE_ORIENTATION_PONDEREE::change_avec_fem_maillage(bool avec_fem_maillage)
{
  m_avec_fem_maillage=avec_fem_maillage;
}

void MSTRUCT_ANALYSE_ORIENTATION_PONDEREE::executer(MSTRUCT_VES* ves)
{
  MG_CG_GROUPE_FORME* groupe_forme=NULL;
  FEM_MAILLAGE* fem_maill=NULL;
  if(m_nom_groupe_forme!="ALL") groupe_forme=ves->get_mgcg_modele()->get_mgcg_groupe_forme(m_nom_groupe_forme);
  if(m_avec_fem_maillage) fem_maill=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,true);
}

void MSTRUCT_ANALYSE_ORIENTATION_PONDEREE::enregistrer(std::ofstream& ofstrm)
{
  MSTRUCT_ANALYSE_ORIENTATION::enregistrer(ofstrm);
  ofstrm.write((char*)&m_avec_fem_maillage,sizeof(bool));
}

void MSTRUCT_ANALYSE_ORIENTATION_PONDEREE::ouvrir(std::ifstream& ifstrm)
{
  MSTRUCT_ANALYSE_ORIENTATION::ouvrir(ifstrm);
  ifstrm.read((char*)&m_avec_fem_maillage,sizeof(bool));
}

void MSTRUCT_ANALYSE_ORIENTATION_PONDEREE::exporter(std::ofstream& ofstrm, long i, bool avec_entete, bool avec_histo, char* prefix_histo)
{
  MSTRUCT_ANALYSE_ORIENTATION::exporter(ofstrm, i, avec_entete, avec_histo, prefix_histo);
}


void MSTRUCT_ANALYSE_ORIENTATION_PONDEREE::affiche_contenu(fonction_affiche* fonc)
{
  MSTRUCT_ANALYSE::affiche_contenu(fonc);
  char ligne[5000];
  sprintf(ligne,"MSTRUCT_ANALYSE_ORIENTATION_PONDEREE");
  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);}


MSTRUCT_ANALYSE_CAO::MSTRUCT_ANALYSE_CAO(void): MSTRUCT_ANALYSE()
{
}

MSTRUCT_ANALYSE_CAO::MSTRUCT_ANALYSE_CAO(std::string identifiant,
                                         double largeur_colonne_nb_forme,
                                         double largeur_colonne_nb_volume,
                                         double largeur_colonne_volume,
                                         double largeur_colonne_fraction_volumique,
                                         double largeur_colonne_volume_forme,
                                         std::string nom_groupe_forme): MSTRUCT_ANALYSE(identifiant,nom_groupe_forme)
{
  m_nb_forme_histogramme.fixe_largeur_colonne(largeur_colonne_nb_forme);
  m_nb_volume_histogramme.fixe_largeur_colonne(largeur_colonne_nb_volume);
  m_volume_histogramme.fixe_largeur_colonne(largeur_colonne_volume);
  m_fraction_volumique_histogramme.fixe_largeur_colonne(largeur_colonne_fraction_volumique);
  m_volume_forme_histogramme.fixe_largeur_colonne(largeur_colonne_volume_forme);
}

MSTRUCT_ANALYSE_CAO::MSTRUCT_ANALYSE_CAO(std::vector< MSTRUCT_ANALYSE_CAO* >& vector_analyse_cao): MSTRUCT_ANALYSE()
{
  std::vector<MSTRUCT_ANALYSE_CAO*>::iterator it_analyse=vector_analyse_cao.begin();
  MSTRUCT_ANALYSE_CAO* analyse = *it_analyse;
  m_identifiant=analyse->get_identifiant();
  if(analyse->get_boite_analyse()!=NULL) change_boite_analyse(*analyse->get_boite_analyse());
  m_nom_groupe_forme=analyse->get_nom_groupe_forme();
  m_nb_ves=vector_analyse_cao.size();
  
  m_nb_forme_histogramme.fixe_largeur_colonne(analyse->get_distribution_nb_forme()->get_largeur_colonne());
  m_nb_volume_histogramme.fixe_largeur_colonne(analyse->get_distribution_nb_volume()->get_largeur_colonne());
  m_volume_histogramme.fixe_largeur_colonne(analyse->get_distribution_volume()->get_largeur_colonne());
  m_fraction_volumique_histogramme.fixe_largeur_colonne(analyse->get_distribution_fraction_volumique()->get_largeur_colonne());
  m_volume_forme_histogramme.fixe_largeur_colonne(analyse->get_distribution_volume_forme()->get_largeur_colonne());
    
  m_nb_forme_moyenne=0.0;
  m_nb_forme_ecart_type=0.0;
  m_nb_forme_min=std::numeric_limits< long >::max();
  m_nb_forme_max=std::numeric_limits< long >::min();  
  m_nb_volume_moyenne=0.0;
  m_nb_volume_ecart_type=0.0;
  m_nb_volume_min=std::numeric_limits< long >::max();
  m_nb_volume_max=std::numeric_limits< long >::min();
  m_volume_forme_moyenne=0.0;
  m_volume_forme_ecart_type=0.0;
  m_volume_forme_min=std::numeric_limits< double >::max();
  m_volume_forme_max=std::numeric_limits< double >::min();
  m_volume_moyenne=0.0;
  m_volume_ecart_type=0.0;
  m_volume_min=std::numeric_limits< double >::max();
  m_volume_max=std::numeric_limits< double >::min();
  m_fraction_volumique_moyenne=0.0;
  m_fraction_volumique_ecart_type=0.0;
  m_fraction_volumique_min=std::numeric_limits< double >::max();
  m_fraction_volumique_max=std::numeric_limits< double >::min();
  
  for(it_analyse=vector_analyse_cao.begin();it_analyse!=vector_analyse_cao.end();it_analyse++)
  {
    analyse = *it_analyse;
    
    m_nb_forme_moyenne+=analyse->get_nb_forme_moyenne();
    m_nb_forme_histogramme.ajouter_valeur(analyse->get_nb_forme_moyenne(),1./m_nb_ves);
    if(analyse->get_nb_forme_min()<m_nb_forme_min) m_nb_forme_min=analyse->get_nb_forme_min();
    if(analyse->get_nb_forme_max()>m_nb_forme_max) m_nb_forme_max=analyse->get_nb_forme_max();
    
    m_nb_volume_moyenne+=analyse->get_nb_volume_moyenne();
    m_nb_volume_histogramme.ajouter_valeur(analyse->get_nb_volume_moyenne(),1./m_nb_ves);
    if(analyse->get_nb_volume_min()<m_nb_volume_min) m_nb_volume_min=analyse->get_nb_volume_min();
    if(analyse->get_nb_volume_max()>m_nb_volume_max) m_nb_volume_max=analyse->get_nb_volume_max();
    
    m_volume_forme_moyenne+=analyse->get_volume_forme_moyenne();
    std::map<long,double>::iterator it_his;
    double val;
    long l;
    int k=analyse->get_distribution_volume_forme()->get_premiere_valeur(it_his,val,l);
    while(k!=0)
    {
      m_volume_forme_histogramme.ajouter_valeur(l,val/m_nb_ves);
      k=analyse->get_distribution_volume_forme()->get_suivante_valeur(it_his,val,l);
    }
    if(analyse->get_volume_forme_min()<m_volume_forme_min) m_volume_forme_min=analyse->get_volume_forme_min();
    if(analyse->get_volume_forme_max()>m_volume_forme_max) m_volume_forme_max=analyse->get_volume_forme_max();
    
    m_volume_moyenne+=analyse->get_volume_moyenne();
    m_volume_histogramme.ajouter_valeur(analyse->get_volume_moyenne(),1./m_nb_ves);
    if(analyse->get_volume_min()<m_volume_min) m_volume_min=analyse->get_volume_min();
    if(analyse->get_volume_max()>m_volume_max) m_volume_max=analyse->get_volume_max();
    
    m_fraction_volumique_moyenne+=analyse->get_fraction_volumique_moyenne();
    m_fraction_volumique_histogramme.ajouter_valeur(analyse->get_fraction_volumique_moyenne(),1./m_nb_ves);
    if(analyse->get_fraction_volumique_min()<m_fraction_volumique_min) m_fraction_volumique_min=analyse->get_fraction_volumique_min();
    if(analyse->get_fraction_volumique_max()>m_fraction_volumique_max) m_fraction_volumique_max=analyse->get_fraction_volumique_max();
  }
  m_nb_forme_moyenne=m_nb_forme_moyenne/m_nb_ves;
  m_nb_volume_moyenne=m_nb_volume_moyenne/m_nb_ves;
  m_volume_forme_moyenne=m_volume_forme_moyenne/m_nb_ves;
  m_volume_moyenne=m_volume_moyenne/m_nb_ves;
  m_fraction_volumique_moyenne=m_fraction_volumique_moyenne/m_nb_ves;
  if(m_nb_ves>1)
  {
    for(it_analyse=vector_analyse_cao.begin();it_analyse!=vector_analyse_cao.end();it_analyse++)
    {
      analyse = *it_analyse;
      m_nb_forme_ecart_type+=(analyse->get_nb_forme_moyenne()-m_nb_forme_moyenne)*(analyse->get_nb_forme_moyenne()-m_nb_forme_moyenne);
      m_nb_volume_ecart_type+=(analyse->get_nb_volume_moyenne()-m_nb_volume_moyenne)*(analyse->get_nb_volume_moyenne()-m_nb_volume_moyenne);
      m_volume_forme_ecart_type+=(analyse->get_volume_forme_moyenne()-m_volume_forme_moyenne)*(analyse->get_volume_forme_moyenne()-m_volume_forme_moyenne);
      m_volume_ecart_type+=(analyse->get_volume_moyenne()-m_volume_moyenne)*(analyse->get_volume_moyenne()-m_volume_moyenne);
      m_fraction_volumique_ecart_type+=(analyse->get_fraction_volumique_moyenne()-m_fraction_volumique_moyenne)*(analyse->get_fraction_volumique_moyenne()-m_fraction_volumique_moyenne);
    }
    m_nb_forme_ecart_type=sqrt(m_nb_forme_ecart_type*(1.0/(m_nb_ves-1.0)));  
    m_nb_volume_ecart_type=sqrt(m_nb_volume_ecart_type*(1.0/(m_nb_ves-1.0))); 
    m_volume_forme_ecart_type=sqrt(m_volume_forme_ecart_type*(1.0/(m_nb_ves-1.0))); 
    m_volume_ecart_type=sqrt(m_volume_ecart_type*(1.0/(m_nb_ves-1.0))); 
    m_fraction_volumique_ecart_type=sqrt(m_fraction_volumique_ecart_type*(1.0/(m_nb_ves-1.0))); 
  }
}


MSTRUCT_ANALYSE_CAO::MSTRUCT_ANALYSE_CAO(MSTRUCT_ANALYSE_CAO& mdd): MSTRUCT_ANALYSE(mdd)
{
  m_nb_forme_min=mdd.m_nb_forme_min;
  m_nb_forme_max=mdd.m_nb_forme_max;
  m_nb_forme_moyenne=mdd.m_nb_forme_moyenne;
  m_nb_forme_ecart_type=mdd.m_nb_forme_ecart_type;
  
  m_nb_volume_min=mdd.m_nb_volume_min;
  m_nb_volume_max=mdd.m_nb_volume_max;
  m_nb_volume_moyenne=mdd.m_nb_volume_moyenne;
  m_nb_volume_ecart_type=mdd.m_nb_volume_ecart_type;
  
  m_volume_forme_min=mdd.m_volume_forme_min;
  m_volume_forme_max=mdd.m_volume_forme_max;
  m_volume_forme_moyenne=mdd.m_volume_forme_moyenne;
  m_volume_forme_ecart_type=mdd.m_volume_forme_ecart_type;
  m_volume_forme_histogramme=mdd.m_volume_forme_histogramme;
  
  m_volume_min=mdd.m_volume_min;
  m_volume_max=mdd.m_volume_max;
  m_volume_moyenne=mdd.m_volume_moyenne;
  m_volume_ecart_type=mdd.m_volume_ecart_type;
  m_volume_histogramme=mdd.m_volume_histogramme;
  
  m_fraction_volumique_min=mdd.m_fraction_volumique_min;
  m_fraction_volumique_max=mdd.m_fraction_volumique_max;
  m_fraction_volumique_ecart_type=mdd.m_fraction_volumique_ecart_type;
  m_fraction_volumique_moyenne=mdd.m_fraction_volumique_moyenne;
}

MSTRUCT_ANALYSE_CAO::~MSTRUCT_ANALYSE_CAO(void)
{
}

long int MSTRUCT_ANALYSE_CAO::get_nb_forme_min(void)
{
  return m_nb_forme_min;
}

long int MSTRUCT_ANALYSE_CAO::get_nb_forme_max(void)
{
  return m_nb_forme_max;
}

long int MSTRUCT_ANALYSE_CAO::get_nb_forme_moyenne(void)
{
  return m_nb_forme_moyenne;
}

long int MSTRUCT_ANALYSE_CAO::get_nb_forme_ecart_type(void)
{
  return m_nb_forme_ecart_type;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_CAO::get_distribution_nb_forme(void)
{
  return &m_nb_forme_histogramme;
}

long int MSTRUCT_ANALYSE_CAO::get_nb_volume_min(void)
{
  return m_nb_volume_min;
}

long int MSTRUCT_ANALYSE_CAO::get_nb_volume_max(void)
{
  return m_nb_volume_max;
}

long int MSTRUCT_ANALYSE_CAO::get_nb_volume_moyenne(void)
{
  return m_nb_volume_moyenne;
}
long int MSTRUCT_ANALYSE_CAO::get_nb_volume_ecart_type(void)
{
  return m_nb_volume_ecart_type;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_CAO::get_distribution_nb_volume(void)
{
  return &m_nb_volume_histogramme;
}

double MSTRUCT_ANALYSE_CAO::get_volume_forme_min(void)
{
  return m_volume_forme_min;
}

double MSTRUCT_ANALYSE_CAO::get_volume_forme_max(void)
{
  return m_volume_forme_max;
}

double MSTRUCT_ANALYSE_CAO::get_volume_forme_moyenne(void)
{
  return m_volume_forme_moyenne;
}

double MSTRUCT_ANALYSE_CAO::get_volume_forme_ecart_type(void)
{
  return m_volume_forme_ecart_type;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_CAO::get_distribution_volume_forme(void)
{
  return &m_volume_forme_histogramme;
}

double MSTRUCT_ANALYSE_CAO::get_volume_moyenne(void)
{
  return m_volume_moyenne;
}

double MSTRUCT_ANALYSE_CAO::get_volume_ecart_type(void)
{
  return m_volume_ecart_type;
}

double MSTRUCT_ANALYSE_CAO::get_volume_min(void)
{
  return m_volume_min;
}

double MSTRUCT_ANALYSE_CAO::get_volume_max(void)
{
  return m_volume_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_CAO::get_distribution_volume(void)
{
  return &m_volume_histogramme;
}

double MSTRUCT_ANALYSE_CAO::get_fraction_volumique_ecart_type(void)
{
  return m_fraction_volumique_ecart_type;
}

double MSTRUCT_ANALYSE_CAO::get_fraction_volumique_moyenne(void)
{
  return m_fraction_volumique_moyenne;
}

double MSTRUCT_ANALYSE_CAO::get_fraction_volumique_min(void)
{
  return m_fraction_volumique_min;
}

double MSTRUCT_ANALYSE_CAO::get_fraction_volumique_max(void)
{
  return m_fraction_volumique_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_CAO::get_distribution_fraction_volumique(void)
{
  return &m_fraction_volumique_histogramme;
}

long int MSTRUCT_ANALYSE_CAO::get_type(void)
{
  return TYPE_ANALYSE::CAO;
}

void MSTRUCT_ANALYSE_CAO::executer(MSTRUCT_VES* ves)
{
  MG_CG_GROUPE_FORME* groupe_forme=NULL;
  if(m_nom_groupe_forme!="ALL") groupe_forme=ves->get_mgcg_modele()->get_mgcg_groupe_forme(m_nom_groupe_forme);
  TPL_MAP_ENTITE<MG_CG_FORME*> tpl_map_forme;
  if(groupe_forme!=NULL)
  {
    std::map<long,MG_CG_FORME*>::iterator it_forme;
    for(MG_CG_FORME* forme=groupe_forme->get_premiere_mgcg_forme(it_forme);forme!=NULL;forme=groupe_forme->get_suivante_mgcg_forme(it_forme))
    {
      tpl_map_forme.ajouter(forme);
    }
  }
  else
  {
    std::map<long,MG_CG_FORME*>::iterator it_forme;
    MG_CG_ASSEMBLAGE* mgcg_ass=ves->get_mgcg_assemblage();
    for(MG_CG_FORME*forme=mgcg_ass->get_premiere_mgcg_forme(it_forme);forme!=NULL;forme=mgcg_ass->get_suivante_mgcg_forme(it_forme))
    {
      tpl_map_forme.ajouter(forme);
    }
  }
  MSTRUCT_OUTILS::statistiques_CAO(ves->get_boite3d_ves(),
                           tpl_map_forme,
                           m_nb_forme_moyenne,
                           m_nb_volume_moyenne,
                           m_volume_forme_moyenne,
                           m_volume_forme_ecart_type,
                           m_volume_forme_min,
                           m_volume_forme_max,
                           m_volume_forme_histogramme,
                           m_volume_moyenne,
                           m_fraction_volumique_moyenne);
  
  m_nb_forme_min=m_nb_forme_moyenne;
  m_nb_forme_max=m_nb_forme_moyenne;
  m_nb_forme_ecart_type=0.0;
  m_nb_volume_min=m_nb_volume_moyenne;
  m_nb_volume_max=m_nb_volume_moyenne;
  m_nb_volume_ecart_type=0.0;  
  m_volume_min=m_volume_moyenne;
  m_volume_max=m_volume_moyenne;
  m_volume_ecart_type=0.0;
  m_fraction_volumique_min=m_fraction_volumique_moyenne;
  m_fraction_volumique_max=m_fraction_volumique_moyenne;
  m_fraction_volumique_ecart_type=0.0;
}

void MSTRUCT_ANALYSE_CAO::exporter(std::ofstream& ofstrm, long i, bool avec_entete, bool avec_histo, char* prefix_histo)
{
  if(avec_entete)
    ofstrm << "#(1) volume[moy(2) ±(3) min(4) max(5)] frac_vol[moy(6) ±(7) min(8) max(9)] nb_forme[moy(10) ±(11) min(12) max(13)] nb_volume[moy(14) ±(15) min(16) max(17)] volume_forme[moy(18) ±(19) min(20) max(21)]" << std::endl;
  ofstrm << i << " " 
         << m_volume_moyenne << " "
         << m_volume_ecart_type << " "
         << m_volume_min << " "
         << m_volume_max << " "
         << m_fraction_volumique_moyenne << " "
         << m_fraction_volumique_ecart_type << " "
         << m_fraction_volumique_min << " "
         << m_fraction_volumique_max << " "
         << m_nb_forme_moyenne << " "
         << m_nb_forme_ecart_type << " "
         << m_nb_forme_min << " "
         << m_nb_forme_max << " "
         << m_nb_volume_moyenne << " "
         << m_nb_volume_ecart_type << " "
         << m_nb_volume_min << " "
         << m_nb_volume_max << " "
         << m_volume_forme_moyenne << " "
         << m_volume_forme_ecart_type << " "
         << m_volume_forme_min << " "
         << m_volume_forme_max << std::endl;
  if(avec_histo)
  {
    char nom_fichier[500];
    sprintf(nom_fichier,"%s/histo_%s_volume_forme.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_volume_forme(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_volume_forme.precision(16);
    of_histo_volume_forme.setf(std::ios::showpoint);
    m_volume_forme_histogramme.exporter(of_histo_volume_forme);
    of_histo_volume_forme.close();
    
    sprintf(nom_fichier,"%s/histo_%s_volume.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_volume(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_volume.precision(16);
    of_histo_volume.setf(std::ios::showpoint);
    m_volume_histogramme.exporter(of_histo_volume);
    of_histo_volume.close();
    
    sprintf(nom_fichier,"%s/histo_%s_frac_vol.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_frac_vol(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_frac_vol.precision(16);
    of_histo_frac_vol.setf(std::ios::showpoint);
    m_fraction_volumique_histogramme.exporter(of_histo_frac_vol);
    of_histo_frac_vol.close();
    
    sprintf(nom_fichier,"%s/histo_%s_nb_forme.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_nb_forme(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_nb_forme.precision(16);
    of_histo_nb_forme.setf(std::ios::showpoint);
    m_nb_forme_histogramme.exporter(of_histo_nb_forme);
    of_histo_nb_forme.close();
    
    sprintf(nom_fichier,"%s/histo_%s_nb_vol.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_nb_volume(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_nb_volume.precision(16);
    of_histo_nb_volume.setf(std::ios::showpoint);
    m_nb_volume_histogramme.exporter(of_histo_nb_volume);
    of_histo_nb_volume.close();
  }
  
}

void MSTRUCT_ANALYSE_CAO::enregistrer(std::ofstream& ofstrm)
{
  long type_analyse=get_type();
  ofstrm.write((char*)&type_analyse,sizeof(long));
  MSTRUCT_ANALYSE::enregistrer(ofstrm);
  ofstrm.write((char*)&m_nb_forme_moyenne,sizeof(long));
  ofstrm.write((char*)&m_nb_forme_ecart_type,sizeof(long));
  ofstrm.write((char*)&m_nb_forme_min,sizeof(long));
  ofstrm.write((char*)&m_nb_forme_max,sizeof(long));
  m_nb_forme_histogramme.enregistrer_bin(ofstrm);
  ofstrm.write((char*)&m_nb_volume_moyenne,sizeof(long));
  ofstrm.write((char*)&m_nb_volume_ecart_type,sizeof(long));
  ofstrm.write((char*)&m_nb_volume_min,sizeof(long));
  ofstrm.write((char*)&m_nb_volume_max,sizeof(long));
  m_nb_volume_histogramme.enregistrer_bin(ofstrm);
  ofstrm.write((char*)&m_volume_forme_moyenne,sizeof(double));
  ofstrm.write((char*)&m_volume_forme_ecart_type,sizeof(double));
  ofstrm.write((char*)&m_volume_forme_min,sizeof(double));
  ofstrm.write((char*)&m_volume_forme_max,sizeof(double));
  m_volume_forme_histogramme.enregistrer_bin(ofstrm);
  ofstrm.write((char*)&m_volume_moyenne,sizeof(double));
  ofstrm.write((char*)&m_volume_ecart_type,sizeof(double));
  ofstrm.write((char*)&m_volume_min,sizeof(double));
  ofstrm.write((char*)&m_volume_max,sizeof(double));
  m_volume_histogramme.enregistrer_bin(ofstrm);
  ofstrm.write((char*)&m_fraction_volumique_moyenne,sizeof(double));
  ofstrm.write((char*)&m_fraction_volumique_ecart_type,sizeof(double));
  ofstrm.write((char*)&m_fraction_volumique_min,sizeof(double));
  ofstrm.write((char*)&m_fraction_volumique_max,sizeof(double));
  m_fraction_volumique_histogramme.enregistrer_bin(ofstrm);
}

void MSTRUCT_ANALYSE_CAO::ouvrir(std::ifstream& ifstrm)
{
  MSTRUCT_ANALYSE::ouvrir(ifstrm);
  ifstrm.read((char*)&m_nb_forme_moyenne,sizeof(long));
  ifstrm.read((char*)&m_nb_forme_ecart_type,sizeof(long));
  ifstrm.read((char*)&m_nb_forme_min,sizeof(long));
  ifstrm.read((char*)&m_nb_forme_max,sizeof(long));
  m_nb_forme_histogramme.ouvrir_bin(ifstrm);
  ifstrm.read((char*)&m_nb_volume_moyenne,sizeof(long));
  ifstrm.read((char*)&m_nb_volume_ecart_type,sizeof(long));
  ifstrm.read((char*)&m_nb_volume_min,sizeof(long));
  ifstrm.read((char*)&m_nb_volume_max,sizeof(long));
  m_nb_volume_histogramme.ouvrir_bin(ifstrm);
  ifstrm.read((char*)&m_volume_forme_moyenne,sizeof(double));
  ifstrm.read((char*)&m_volume_forme_ecart_type,sizeof(double));
  ifstrm.read((char*)&m_volume_forme_min,sizeof(double));
  ifstrm.read((char*)&m_volume_forme_max,sizeof(double));
  m_volume_forme_histogramme.ouvrir_bin(ifstrm);
  ifstrm.read((char*)&m_volume_moyenne,sizeof(double));
  ifstrm.read((char*)&m_volume_ecart_type,sizeof(double));
  ifstrm.read((char*)&m_volume_min,sizeof(double));
  ifstrm.read((char*)&m_volume_max,sizeof(double));
  m_volume_histogramme.ouvrir_bin(ifstrm);
  ifstrm.read((char*)&m_fraction_volumique_moyenne,sizeof(double));
  ifstrm.read((char*)&m_fraction_volumique_ecart_type,sizeof(double));
  ifstrm.read((char*)&m_fraction_volumique_min,sizeof(double));
  ifstrm.read((char*)&m_fraction_volumique_max,sizeof(double));
  m_fraction_volumique_histogramme.ouvrir_bin(ifstrm);
}

void MSTRUCT_ANALYSE_CAO::affiche_contenu(fonction_affiche* fonc)
{
  MSTRUCT_ANALYSE::affiche_contenu(fonc);
  char ligne[5000];
  sprintf(ligne,"MSTRUCT_ANALYSE_CAO");
  fonc(ligne);
  sprintf(ligne,"-> Moyenne nb forme    : %li",m_nb_forme_moyenne); fonc(ligne);
  sprintf(ligne,"-> Ecart-type nb forme    : %li",m_nb_forme_ecart_type); fonc(ligne);
  sprintf(ligne,"-> Min nb forme    : %li",m_nb_forme_min); fonc(ligne);
  sprintf(ligne,"-> Max nb forme    : %li",m_nb_forme_max); fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME nb forme : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_nb_forme_histogramme.get_nb_colonne(),
                                                                                                          m_nb_forme_histogramme.get_largeur_colonne(),
                                                                                                          m_nb_forme_histogramme.get_x_min(),
                                                                                                          m_nb_forme_histogramme.get_x_max());
  fonc(ligne);
  sprintf(ligne,"-> Moyenne nb volume    : %li",m_nb_volume_moyenne); fonc(ligne);
  sprintf(ligne,"-> Ecart-type nb volume    : %li",m_nb_volume_ecart_type); fonc(ligne);
  sprintf(ligne,"-> Min nb volume    : %li",m_nb_volume_min); fonc(ligne);
  sprintf(ligne,"-> Max nb volume    : %li",m_nb_volume_max); fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME nb volume : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_nb_volume_histogramme.get_nb_colonne(),
                                                                                                          m_nb_volume_histogramme.get_largeur_colonne(),
                                                                                                          m_nb_volume_histogramme.get_x_min(),
                                                                                                          m_nb_volume_histogramme.get_x_max());
  fonc(ligne);
  sprintf(ligne,"-> Moyenne volume      : %lf",m_volume_moyenne); fonc(ligne);
  sprintf(ligne,"-> Ecart-type volume   : %lf",m_volume_ecart_type); fonc(ligne);
  sprintf(ligne,"-> Min volume          : %lf",m_volume_min); fonc(ligne);
  sprintf(ligne,"-> Max volume          : %lf",m_volume_max); fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME volume : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_volume_histogramme.get_nb_colonne(),
                                                                                                          m_volume_histogramme.get_largeur_colonne(),
                                                                                                          m_volume_histogramme.get_x_min(),
                                                                                                          m_volume_histogramme.get_x_max());
  fonc(ligne);
  sprintf(ligne,"-> Moyenne fraction volumique      : %lf",m_fraction_volumique_moyenne); fonc(ligne);
  sprintf(ligne,"-> Ecart-type fraction volumique      : %lf",m_fraction_volumique_ecart_type); fonc(ligne);
  sprintf(ligne,"-> Min fraction volumique      : %lf",m_fraction_volumique_min); fonc(ligne);
  sprintf(ligne,"-> Max fraction volumique      : %lf",m_fraction_volumique_max); fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME fraction volumique : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_fraction_volumique_histogramme.get_nb_colonne(),
                                                                                                          m_fraction_volumique_histogramme.get_largeur_colonne(),
                                                                                                          m_fraction_volumique_histogramme.get_x_min(),
                                                                                                          m_fraction_volumique_histogramme.get_x_max());
  fonc(ligne);
  sprintf(ligne,"-> Moyenne volume forme    : %lf",m_volume_forme_moyenne); fonc(ligne);
  sprintf(ligne,"-> Ecart-type volume forme : %lf",m_volume_forme_ecart_type); fonc(ligne);
  sprintf(ligne,"-> Min volume forme        : %lf",m_volume_forme_min); fonc(ligne);
  sprintf(ligne,"-> Max volume forme        : %lf",m_volume_forme_max); fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME volume forme : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_volume_forme_histogramme.get_nb_colonne(),
                                                                                                                m_volume_forme_histogramme.get_largeur_colonne(),
                                                                                                                m_volume_forme_histogramme.get_x_min(),
                                                                                                                m_volume_forme_histogramme.get_x_max());
  fonc(ligne);
}


MSTRUCT_ANALYSE_MG_MAILLAGE::MSTRUCT_ANALYSE_MG_MAILLAGE(void): MSTRUCT_ANALYSE()
{
}

MSTRUCT_ANALYSE_MG_MAILLAGE::MSTRUCT_ANALYSE_MG_MAILLAGE(std::string identifiant,
                                                                 long int id_maillage,
                                                                 double largeur_colonne_nb_element_2D,
                                                                 double largeur_colonne_nb_element_3D,
                                                                 double largeur_colonne_qualite_2D,
                                                                 double largeur_colonne_taille_2D,
                                                                 double largeur_colonne_qualite_3D,
                                                                 double largeur_colonne_taille_3D,
                                                                 double largeur_colonne_volume,
                                                                 double largeur_colonne_fraction_volumique,
                                                                 std::string nom_groupe_forme): MSTRUCT_ANALYSE(identifiant,nom_groupe_forme)
{
  m_id_maillage=id_maillage;
  m_nb_element_2D_histogramme.fixe_largeur_colonne(largeur_colonne_nb_element_2D);
  m_nb_element_3D_histogramme.fixe_largeur_colonne(largeur_colonne_nb_element_3D);
  m_2D_qualite_histogramme.fixe_largeur_colonne(largeur_colonne_qualite_2D);
  m_3D_qualite_histogramme.fixe_largeur_colonne(largeur_colonne_qualite_3D);
  m_2D_taille_histogramme.fixe_largeur_colonne(largeur_colonne_taille_2D);
  m_3D_taille_histogramme.fixe_largeur_colonne(largeur_colonne_taille_3D);
  m_volume_histogramme.fixe_largeur_colonne(largeur_colonne_volume);
  m_fraction_volumique_histogramme.fixe_largeur_colonne(largeur_colonne_fraction_volumique);
}

MSTRUCT_ANALYSE_MG_MAILLAGE::MSTRUCT_ANALYSE_MG_MAILLAGE(std::vector< MSTRUCT_ANALYSE_MG_MAILLAGE* > &vector_analyse): MSTRUCT_ANALYSE()
{
  std::vector<MSTRUCT_ANALYSE_MG_MAILLAGE*>::iterator it_analyse=vector_analyse.begin();
  MSTRUCT_ANALYSE_MG_MAILLAGE* analyse = *it_analyse;
  m_identifiant=analyse->get_identifiant();
  if(analyse->get_boite_analyse()!=NULL) change_boite_analyse(*analyse->get_boite_analyse());
  m_nom_groupe_forme=analyse->get_nom_groupe_forme();
  m_nb_ves=vector_analyse.size();
  
  m_nb_element_2D_histogramme.fixe_largeur_colonne(analyse->get_distribution_nb_element_2D()->get_largeur_colonne());
  m_nb_element_3D_histogramme.fixe_largeur_colonne(analyse->get_distribution_nb_element_3D()->get_largeur_colonne());
  m_2D_qualite_histogramme.fixe_largeur_colonne(analyse->get_distribution_qualite_2D()->get_largeur_colonne());
  m_3D_qualite_histogramme.fixe_largeur_colonne(analyse->get_distribution_qualite_3D()->get_largeur_colonne());
  m_2D_taille_histogramme.fixe_largeur_colonne(analyse->get_distribution_taille_2D()->get_largeur_colonne());
  m_3D_taille_histogramme.fixe_largeur_colonne(analyse->get_distribution_taille_3D()->get_largeur_colonne());
  m_volume_histogramme.fixe_largeur_colonne(analyse->get_distribution_volume()->get_largeur_colonne());
  m_fraction_volumique_histogramme.fixe_largeur_colonne(analyse->get_distribution_fraction_volumique()->get_largeur_colonne());
  
  m_id_maillage=-1;
  
  m_nb_element_2D_moyenne=0;
  m_nb_element_2D_ecart_type=0;
  m_nb_element_2D_min=std::numeric_limits< long >::max();
  m_nb_element_2D_max=std::numeric_limits< long >::min();
  
  m_nb_element_3D_moyenne=0;
  m_nb_element_3D_ecart_type=0;
  m_nb_element_3D_min=std::numeric_limits< long >::max();
  m_nb_element_3D_max=std::numeric_limits< long >::min();
  
  m_2D_qualite_min=std::numeric_limits< double >::max();
  m_2D_qualite_max=std::numeric_limits< double >::min();
  m_2D_qualite_moyenne=0;
  m_2D_qualite_ecart_type=0;

  m_3D_qualite_min=std::numeric_limits< double >::max();
  m_3D_qualite_max=std::numeric_limits< double >::min();
  m_3D_qualite_moyenne=0;
  m_3D_qualite_ecart_type=0;

  m_2D_taille_min=std::numeric_limits< double >::max();
  m_2D_taille_max=std::numeric_limits< double >::min();
  m_2D_taille_moyenne=0;
  m_2D_taille_ecart_type=0;

  m_3D_taille_min=std::numeric_limits< double >::max();
  m_3D_taille_max=std::numeric_limits< double >::min();
  m_3D_taille_moyenne=0;
  m_3D_taille_ecart_type=0;

  m_volume_min=std::numeric_limits< double >::max();
  m_volume_max=std::numeric_limits< double >::min();
  m_volume_moyenne=0;
  m_volume_ecart_type=0;

  m_fraction_volumique_min=std::numeric_limits< double >::max();
  m_fraction_volumique_max=std::numeric_limits< double >::min();
  m_fraction_volumique_ecart_type=0;
  m_fraction_volumique_moyenne=0; 
  
  for(it_analyse=vector_analyse.begin();it_analyse!=vector_analyse.end();it_analyse++)
  {
    analyse = *it_analyse;
    
    m_nb_element_2D_moyenne+=analyse->get_nb_element_2D_moyenne();
    m_nb_element_2D_histogramme.ajouter_valeur((double)analyse->get_nb_element_2D_moyenne(),1.0/m_nb_ves);
    if(analyse->get_nb_element_2D_min()<m_nb_element_2D_min) m_nb_element_2D_min=analyse->get_nb_element_2D_min();
    if(analyse->get_nb_element_2D_max()>m_nb_element_2D_max) m_nb_element_2D_max=analyse->get_nb_element_2D_max();
    
    m_nb_element_3D_moyenne+=analyse->get_nb_element_3D_moyenne();
    m_nb_element_3D_histogramme.ajouter_valeur((double)analyse->get_nb_element_3D_moyenne(),1.0/m_nb_ves);
    if(analyse->get_nb_element_3D_min()<m_nb_element_3D_min) m_nb_element_3D_min=analyse->get_nb_element_3D_min();
    if(analyse->get_nb_element_3D_max()>m_nb_element_3D_max) m_nb_element_3D_max=analyse->get_nb_element_3D_max();
    
    m_2D_qualite_moyenne+=analyse->get_qualite_moyenne_2D();
    std::map<long,double>::iterator it_his;
    double val;
    long l;
    int k=analyse->get_distribution_qualite_2D()->get_premiere_valeur(it_his,val,l);
    while(k!=0)
    {
      m_2D_qualite_histogramme.ajouter_valeur(l,val/m_nb_ves);
      k=analyse->get_distribution_qualite_2D()->get_suivante_valeur(it_his,val,l);
    }
    if(analyse->get_qualite_min_2D()<m_2D_qualite_min) m_2D_qualite_min=analyse->get_qualite_min_2D();
    if(analyse->get_qualite_max_2D()>m_2D_qualite_max) m_2D_qualite_max=analyse->get_qualite_max_2D();
    
    m_3D_qualite_moyenne+=analyse->get_qualite_moyenne_3D();
    k=analyse->get_distribution_qualite_3D()->get_premiere_valeur(it_his,val,l);
    while(k!=0)
    {
      m_3D_qualite_histogramme.ajouter_valeur(l,val/m_nb_ves);
      k=analyse->get_distribution_qualite_3D()->get_suivante_valeur(it_his,val,l);
    }
    if(analyse->get_qualite_min_3D()<m_3D_qualite_min) m_3D_qualite_min=analyse->get_qualite_min_3D();
    if(analyse->get_qualite_max_3D()>m_3D_qualite_max) m_3D_qualite_max=analyse->get_qualite_max_3D();
    
    m_2D_taille_moyenne+=analyse->get_taille_moyenne_2D();
    k=analyse->get_distribution_taille_2D()->get_premiere_valeur(it_his,val,l);
    while(k!=0)
    {
      m_2D_taille_histogramme.ajouter_valeur(l,val/m_nb_ves);
      k=analyse->get_distribution_taille_2D()->get_suivante_valeur(it_his,val,l);
    }
    if(analyse->get_taille_min_2D()<m_2D_taille_min) m_2D_taille_min=analyse->get_taille_min_2D();
    if(analyse->get_taille_max_2D()>m_2D_taille_max) m_2D_taille_max=analyse->get_taille_max_2D();
    
    m_3D_taille_moyenne+=analyse->get_taille_moyenne_3D();
    k=analyse->get_distribution_taille_3D()->get_premiere_valeur(it_his,val,l);
    while(k!=0)
    {
      m_3D_taille_histogramme.ajouter_valeur(l,val/m_nb_ves);
      k=analyse->get_distribution_taille_3D()->get_suivante_valeur(it_his,val,l);
    }
    if(analyse->get_taille_min_3D()<m_3D_taille_min) m_3D_taille_min=analyse->get_taille_min_3D();
    if(analyse->get_taille_max_3D()>m_3D_taille_max) m_3D_taille_max=analyse->get_taille_max_3D();
    
    m_volume_moyenne+=analyse->get_volume_moyenne();
    m_volume_histogramme.ajouter_valeur(analyse->get_volume_moyenne(),1.0/m_nb_ves);
    if(analyse->get_volume_min()<m_volume_min) m_volume_min=analyse->get_volume_min();
    if(analyse->get_volume_max()>m_volume_max) m_volume_max=analyse->get_volume_max();
    
    m_fraction_volumique_moyenne+=analyse->get_fraction_volumique_moyenne();
    m_fraction_volumique_histogramme.ajouter_valeur(analyse->get_fraction_volumique_moyenne(),1.0/m_nb_ves);
    if(analyse->get_fraction_volumique_min()<m_fraction_volumique_min) m_fraction_volumique_min=analyse->get_fraction_volumique_min();
    if(analyse->get_fraction_volumique_max()>m_fraction_volumique_max) m_fraction_volumique_max=analyse->get_fraction_volumique_max();
  }
  m_nb_element_2D_moyenne=m_nb_element_2D_moyenne/m_nb_ves;
  m_nb_element_3D_moyenne=m_nb_element_2D_moyenne/m_nb_ves;
  m_2D_qualite_moyenne=m_2D_qualite_moyenne/m_nb_ves;
  m_3D_qualite_moyenne=m_3D_qualite_moyenne/m_nb_ves;
  m_2D_taille_moyenne=m_2D_taille_moyenne/m_nb_ves;
  m_3D_taille_moyenne=m_3D_taille_moyenne/m_nb_ves;
  m_volume_moyenne=m_volume_moyenne/m_nb_ves;
  m_fraction_volumique_moyenne=m_fraction_volumique_moyenne/m_nb_ves;
  if(m_nb_ves>1)
  {
    for(it_analyse=vector_analyse.begin();it_analyse!=vector_analyse.end();it_analyse++)
    {
      analyse = *it_analyse;
      m_nb_element_2D_ecart_type+=(analyse->get_nb_element_2D_moyenne()-m_nb_element_2D_moyenne)*(analyse->get_nb_element_2D_moyenne()-m_nb_element_2D_moyenne);
      m_nb_element_3D_ecart_type+=(analyse->get_nb_element_3D_moyenne()-m_nb_element_3D_moyenne)*(analyse->get_nb_element_3D_moyenne()-m_nb_element_3D_moyenne);
      m_2D_qualite_ecart_type+=(analyse->get_qualite_moyenne_2D()-m_2D_qualite_moyenne)*(analyse->get_qualite_moyenne_2D()-m_2D_qualite_moyenne);
      m_3D_qualite_ecart_type+=(analyse->get_qualite_moyenne_3D()-m_3D_qualite_moyenne)*(analyse->get_qualite_moyenne_3D()-m_3D_qualite_moyenne);
      m_2D_taille_ecart_type+=(analyse->get_taille_moyenne_2D()-m_2D_taille_moyenne)*(analyse->get_taille_moyenne_2D()-m_2D_taille_moyenne);
      m_3D_taille_ecart_type+=(analyse->get_taille_moyenne_3D()-m_2D_taille_moyenne)*(analyse->get_taille_moyenne_3D()-m_2D_taille_moyenne);
      m_volume_ecart_type+=(analyse->get_volume_ecart_type()-m_volume_moyenne)*(analyse->get_volume_ecart_type()-m_volume_moyenne);
      m_fraction_volumique_ecart_type+=(analyse->get_fraction_volumique_ecart_type()-m_fraction_volumique_moyenne)*(analyse->get_fraction_volumique_ecart_type()-m_fraction_volumique_moyenne);
    }
    m_nb_element_2D_ecart_type=sqrt(m_nb_element_2D_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_nb_element_3D_ecart_type=sqrt(m_nb_element_3D_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_2D_qualite_ecart_type=sqrt(m_2D_qualite_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_3D_qualite_ecart_type=sqrt(m_3D_qualite_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_2D_taille_ecart_type=sqrt(m_2D_taille_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_3D_taille_ecart_type=sqrt(m_3D_taille_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_volume_ecart_type=sqrt(m_volume_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_fraction_volumique_ecart_type=sqrt(m_fraction_volumique_ecart_type*(1.0/(m_nb_ves-1.0)));
  }  
}


MSTRUCT_ANALYSE_MG_MAILLAGE::MSTRUCT_ANALYSE_MG_MAILLAGE(MSTRUCT_ANALYSE_MG_MAILLAGE& mdd): MSTRUCT_ANALYSE(mdd)
{
  m_id_maillage=mdd.m_id_maillage;
  m_nb_element_2D_moyenne=mdd.m_nb_element_2D_moyenne;
  m_nb_element_2D_ecart_type=mdd.m_nb_element_2D_ecart_type;
  m_nb_element_2D_min=mdd.m_nb_element_2D_min;
  m_nb_element_2D_max=mdd.m_nb_element_2D_max;
  m_nb_element_2D_histogramme=mdd.m_nb_element_2D_histogramme;
  m_nb_element_3D_moyenne=mdd.m_nb_element_3D_moyenne;
  m_nb_element_3D_ecart_type=mdd.m_nb_element_3D_ecart_type;
  m_nb_element_3D_min=mdd.m_nb_element_3D_min;
  m_nb_element_3D_max=mdd.m_nb_element_3D_max;
  m_nb_element_3D_histogramme=mdd.m_nb_element_3D_histogramme;
  m_2D_qualite_min=mdd.m_2D_qualite_min;
  m_2D_qualite_max=mdd.m_2D_qualite_max;
  m_2D_qualite_moyenne=mdd.m_2D_qualite_moyenne;
  m_2D_qualite_ecart_type=mdd.m_2D_qualite_ecart_type;
  m_2D_qualite_histogramme=mdd.m_2D_qualite_histogramme;
  m_3D_qualite_min=mdd.m_3D_qualite_min;
  m_3D_qualite_max=mdd.m_3D_qualite_max;
  m_3D_qualite_moyenne=mdd.m_3D_qualite_moyenne;
  m_3D_qualite_ecart_type=mdd.m_3D_qualite_ecart_type;
  m_3D_qualite_histogramme=mdd.m_3D_qualite_histogramme;
  m_2D_taille_min=mdd.m_2D_taille_min;
  m_2D_taille_max=mdd.m_2D_taille_max;
  m_2D_taille_moyenne=mdd.m_2D_taille_moyenne;
  m_2D_taille_ecart_type=mdd.m_2D_taille_ecart_type;
  m_2D_taille_histogramme=mdd.m_2D_taille_histogramme;
  m_3D_taille_min=mdd.m_3D_taille_min;
  m_3D_taille_max=mdd.m_3D_taille_max;
  m_3D_taille_moyenne=mdd.m_3D_taille_moyenne;
  m_3D_taille_ecart_type=mdd.m_3D_taille_ecart_type;
  m_3D_taille_histogramme=mdd.m_3D_taille_histogramme;
  m_volume_min=mdd.m_volume_min;
  m_volume_max=mdd.m_volume_max;
  m_volume_moyenne=mdd.m_volume_moyenne;
  m_volume_ecart_type=mdd.m_volume_ecart_type;
  m_volume_histogramme=mdd.m_volume_histogramme;  
  m_fraction_volumique_min=mdd.m_fraction_volumique_min;
  m_fraction_volumique_max=mdd.m_fraction_volumique_max;
  m_fraction_volumique_ecart_type=mdd.m_fraction_volumique_ecart_type;
  m_fraction_volumique_moyenne=mdd.m_fraction_volumique_moyenne;
  m_fraction_volumique_histogramme=mdd.m_fraction_volumique_histogramme;
}

MSTRUCT_ANALYSE_MG_MAILLAGE::~MSTRUCT_ANALYSE_MG_MAILLAGE(void)
{

}

long int MSTRUCT_ANALYSE_MG_MAILLAGE::get_id_maillage(void)
{
  return m_id_maillage;
}

long int MSTRUCT_ANALYSE_MG_MAILLAGE::get_nb_element_2D_min(void)
{
  return m_nb_element_2D_min;
}

long int MSTRUCT_ANALYSE_MG_MAILLAGE::get_nb_element_2D_max(void)
{
  return m_nb_element_2D_max;
}

long int MSTRUCT_ANALYSE_MG_MAILLAGE::get_nb_element_2D_moyenne(void)
{
  return m_nb_element_2D_moyenne;
}

long int MSTRUCT_ANALYSE_MG_MAILLAGE::get_nb_element_2D_ecart_type(void)
{
  return m_nb_element_2D_ecart_type;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_MG_MAILLAGE::get_distribution_nb_element_2D(void)
{
  return &m_nb_element_2D_histogramme;
}

long int MSTRUCT_ANALYSE_MG_MAILLAGE::get_nb_element_3D_min(void)
{
  return m_nb_element_3D_min;
}

long int MSTRUCT_ANALYSE_MG_MAILLAGE::get_nb_element_3D_max(void)
{
  return m_nb_element_3D_max;
}

long int MSTRUCT_ANALYSE_MG_MAILLAGE::get_nb_element_3D_moyenne(void)
{
  return m_nb_element_3D_moyenne;
}

long int MSTRUCT_ANALYSE_MG_MAILLAGE::get_nb_element_3D_ecart_type(void)
{
  return m_nb_element_3D_ecart_type;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_MG_MAILLAGE::get_distribution_nb_element_3D(void)
{
  return &m_nb_element_3D_histogramme;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_qualite_moyenne_2D(void)
{
  return m_2D_qualite_moyenne;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_qualite_ecart_type_2D(void)
{
  return m_2D_qualite_ecart_type;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_qualite_min_2D(void)
{
  return m_2D_qualite_min;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_qualite_max_2D(void)
{
  return m_2D_qualite_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_MG_MAILLAGE::get_distribution_qualite_2D(void)
{
  return &m_2D_qualite_histogramme;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_qualite_moyenne_3D(void)
{
  return m_3D_qualite_moyenne;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_qualite_ecart_type_3D(void)
{
  return m_3D_qualite_ecart_type;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_qualite_min_3D(void)
{
  return m_3D_qualite_min;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_qualite_max_3D(void)
{
  return m_3D_qualite_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_MG_MAILLAGE::get_distribution_qualite_3D(void)
{
  return &m_3D_qualite_histogramme;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_taille_moyenne_2D(void)
{
  return m_2D_taille_moyenne;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_taille_ecart_type_2D(void)
{
  return m_2D_taille_ecart_type;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_taille_min_2D(void)
{
  return m_2D_taille_min;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_taille_max_2D(void)
{
  return m_2D_taille_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_MG_MAILLAGE::get_distribution_taille_2D(void)
{
  return &m_2D_taille_histogramme;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_taille_moyenne_3D(void)
{
  return m_3D_taille_moyenne;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_taille_ecart_type_3D(void)
{
  return m_3D_taille_ecart_type;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_taille_min_3D(void)
{
  return m_3D_taille_min;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_taille_max_3D(void)
{
  return m_3D_taille_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_MG_MAILLAGE::get_distribution_taille_3D(void)
{
  return &m_3D_taille_histogramme;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_volume_min(void)
{
  return m_volume_min;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_volume_max(void)
{
  return m_volume_max;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_volume_moyenne(void)
{
  return m_volume_moyenne;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_volume_ecart_type(void)
{
  return m_volume_ecart_type;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_MG_MAILLAGE::get_distribution_volume(void)
{
  return &m_volume_histogramme;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_fraction_volumique_min(void)
{
  return m_fraction_volumique_min;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_fraction_volumique_max(void)
{
  return m_fraction_volumique_max;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_fraction_volumique_moyenne(void)
{
  return m_fraction_volumique_moyenne;
}

double MSTRUCT_ANALYSE_MG_MAILLAGE::get_fraction_volumique_ecart_type(void)
{
  return m_fraction_volumique_ecart_type;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_MG_MAILLAGE::get_distribution_fraction_volumique(void)
{
  return & m_fraction_volumique_histogramme;
}

long int MSTRUCT_ANALYSE_MG_MAILLAGE::get_type(void)
{
  return TYPE_ANALYSE::MAILLAGE_MG;
}

void MSTRUCT_ANALYSE_MG_MAILLAGE::executer(MSTRUCT_VES* ves)
{
  MG_CG_GROUPE_FORME* groupe_forme=NULL;
  if(m_nom_groupe_forme!="ALL") groupe_forme=ves->get_mgcg_modele()->get_mgcg_groupe_forme(m_nom_groupe_forme);
  TPL_MAP_ENTITE<MG_CG_FORME*> tpl_map_forme;
  if(groupe_forme!=NULL)
  {
    std::map<long,MG_CG_FORME*>::iterator it_forme;
    for(MG_CG_FORME* forme=groupe_forme->get_premiere_mgcg_forme(it_forme);forme!=NULL;forme=groupe_forme->get_suivante_mgcg_forme(it_forme))
    {
      tpl_map_forme.ajouter(forme);
    }
  }
  else
  {
    std::map<long,MG_CG_FORME*>::iterator it_forme;
    MG_CG_ASSEMBLAGE* mgcg_ass=ves->get_mgcg_assemblage();
    for(MG_CG_FORME*forme=mgcg_ass->get_premiere_mgcg_forme(it_forme);forme!=NULL;forme=mgcg_ass->get_suivante_mgcg_forme(it_forme))
    {
      tpl_map_forme.ajouter(forme);
    }
  }
  MSTRUCT_OUTILS::statistiques_mg_maillage(ves->get_boite3d_ves(),
                                   ves->get_mg_maillage(),
                                   tpl_map_forme,
                                   m_nb_element_2D_moyenne,m_nb_element_3D_moyenne,
                                   m_2D_qualite_moyenne,m_2D_qualite_ecart_type,m_2D_qualite_min,m_2D_qualite_max,m_2D_qualite_histogramme,
                                   m_3D_qualite_moyenne,m_3D_qualite_ecart_type,m_3D_qualite_min,m_3D_qualite_min,m_3D_qualite_histogramme,
                                   m_2D_taille_moyenne,m_2D_taille_ecart_type,m_2D_taille_min,m_2D_taille_max,m_2D_taille_histogramme,
                                   m_3D_taille_moyenne,m_3D_taille_ecart_type,m_3D_taille_min,m_3D_taille_max,m_3D_taille_histogramme,
                                   m_volume_moyenne,
                                   m_fraction_volumique_moyenne);
  m_nb_element_2D_min=m_nb_element_2D_moyenne;
  m_nb_element_2D_max=m_nb_element_2D_moyenne;
  m_nb_element_2D_ecart_type=0.0;
  m_nb_element_3D_min=m_nb_element_3D_moyenne;
  m_nb_element_3D_max=m_nb_element_3D_moyenne;
  m_nb_element_3D_ecart_type=0.0;  
  m_volume_min=m_volume_moyenne;
  m_volume_max=m_volume_moyenne;
  m_volume_ecart_type=0.0;
  m_fraction_volumique_min=m_fraction_volumique_moyenne;
  m_fraction_volumique_max=m_fraction_volumique_moyenne;
  m_fraction_volumique_ecart_type=0.0;
}

void MSTRUCT_ANALYSE_MG_MAILLAGE::exporter(std::ofstream& ofstrm, long i, bool avec_entete, bool avec_histo, char* prefix_histo)
{
  if(avec_entete) ofstrm << "#(1) volume[moy(2) ±(3) min(4) max(5)] frac_vol[moy(6) ±(7) min(8) max(9)] nb_ele_2D[moy(10) ±(11) min(12) max(13)] nb_ele_3D[moy(14) ±(15) min(16) max(17)] 2D_qualite[moy(18) ±(19) min(20) max(21)] 3D_qualite[moy(22) ±(23) min(24) max(25)] 2D_taille[moy(26) ±(27) min(28) max(29)] 3D_taille[moy(30) ±(31) min(32) max(33)]" << std::endl; 
  ofstrm << i << " " 
         << m_volume_moyenne << " "
         << m_volume_ecart_type << " "
         << m_volume_min << " "
         << m_volume_max << " "
         << m_fraction_volumique_moyenne << " "
         << m_fraction_volumique_ecart_type << " "
         << m_fraction_volumique_min << " "
         << m_fraction_volumique_max << " "
         << m_nb_element_2D_moyenne << " "
         << m_nb_element_2D_ecart_type << " "
         << m_nb_element_2D_min << " "
         << m_nb_element_2D_max << " "
         << m_nb_element_3D_moyenne << " "
         << m_nb_element_3D_ecart_type << " "
         << m_nb_element_3D_min << " "
         << m_nb_element_3D_max << " "
         << m_2D_qualite_moyenne << " "
         << m_2D_qualite_ecart_type << " "
         << m_2D_qualite_min << " "
         << m_2D_qualite_max << " "
         << m_3D_qualite_moyenne << " "
         << m_3D_qualite_ecart_type << " "
         << m_3D_qualite_min << " "
         << m_3D_qualite_min << " "
         << m_2D_taille_moyenne << " "
         << m_2D_taille_ecart_type << " "
         << m_2D_taille_min << " "
         << m_2D_taille_max << " "
         << m_3D_taille_moyenne << " "
         << m_3D_taille_ecart_type << " "
         << m_3D_taille_min << " "
         << m_3D_taille_max << " "
         << std::endl;
  if(avec_histo)
  {
    char nom_fichier[500];
    sprintf(nom_fichier,"%s/histo_%s_qualite_2D.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_qual_2d(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_qual_2d.precision(16);
    of_histo_qual_2d.setf(std::ios::showpoint);
    m_2D_qualite_histogramme.exporter(of_histo_qual_2d);
    of_histo_qual_2d.close();
    
    sprintf(nom_fichier,"%s/histo_%s_qualite_3D.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_qual_3d(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_qual_3d.precision(16);
    of_histo_qual_3d.setf(std::ios::showpoint);
    m_3D_qualite_histogramme.exporter(of_histo_qual_3d);
    of_histo_qual_3d.close();
    
    sprintf(nom_fichier,"%s/histo_%s_taille_2D.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_taille_2d(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_taille_2d.precision(16);
    of_histo_taille_2d.setf(std::ios::showpoint);
    m_2D_taille_histogramme.exporter(of_histo_taille_2d);
    of_histo_taille_2d.close();
    
    sprintf(nom_fichier,"%s/histo_%s_taille_3D.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_taille_3d(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_taille_3d.precision(16);
    of_histo_taille_3d.setf(std::ios::showpoint);
    m_3D_taille_histogramme.exporter(of_histo_taille_3d);
    of_histo_taille_3d.close();
    
    sprintf(nom_fichier,"%s/histo_%s_volume.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_volume(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_volume.precision(16);
    of_histo_volume.setf(std::ios::showpoint);
    m_volume_histogramme.exporter(of_histo_volume);
    of_histo_volume.close();
    
    sprintf(nom_fichier,"%s/histo_%s_frac_vol.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_frac_vol(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_frac_vol.precision(16);
    of_histo_frac_vol.setf(std::ios::showpoint);
    m_fraction_volumique_histogramme.exporter(of_histo_frac_vol);
    of_histo_frac_vol.close();
    
    sprintf(nom_fichier,"%s/histo_%s_nb_ele_2D.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_nb_ele_2d(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_nb_ele_2d.precision(16);
    of_histo_nb_ele_2d.setf(std::ios::showpoint);
    m_nb_element_2D_histogramme.exporter(of_histo_nb_ele_2d);
    of_histo_nb_ele_2d.close();
    
    sprintf(nom_fichier,"%s/histo_%s_nb_ele_3D.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_nb_ele_3d(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_nb_ele_3d.precision(16);
    of_histo_nb_ele_3d.setf(std::ios::showpoint);
    m_nb_element_3D_histogramme.exporter(of_histo_nb_ele_3d);
    of_histo_nb_ele_3d.close();
  }
    
}

void MSTRUCT_ANALYSE_MG_MAILLAGE::enregistrer(std::ofstream& ofstrm)
{
  long type_analyse=get_type();
  ofstrm.write((char*)&type_analyse,sizeof(long));
  MSTRUCT_ANALYSE::enregistrer(ofstrm);
  ofstrm.write((char*)&m_id_maillage,sizeof(long));
  
  ofstrm.write((char*)&m_nb_element_2D_min,sizeof(long));
  ofstrm.write((char*)&m_nb_element_2D_max,sizeof(long));
  ofstrm.write((char*)&m_nb_element_2D_moyenne,sizeof(long));
  ofstrm.write((char*)&m_nb_element_2D_ecart_type,sizeof(long));
  m_nb_element_2D_histogramme.enregistrer_bin(ofstrm);
  
  ofstrm.write((char*)&m_nb_element_3D_min,sizeof(long));
  ofstrm.write((char*)&m_nb_element_3D_max,sizeof(long));
  ofstrm.write((char*)&m_nb_element_3D_moyenne,sizeof(long));
  ofstrm.write((char*)&m_nb_element_3D_ecart_type,sizeof(long));
  m_nb_element_3D_histogramme.enregistrer_bin(ofstrm);
  
  ofstrm.write((char*)&m_2D_qualite_min,sizeof(double));
  ofstrm.write((char*)&m_2D_qualite_max,sizeof(double));
  ofstrm.write((char*)&m_2D_qualite_moyenne,sizeof(double));
  ofstrm.write((char*)&m_2D_qualite_ecart_type,sizeof(double));
  m_2D_qualite_histogramme.enregistrer_bin(ofstrm);
  
  ofstrm.write((char*)&m_3D_qualite_min,sizeof(double));
  ofstrm.write((char*)&m_3D_qualite_max,sizeof(double));
  ofstrm.write((char*)&m_3D_qualite_moyenne,sizeof(double));
  ofstrm.write((char*)&m_3D_qualite_ecart_type,sizeof(double));
  m_3D_qualite_histogramme.enregistrer_bin(ofstrm);
  
  ofstrm.write((char*)&m_2D_taille_min,sizeof(double));
  ofstrm.write((char*)&m_2D_taille_max,sizeof(double));
  ofstrm.write((char*)&m_2D_taille_moyenne,sizeof(double));
  ofstrm.write((char*)&m_2D_taille_ecart_type,sizeof(double));
  m_2D_taille_histogramme.enregistrer_bin(ofstrm);
  
  ofstrm.write((char*)&m_3D_taille_min,sizeof(double));
  ofstrm.write((char*)&m_3D_taille_max,sizeof(double));
  ofstrm.write((char*)&m_3D_taille_moyenne,sizeof(double));
  ofstrm.write((char*)&m_3D_taille_ecart_type,sizeof(double));
  m_3D_taille_histogramme.enregistrer_bin(ofstrm);
  
  ofstrm.write((char*)&m_volume_moyenne,sizeof(double));
  ofstrm.write((char*)&m_volume_ecart_type,sizeof(double));
  ofstrm.write((char*)&m_volume_min,sizeof(double));
  ofstrm.write((char*)&m_volume_max,sizeof(double));
  m_volume_histogramme.enregistrer_bin(ofstrm);
  ofstrm.write((char*)&m_fraction_volumique_moyenne,sizeof(double));
  ofstrm.write((char*)&m_fraction_volumique_ecart_type,sizeof(double));
  ofstrm.write((char*)&m_fraction_volumique_min,sizeof(double));
  ofstrm.write((char*)&m_fraction_volumique_max,sizeof(double));
  m_fraction_volumique_histogramme.enregistrer_bin(ofstrm);
} 
    
void MSTRUCT_ANALYSE_MG_MAILLAGE::ouvrir(std::ifstream& ifstrm)
{
  MSTRUCT_ANALYSE::ouvrir(ifstrm);
  ifstrm.read((char*)&m_id_maillage,sizeof(long));
  
  ifstrm.read((char*)&m_nb_element_2D_min,sizeof(long));
  ifstrm.read((char*)&m_nb_element_2D_max,sizeof(long));
  ifstrm.read((char*)&m_nb_element_2D_moyenne,sizeof(long));
  ifstrm.read((char*)&m_nb_element_2D_ecart_type,sizeof(long));
  m_nb_element_2D_histogramme.ouvrir_bin(ifstrm);
  
  ifstrm.read((char*)&m_nb_element_3D_min,sizeof(long));
  ifstrm.read((char*)&m_nb_element_3D_max,sizeof(long));
  ifstrm.read((char*)&m_nb_element_3D_moyenne,sizeof(long));
  ifstrm.read((char*)&m_nb_element_3D_ecart_type,sizeof(long));
  m_nb_element_3D_histogramme.ouvrir_bin(ifstrm);
  
  ifstrm.read((char*)&m_2D_qualite_min,sizeof(double));
  ifstrm.read((char*)&m_2D_qualite_max,sizeof(double));
  ifstrm.read((char*)&m_2D_qualite_moyenne,sizeof(double));
  ifstrm.read((char*)&m_2D_qualite_ecart_type,sizeof(double));
  m_2D_qualite_histogramme.ouvrir_bin(ifstrm);
  
  ifstrm.read((char*)&m_3D_qualite_min,sizeof(double));
  ifstrm.read((char*)&m_3D_qualite_max,sizeof(double));
  ifstrm.read((char*)&m_3D_qualite_moyenne,sizeof(double));
  ifstrm.read((char*)&m_3D_qualite_ecart_type,sizeof(double));
  m_3D_qualite_histogramme.ouvrir_bin(ifstrm);
  
  ifstrm.read((char*)&m_2D_taille_min,sizeof(double));
  ifstrm.read((char*)&m_2D_taille_max,sizeof(double));
  ifstrm.read((char*)&m_2D_taille_moyenne,sizeof(double));
  ifstrm.read((char*)&m_2D_taille_ecart_type,sizeof(double));
  m_2D_taille_histogramme.ouvrir_bin(ifstrm);
  
  ifstrm.read((char*)&m_3D_taille_min,sizeof(double));
  ifstrm.read((char*)&m_3D_taille_max,sizeof(double));
  ifstrm.read((char*)&m_3D_taille_moyenne,sizeof(double));
  ifstrm.read((char*)&m_3D_taille_ecart_type,sizeof(double));
  m_3D_taille_histogramme.ouvrir_bin(ifstrm);
  
  ifstrm.read((char*)&m_volume_moyenne,sizeof(double));
  ifstrm.read((char*)&m_volume_ecart_type,sizeof(double));
  ifstrm.read((char*)&m_volume_min,sizeof(double));
  ifstrm.read((char*)&m_volume_max,sizeof(double));
  m_volume_histogramme.ouvrir_bin(ifstrm);
  ifstrm.read((char*)&m_fraction_volumique_moyenne,sizeof(double));
  ifstrm.read((char*)&m_fraction_volumique_ecart_type,sizeof(double));
  ifstrm.read((char*)&m_fraction_volumique_min,sizeof(double));
  ifstrm.read((char*)&m_fraction_volumique_max,sizeof(double));
  m_fraction_volumique_histogramme.ouvrir_bin(ifstrm);
}

void MSTRUCT_ANALYSE_MG_MAILLAGE::affiche_contenu(fonction_affiche* fonc)
{
  MSTRUCT_ANALYSE::affiche_contenu(fonc);
  char ligne[5000];
  sprintf(ligne,"MSTRUCT_ANALYSE_CAO");fonc(ligne);
  sprintf(ligne,"-> ID MG_MAILLAGE : %li",m_id_maillage);fonc(ligne);
  sprintf(ligne,"-> Moyenne nb element 2D    : %li",m_nb_element_2D_moyenne);fonc(ligne);
  sprintf(ligne,"-> Ecart-type nb element 2D : %li",m_nb_element_2D_ecart_type);fonc(ligne);
  sprintf(ligne,"-> Min nb element 2D        : %li",m_nb_element_2D_min);fonc(ligne);
  sprintf(ligne,"-> Max nb element 2D        : %li",m_nb_element_2D_max);fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME nb element 2D : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_nb_element_2D_histogramme.get_nb_colonne(),
                                                                                                              m_nb_element_2D_histogramme.get_largeur_colonne(),
                                                                                                              m_nb_element_2D_histogramme.get_x_min(),
                                                                                                              m_nb_element_2D_histogramme.get_x_max());
  fonc(ligne);
  sprintf(ligne,"-> Moyenne nb element 3D    : %li",m_nb_element_3D_moyenne);fonc(ligne);
  sprintf(ligne,"-> Ecart-type nb element 3D : %li",m_nb_element_3D_ecart_type);fonc(ligne);
  sprintf(ligne,"-> Min nb element 3D        : %li",m_nb_element_3D_min);fonc(ligne);
  sprintf(ligne,"-> Max nb element 3D        : %li",m_nb_element_3D_max);fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME nb element 3D : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_nb_element_3D_histogramme.get_nb_colonne(),
                                                                                                              m_nb_element_3D_histogramme.get_largeur_colonne(),
                                                                                                              m_nb_element_3D_histogramme.get_x_min(),
                                                                                                              m_nb_element_3D_histogramme.get_x_max());
  fonc(ligne);
  sprintf(ligne,"-> Qualite moyenne 2D    : %lf",m_2D_qualite_moyenne);fonc(ligne);
  sprintf(ligne,"-> Qualite ecart_type 2D : %lf",m_2D_qualite_ecart_type);fonc(ligne);
  sprintf(ligne,"-> Qualite min 2D        : %lf",m_2D_qualite_min);fonc(ligne);
  sprintf(ligne,"-> Qualite max 2D        : %lf",m_2D_qualite_max);fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME Qualite 2D : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_2D_qualite_histogramme.get_nb_colonne(),
                                                                                                              m_2D_qualite_histogramme.get_largeur_colonne(),
                                                                                                              m_2D_qualite_histogramme.get_x_min(),
                                                                                                              m_2D_qualite_histogramme.get_x_max());
  fonc(ligne);
  sprintf(ligne,"-> Qualite moyenne 3D    : %lf",m_3D_qualite_moyenne);fonc(ligne);
  sprintf(ligne,"-> Qualite ecart_type 3D : %lf",m_3D_qualite_ecart_type);fonc(ligne);
  sprintf(ligne,"-> Qualite min 3D        : %lf",m_3D_qualite_min);fonc(ligne);
  sprintf(ligne,"-> Qualite max 3D        : %lf",m_3D_qualite_max);fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME Qualite 3D : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_3D_qualite_histogramme.get_nb_colonne(),
                                                                                                              m_3D_qualite_histogramme.get_largeur_colonne(),
                                                                                                              m_3D_qualite_histogramme.get_x_min(),
                                                                                                              m_3D_qualite_histogramme.get_x_max());
  fonc(ligne);
  sprintf(ligne,"-> Taille moyenne 2D    : %lf",m_2D_taille_moyenne);fonc(ligne);
  sprintf(ligne,"-> Taille ecart_type 2D : %lf",m_2D_taille_ecart_type);fonc(ligne);
  sprintf(ligne,"-> Taille min 2D        : %lf",m_2D_taille_min);fonc(ligne);
  sprintf(ligne,"-> Taille max 2D        : %lf",m_2D_taille_max);fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME Taille 2D : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_2D_taille_histogramme.get_nb_colonne(),
                                                                                                             m_2D_taille_histogramme.get_largeur_colonne(),
                                                                                                             m_2D_taille_histogramme.get_x_min(),
                                                                                                             m_2D_taille_histogramme.get_x_max());
  fonc(ligne);
  sprintf(ligne,"-> Taille moyenne 3D    : %lf",m_3D_taille_moyenne);fonc(ligne);
  sprintf(ligne,"-> Taille ecart_type 3D : %lf",m_3D_taille_ecart_type);fonc(ligne);
  sprintf(ligne,"-> Taille min 3D        : %lf",m_3D_taille_min);fonc(ligne);
  sprintf(ligne,"-> Taille max 3D        : %lf",m_3D_taille_max);fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME Taille 3D : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_3D_taille_histogramme.get_nb_colonne(),
                                                                                                             m_3D_taille_histogramme.get_largeur_colonne(),
                                                                                                             m_3D_taille_histogramme.get_x_min(),
                                                                                                             m_3D_taille_histogramme.get_x_max());
  fonc(ligne);
  sprintf(ligne,"-> Moyenne volume      : %lf",m_volume_moyenne); fonc(ligne);
  sprintf(ligne,"-> Ecart-type volume   : %lf",m_volume_ecart_type); fonc(ligne);
  sprintf(ligne,"-> Min volume          : %lf",m_volume_min); fonc(ligne);
  sprintf(ligne,"-> Max volume          : %lf",m_volume_max); fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME volume : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_volume_histogramme.get_nb_colonne(),
                                                                                                          m_volume_histogramme.get_largeur_colonne(),
                                                                                                          m_volume_histogramme.get_x_min(),
                                                                                                          m_volume_histogramme.get_x_max());
  fonc(ligne);
  sprintf(ligne,"-> Moyenne fraction volumique      : %lf",m_fraction_volumique_moyenne); fonc(ligne);
  sprintf(ligne,"-> Ecart-type fraction volumique      : %lf",m_fraction_volumique_ecart_type); fonc(ligne);
  sprintf(ligne,"-> Min fraction volumique      : %lf",m_fraction_volumique_min); fonc(ligne);
  sprintf(ligne,"-> Max fraction volumique      : %lf",m_fraction_volumique_max); fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME fraction volumique : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_fraction_volumique_histogramme.get_nb_colonne(),
                                                                                                          m_fraction_volumique_histogramme.get_largeur_colonne(),
                                                                                                          m_fraction_volumique_histogramme.get_x_min(),
                                                                                                          m_fraction_volumique_histogramme.get_x_max());
  fonc(ligne);
}


MSTRUCT_ANALYSE_FEM_MAILLAGE::MSTRUCT_ANALYSE_FEM_MAILLAGE(void): MSTRUCT_ANALYSE()
{

}

MSTRUCT_ANALYSE_FEM_MAILLAGE::MSTRUCT_ANALYSE_FEM_MAILLAGE(std::string identifiant,
                                                                   long int id_fem_maillage,
                                                                   double largeur_colonne_nb_element_2D,
                                                                   double largeur_colonne_nb_element_3D,
                                                                   double largeur_colonne_jacobien_2D_min,
                                                                   double largeur_colonne_jacobien_2D_max,
                                                                   double largeur_colonne_distortion_2D,
                                                                   double largeur_colonne_jacobien_3D_min,
                                                                   double largeur_colonne_jacobien_3D_max,
                                                                   double largeur_colonne_distortion_3D,
                                                                   double largeur_colonne_volume,
                                                                   double largeur_colonne_fraction_volumique,
                                                                   std::string nom_groupe_forme,
                                                                   BOITE_3D* boite_3d): MSTRUCT_ANALYSE(identifiant, nom_groupe_forme, boite_3d)
{
  m_nb_element_2D_histogramme.fixe_largeur_colonne(largeur_colonne_nb_element_2D);
  m_nb_element_3D_histogramme.fixe_largeur_colonne(largeur_colonne_nb_element_3D);
  m_2D_jacobien_histogramme_min.fixe_largeur_colonne(largeur_colonne_jacobien_2D_min);
  m_2D_jacobien_histogramme_max.fixe_largeur_colonne(largeur_colonne_jacobien_2D_max);
  m_3D_jacobien_histogramme_min.fixe_largeur_colonne(largeur_colonne_jacobien_3D_min);
  m_3D_jacobien_histogramme_max.fixe_largeur_colonne(largeur_colonne_jacobien_3D_max);
  m_2D_distortion_histogramme.fixe_largeur_colonne(largeur_colonne_distortion_2D);
  m_3D_distortion_histogramme.fixe_largeur_colonne(largeur_colonne_distortion_3D);
  m_volume_histogramme.fixe_largeur_colonne(largeur_colonne_volume);
  m_fraction_volumique_histogramme.fixe_largeur_colonne(largeur_colonne_fraction_volumique);
}

MSTRUCT_ANALYSE_FEM_MAILLAGE::MSTRUCT_ANALYSE_FEM_MAILLAGE(std::vector< MSTRUCT_ANALYSE_FEM_MAILLAGE* >& vector_analyse): MSTRUCT_ANALYSE()
{
  std::vector<MSTRUCT_ANALYSE_FEM_MAILLAGE*>::iterator it_analyse=vector_analyse.begin();
  MSTRUCT_ANALYSE_FEM_MAILLAGE* analyse = *it_analyse;
  m_identifiant=analyse->get_identifiant();
  if(analyse->get_boite_analyse()!=NULL) change_boite_analyse(*analyse->get_boite_analyse());
  m_nom_groupe_forme=analyse->get_nom_groupe_forme();
  m_nb_ves=vector_analyse.size();
  
  m_nb_element_2D_histogramme.fixe_largeur_colonne(analyse->get_distribution_nb_element_2D()->get_largeur_colonne());
  m_nb_element_3D_histogramme.fixe_largeur_colonne(analyse->get_distribution_nb_element_3D()->get_largeur_colonne());
  m_2D_jacobien_histogramme_min.fixe_largeur_colonne(analyse->get_distribution_jacobien_min_2D()->get_largeur_colonne());
  m_2D_jacobien_histogramme_max.fixe_largeur_colonne(analyse->get_distribution_jacobien_max_2D()->get_largeur_colonne());
  m_3D_jacobien_histogramme_min.fixe_largeur_colonne(analyse->get_distribution_jacobien_min_3D()->get_largeur_colonne());
  m_3D_jacobien_histogramme_max.fixe_largeur_colonne(analyse->get_distribution_jacobien_max_3D()->get_largeur_colonne());
  m_2D_distortion_histogramme.fixe_largeur_colonne(analyse->get_distribution_distortion_2D()->get_largeur_colonne());
  m_3D_distortion_histogramme.fixe_largeur_colonne(analyse->get_distribution_distortion_3D()->get_largeur_colonne());
  m_volume_histogramme.fixe_largeur_colonne(analyse->get_distribution_volume()->get_largeur_colonne());
  m_fraction_volumique_histogramme.fixe_largeur_colonne(analyse->get_distribution_fraction_volumique()->get_largeur_colonne());
  
  m_id_fem_maillage=-1;
  
  m_nb_element_2D_moyenne=0.0;
  m_nb_element_2D_ecart_type=0.0;
  m_nb_element_2D_min=std::numeric_limits< long >::max();
  m_nb_element_2D_max=std::numeric_limits< long >::min();

  m_nb_element_3D_moyenne=0.0;
  m_nb_element_3D_ecart_type=0.0;
  m_nb_element_3D_min=std::numeric_limits< long >::max();
  m_nb_element_3D_max=std::numeric_limits< long >::min();
  
  m_2D_jacobien_min_min=std::numeric_limits< double >::max();
  m_2D_jacobien_min_max=std::numeric_limits< double >::min();
  m_2D_jacobien_min_moyenne=0.0;
  m_2D_jacobien_min_ecart_type=0.0;
  
  m_2D_jacobien_max_min=std::numeric_limits< double >::max();
  m_2D_jacobien_max_max=std::numeric_limits< double >::min();
  m_2D_jacobien_max_moyenne=0.0;
  m_2D_jacobien_max_ecart_type=0.0;
  
  m_3D_jacobien_min_min=std::numeric_limits< double >::max();
  m_3D_jacobien_min_max=std::numeric_limits< double >::min();
  m_3D_jacobien_min_moyenne=0.0;
  m_3D_jacobien_min_ecart_type=0.0;  
  
  m_3D_jacobien_max_min=std::numeric_limits< double >::max();
  m_3D_jacobien_max_max=std::numeric_limits< double >::min();
  m_3D_jacobien_max_moyenne=0.0;
  m_3D_jacobien_max_ecart_type=0.0;
  
  m_2D_distortion_min=std::numeric_limits< double >::max();
  m_2D_distortion_max=std::numeric_limits< double >::min();
  m_2D_distortion_moyenne=0.0;
  m_2D_distortion_ecart_type=0.0;

  m_3D_distortion_min=std::numeric_limits< double >::max();
  m_3D_distortion_max=std::numeric_limits< double >::min();
  m_3D_distortion_moyenne=0.0;
  m_3D_distortion_ecart_type=0.0;
  
  m_volume_min=std::numeric_limits< double >::max();
  m_volume_max=std::numeric_limits< double >::min();
  m_volume_moyenne=0.0;
  m_volume_ecart_type=0.0;

  m_fraction_volumique_min=std::numeric_limits< double >::max();
  m_fraction_volumique_max=std::numeric_limits< double >::min();
  m_fraction_volumique_ecart_type=0.0;
  m_fraction_volumique_moyenne=0.0;


  for(it_analyse=vector_analyse.begin();it_analyse!=vector_analyse.end();it_analyse++)
  {
    analyse = *it_analyse;
    
    m_nb_element_2D_moyenne+=analyse->get_nb_element_2D_moyenne();
    m_nb_element_2D_histogramme.ajouter_valeur((double)analyse->get_nb_element_2D_moyenne(),1./m_nb_ves);
    if(analyse->get_nb_element_2D_min()<m_nb_element_2D_min) m_nb_element_2D_min=analyse->get_nb_element_2D_min();
    if(analyse->get_nb_element_2D_max()>m_nb_element_2D_max) m_nb_element_2D_max=analyse->get_nb_element_2D_max();
    
    m_nb_element_3D_moyenne+=analyse->get_nb_element_3D_moyenne();
    m_nb_element_3D_histogramme.ajouter_valeur((double)analyse->get_nb_element_3D_moyenne(),1./m_nb_ves);
    if(analyse->get_nb_element_3D_min()<m_nb_element_3D_min) m_nb_element_3D_min=analyse->get_nb_element_3D_min();
    if(analyse->get_nb_element_3D_max()>m_nb_element_3D_max) m_nb_element_3D_max=analyse->get_nb_element_3D_max();
    
    m_2D_jacobien_min_moyenne+=analyse->get_jacobien_min_moyenne_2D();
    std::map<long,double>::iterator it_his;
    double val;
    long l;
    int k=analyse->get_distribution_jacobien_min_2D()->get_premiere_valeur(it_his,val,l);
    while(k!=0)
    {
      m_2D_jacobien_histogramme_min.ajouter_valeur(l,val/m_nb_ves);
      k=analyse->get_distribution_jacobien_min_2D()->get_suivante_valeur(it_his,val,l);
    }
    if(analyse->get_jacobien_min_min_2D()<m_2D_jacobien_min_min) m_2D_jacobien_min_min=analyse->get_jacobien_min_min_2D();
    if(analyse->get_jacobien_min_max_2D()>m_2D_jacobien_min_max) m_2D_jacobien_min_max=analyse->get_jacobien_min_max_2D();    
    
    m_2D_jacobien_max_moyenne+=analyse->get_jacobien_max_moyenne_2D();
    k=analyse->get_distribution_jacobien_max_2D()->get_premiere_valeur(it_his,val,l);
    while(k!=0)
    {
      m_2D_jacobien_histogramme_max.ajouter_valeur(l,val/m_nb_ves);
      k=analyse->get_distribution_jacobien_max_2D()->get_suivante_valeur(it_his,val,l);
    }
    if(analyse->get_jacobien_max_min_2D()<m_2D_jacobien_max_min) m_2D_jacobien_max_min=analyse->get_jacobien_max_min_2D();
    if(analyse->get_jacobien_max_max_2D()>m_2D_jacobien_max_max) m_2D_jacobien_max_max=analyse->get_jacobien_max_max_2D();    
    
    m_3D_jacobien_min_moyenne+=analyse->get_jacobien_min_moyenne_3D();
    k=analyse->get_distribution_jacobien_min_3D()->get_premiere_valeur(it_his,val,l);
    while(k!=0)
    {
      m_3D_jacobien_histogramme_min.ajouter_valeur(l,val/m_nb_ves);
      k=analyse->get_distribution_jacobien_min_3D()->get_suivante_valeur(it_his,val,l);
    }
    if(analyse->get_jacobien_min_min_3D()<m_3D_jacobien_min_min) m_3D_jacobien_min_min=analyse->get_jacobien_min_min_3D();
    if(analyse->get_jacobien_min_max_3D()>m_3D_jacobien_min_max) m_3D_jacobien_min_max=analyse->get_jacobien_min_max_3D();
    
    m_3D_jacobien_max_moyenne+=analyse->get_jacobien_max_moyenne_3D();
    k=analyse->get_distribution_jacobien_max_3D()->get_premiere_valeur(it_his,val,l);
    while(k!=0)
    {
      m_3D_jacobien_histogramme_max.ajouter_valeur(l,val/m_nb_ves);
      k=analyse->get_distribution_jacobien_max_3D()->get_suivante_valeur(it_his,val,l);
    }
    if(analyse->get_jacobien_max_min_3D()<m_3D_jacobien_max_min) m_3D_jacobien_max_min=analyse->get_jacobien_max_min_3D();
    if(analyse->get_jacobien_max_max_3D()>m_3D_jacobien_max_max) m_3D_jacobien_max_max=analyse->get_jacobien_max_max_3D();    
    
    m_2D_distortion_moyenne+=analyse->get_distortion_moyenne_2D();
    k=analyse->get_distribution_distortion_2D()->get_premiere_valeur(it_his,val,l);
    while(k!=0)
    {
      m_2D_distortion_histogramme.ajouter_valeur(l,val/m_nb_ves);
      k=analyse->get_distribution_distortion_2D()->get_suivante_valeur(it_his,val,l);
    }
    if(analyse->get_distortion_min_2D()<m_2D_distortion_min) m_2D_distortion_min=analyse->get_distortion_min_2D();
    if(analyse->get_distortion_max_2D()>m_2D_distortion_max) m_2D_distortion_max=analyse->get_distortion_max_2D();
    
    m_3D_distortion_moyenne+=analyse->get_distortion_moyenne_3D();
    k=analyse->get_distribution_distortion_3D()->get_premiere_valeur(it_his,val,l);
    while(k!=0)
    {
      m_3D_distortion_histogramme.ajouter_valeur(l,val/m_nb_ves);
      k=analyse->get_distribution_distortion_3D()->get_suivante_valeur(it_his,val,l);
    }
    if(analyse->get_distortion_min_3D()<m_3D_distortion_min) m_3D_distortion_min=analyse->get_distortion_min_3D();
    if(analyse->get_distortion_max_3D()>m_3D_distortion_max) m_3D_distortion_max=analyse->get_distortion_max_3D();
    
    m_volume_moyenne+=analyse->get_volume_moyenne();
    m_volume_histogramme.ajouter_valeur(analyse->get_volume_moyenne(),1.0/m_nb_ves);
    if(analyse->get_volume_min()<m_volume_min) m_volume_min=analyse->get_volume_min();
    if(analyse->get_volume_max()>m_volume_max) m_volume_max=analyse->get_volume_max();
    
    m_fraction_volumique_moyenne+=analyse->get_fraction_volumique_moyenne();
    m_fraction_volumique_histogramme.ajouter_valeur(analyse->get_fraction_volumique_moyenne(),1.0/m_nb_ves);
    if(analyse->get_fraction_volumique_min()<m_fraction_volumique_min) m_fraction_volumique_min=analyse->get_fraction_volumique_min();
    if(analyse->get_fraction_volumique_max()>m_fraction_volumique_max) m_fraction_volumique_max=analyse->get_fraction_volumique_max();
  }
  m_nb_element_2D_moyenne=m_nb_element_2D_moyenne/m_nb_ves;
  m_nb_element_3D_moyenne=m_nb_element_3D_moyenne/m_nb_ves;
  m_2D_jacobien_min_moyenne=m_2D_jacobien_min_moyenne/m_nb_ves;
  m_2D_jacobien_max_moyenne=m_2D_jacobien_max_moyenne/m_nb_ves;
  m_3D_jacobien_min_moyenne=m_3D_jacobien_min_moyenne/m_nb_ves;
  m_3D_jacobien_max_moyenne=m_3D_jacobien_max_moyenne/m_nb_ves;
  m_2D_distortion_moyenne=m_2D_distortion_moyenne/m_nb_ves;
  m_3D_distortion_moyenne=m_3D_distortion_moyenne/m_nb_ves;
  m_volume_moyenne=m_volume_moyenne/m_nb_ves;
  m_fraction_volumique_moyenne=m_fraction_volumique_moyenne/m_nb_ves;  
  if(m_nb_ves>1)
  {
    for(it_analyse=vector_analyse.begin();it_analyse!=vector_analyse.end();it_analyse++)
    {
      analyse = *it_analyse;
      m_nb_element_2D_ecart_type+=(analyse->get_nb_element_2D_moyenne()-m_nb_element_2D_moyenne)*(analyse->get_nb_element_2D_moyenne()-m_nb_element_2D_moyenne);
      m_nb_element_3D_ecart_type+=(analyse->get_nb_element_3D_moyenne()-m_nb_element_3D_moyenne)*(analyse->get_nb_element_3D_moyenne()-m_nb_element_3D_moyenne);
      m_2D_jacobien_min_ecart_type+=(analyse->get_jacobien_min_moyenne_2D()-m_2D_jacobien_min_moyenne)*(analyse->get_jacobien_min_moyenne_2D()-m_2D_jacobien_min_moyenne);
      m_2D_jacobien_max_ecart_type+=(analyse->get_jacobien_max_moyenne_2D()-m_2D_jacobien_max_moyenne)*(analyse->get_jacobien_max_moyenne_2D()-m_2D_jacobien_max_moyenne);
      m_3D_jacobien_min_ecart_type+=(analyse->get_jacobien_min_moyenne_3D()-m_3D_jacobien_min_moyenne)*(analyse->get_jacobien_min_moyenne_3D()-m_3D_jacobien_min_moyenne);
      m_3D_jacobien_max_ecart_type+=(analyse->get_jacobien_max_moyenne_3D()-m_3D_jacobien_max_moyenne)*(analyse->get_jacobien_max_moyenne_3D()-m_3D_jacobien_max_moyenne);
      m_2D_distortion_ecart_type+=(analyse->get_distortion_moyenne_2D()-m_2D_distortion_moyenne)*(analyse->get_distortion_moyenne_2D()-m_2D_distortion_moyenne);
      m_3D_distortion_ecart_type+=(analyse->get_distortion_moyenne_3D()-m_3D_distortion_moyenne)*(analyse->get_distortion_moyenne_3D()-m_3D_distortion_moyenne);   
      m_volume_ecart_type+=(analyse->get_volume_moyenne()-m_volume_moyenne)*(analyse->get_volume_moyenne()-m_volume_moyenne);
      m_fraction_volumique_ecart_type+=(analyse->get_fraction_volumique_moyenne()-m_fraction_volumique_moyenne)*(analyse->get_fraction_volumique_moyenne()-m_fraction_volumique_moyenne);
    }
    m_nb_element_2D_ecart_type=sqrt(m_nb_element_2D_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_nb_element_3D_ecart_type=sqrt(m_nb_element_3D_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_2D_jacobien_min_ecart_type=sqrt(m_2D_jacobien_min_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_2D_jacobien_max_ecart_type=sqrt(m_2D_jacobien_max_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_3D_jacobien_min_ecart_type=sqrt(m_3D_jacobien_min_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_3D_jacobien_max_ecart_type=sqrt(m_3D_jacobien_max_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_2D_distortion_ecart_type=sqrt(m_2D_distortion_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_3D_distortion_ecart_type=sqrt(m_3D_distortion_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_volume_ecart_type=sqrt(m_volume_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_fraction_volumique_ecart_type=sqrt(m_fraction_volumique_ecart_type*(1.0/(m_nb_ves-1.0)));
  }  
}


MSTRUCT_ANALYSE_FEM_MAILLAGE::MSTRUCT_ANALYSE_FEM_MAILLAGE(MSTRUCT_ANALYSE_FEM_MAILLAGE& mdd): MSTRUCT_ANALYSE(mdd)
{
  m_id_fem_maillage=mdd.m_id_fem_maillage;
  m_nb_element_2D_moyenne=mdd.m_nb_element_2D_moyenne;
  m_nb_element_2D_ecart_type=mdd.m_nb_element_2D_ecart_type;
  m_nb_element_2D_min=mdd.m_nb_element_2D_min;
  m_nb_element_2D_max=mdd.m_nb_element_2D_max;
  m_nb_element_2D_histogramme=mdd.m_nb_element_2D_histogramme;
  m_nb_element_3D_moyenne=mdd.m_nb_element_3D_moyenne;
  m_nb_element_3D_ecart_type=mdd.m_nb_element_3D_ecart_type;
  m_nb_element_3D_min=mdd.m_nb_element_3D_min;
  m_nb_element_3D_max=mdd.m_nb_element_3D_max;
  m_nb_element_3D_histogramme=mdd.m_nb_element_3D_histogramme;
  
  m_2D_jacobien_min_min=mdd.m_2D_jacobien_min_min;
  m_2D_jacobien_min_max=mdd.m_2D_jacobien_min_max;
  m_2D_jacobien_min_moyenne=mdd.m_2D_jacobien_min_moyenne;
  m_2D_jacobien_min_ecart_type=mdd.m_2D_jacobien_min_ecart_type;
  m_2D_jacobien_histogramme_min=mdd.m_2D_jacobien_histogramme_min;
  
  m_2D_jacobien_max_min=mdd.m_2D_jacobien_max_min;
  m_2D_jacobien_max_max=mdd.m_2D_jacobien_max_max;
  m_2D_jacobien_max_moyenne=mdd.m_2D_jacobien_max_moyenne;
  m_2D_jacobien_max_ecart_type=mdd.m_2D_jacobien_max_ecart_type;
  m_2D_jacobien_histogramme_max=mdd.m_2D_jacobien_histogramme_max; 
  
  m_3D_jacobien_min_min=mdd.m_3D_jacobien_min_min;
  m_3D_jacobien_min_max=mdd.m_3D_jacobien_min_max;
  m_3D_jacobien_min_moyenne=mdd.m_3D_jacobien_min_moyenne;
  m_3D_jacobien_min_ecart_type=mdd.m_3D_jacobien_min_ecart_type;
  m_3D_jacobien_histogramme_min=mdd.m_3D_jacobien_histogramme_min;
  
  m_3D_jacobien_max_min=mdd.m_3D_jacobien_max_min;
  m_3D_jacobien_max_max=mdd.m_3D_jacobien_max_max;
  m_3D_jacobien_max_moyenne=mdd.m_3D_jacobien_max_moyenne;
  m_3D_jacobien_max_ecart_type=mdd.m_3D_jacobien_max_ecart_type;
  m_3D_jacobien_histogramme_max=mdd.m_3D_jacobien_histogramme_max;
  
  m_2D_distortion_min=mdd.m_2D_distortion_min;
  m_2D_distortion_max=mdd.m_2D_distortion_max;
  m_2D_distortion_moyenne=mdd.m_2D_distortion_moyenne;
  m_2D_distortion_ecart_type=mdd.m_2D_distortion_ecart_type;
  m_2D_distortion_histogramme=mdd.m_2D_distortion_histogramme;
  m_3D_distortion_min=mdd.m_3D_distortion_min;
  m_3D_distortion_max=mdd.m_3D_distortion_max;
  m_3D_distortion_moyenne=mdd.m_3D_distortion_moyenne;
  m_3D_distortion_ecart_type=mdd.m_3D_distortion_ecart_type;
  m_3D_distortion_histogramme=mdd.m_3D_distortion_histogramme;
 
  m_volume_min=mdd.m_volume_min;
  m_volume_max=mdd.m_volume_max;
  m_volume_moyenne=mdd.m_volume_moyenne;
  m_volume_ecart_type=mdd.m_volume_ecart_type;
  m_volume_histogramme=mdd.m_volume_histogramme;  
  m_fraction_volumique_min=mdd.m_fraction_volumique_min;
  m_fraction_volumique_max=mdd.m_fraction_volumique_max;
  m_fraction_volumique_ecart_type=mdd.m_fraction_volumique_ecart_type;
  m_fraction_volumique_moyenne=mdd.m_fraction_volumique_moyenne;
  m_fraction_volumique_histogramme=mdd.m_fraction_volumique_histogramme;
}

MSTRUCT_ANALYSE_FEM_MAILLAGE::~MSTRUCT_ANALYSE_FEM_MAILLAGE(void)
{

}

long int MSTRUCT_ANALYSE_FEM_MAILLAGE::get_id_fem_maillage(void)
{
  return m_id_fem_maillage;
}

long int MSTRUCT_ANALYSE_FEM_MAILLAGE::get_nb_element_2D_min(void)
{
  return m_nb_element_2D_min;
}

long int MSTRUCT_ANALYSE_FEM_MAILLAGE::get_nb_element_2D_max(void)
{
  return m_nb_element_2D_max;
}

long int MSTRUCT_ANALYSE_FEM_MAILLAGE::get_nb_element_2D_moyenne(void)
{
  return m_nb_element_2D_moyenne;
}

long int MSTRUCT_ANALYSE_FEM_MAILLAGE::get_nb_element_2D_ecart_type(void)
{
  return m_nb_element_2D_ecart_type;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distribution_nb_element_2D(void)
{
  return &m_nb_element_2D_histogramme;
}

long int MSTRUCT_ANALYSE_FEM_MAILLAGE::get_nb_element_3D_min(void)
{
  return m_nb_element_3D_min;
}

long int MSTRUCT_ANALYSE_FEM_MAILLAGE::get_nb_element_3D_max(void)
{
  return m_nb_element_3D_max;
}

long int MSTRUCT_ANALYSE_FEM_MAILLAGE::get_nb_element_3D_moyenne(void)
{
  return m_nb_element_3D_moyenne;
}

long int MSTRUCT_ANALYSE_FEM_MAILLAGE::get_nb_element_3D_ecart_type(void)
{
  return m_nb_element_3D_ecart_type;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distribution_nb_element_3D(void)
{
  return &m_nb_element_3D_histogramme;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_min_moyenne_2D(void)
{
  return m_2D_jacobien_min_moyenne;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_min_ecart_type_2D(void)
{
  return m_2D_jacobien_min_ecart_type;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_min_min_2D(void)
{
  return m_2D_jacobien_min_min;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_min_max_2D(void)
{
  return m_2D_jacobien_min_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distribution_jacobien_min_2D(void)
{
  return &m_2D_jacobien_histogramme_min;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_max_moyenne_2D(void)
{
  return m_2D_jacobien_max_moyenne;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_max_ecart_type_2D(void)
{
  return m_2D_jacobien_max_ecart_type;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_max_min_2D(void)
{
  return m_2D_jacobien_max_min;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_max_max_2D(void)
{
  return m_2D_jacobien_max_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distribution_jacobien_max_2D(void)
{
  return &m_2D_jacobien_histogramme_max;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_min_moyenne_3D(void)
{
  return m_3D_jacobien_min_moyenne;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_min_ecart_type_3D(void)
{
  return m_3D_jacobien_min_ecart_type;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_min_min_3D(void)
{
  return m_3D_jacobien_min_min;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_min_max_3D(void)
{
  return m_3D_jacobien_min_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distribution_jacobien_min_3D(void)
{
  return &m_3D_jacobien_histogramme_min;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_max_moyenne_3D(void)
{
  return m_3D_jacobien_max_moyenne;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_max_ecart_type_3D(void)
{
  return m_3D_jacobien_max_ecart_type;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_max_min_3D(void)
{
  return m_3D_jacobien_max_min;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_jacobien_max_max_3D(void)
{
  return m_3D_jacobien_max_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distribution_jacobien_max_3D(void)
{
  return &m_3D_jacobien_histogramme_max;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distortion_moyenne_2D(void)
{
  return m_2D_distortion_moyenne;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distortion_ecart_type_2D(void)
{
  return m_2D_distortion_ecart_type;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distortion_min_2D(void)
{
  return m_2D_distortion_min;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distortion_max_2D(void)
{
  return m_2D_distortion_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distribution_distortion_2D(void)
{
  return &m_2D_distortion_histogramme;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distortion_moyenne_3D(void)
{
  return m_3D_distortion_moyenne;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distortion_ecart_type_3D(void)
{
  return m_3D_distortion_ecart_type;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distortion_min_3D(void)
{
  return m_3D_distortion_min;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distortion_max_3D(void)
{
  return m_3D_distortion_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distribution_distortion_3D(void)
{
  return &m_3D_distortion_histogramme;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_volume_min(void)
{
  return m_volume_min;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_volume_max(void)
{
  return m_volume_max;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_volume_moyenne(void)
{
  return m_volume_moyenne;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_volume_ecart_type(void)
{
  return m_volume_ecart_type;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distribution_volume(void)
{
  return &m_volume_histogramme;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_fraction_volumique_min(void)
{
  return m_fraction_volumique_min;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_fraction_volumique_max(void)
{
  return m_fraction_volumique_max;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_fraction_volumique_moyenne(void)
{
  return m_fraction_volumique_moyenne;
}

double MSTRUCT_ANALYSE_FEM_MAILLAGE::get_fraction_volumique_ecart_type(void)
{
  return m_fraction_volumique_ecart_type;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_FEM_MAILLAGE::get_distribution_fraction_volumique(void)
{
  return &m_fraction_volumique_histogramme;
}

long int MSTRUCT_ANALYSE_FEM_MAILLAGE::get_type(void)
{
  return TYPE_ANALYSE::MAILLAGE_FEM;
}

void MSTRUCT_ANALYSE_FEM_MAILLAGE::executer(MSTRUCT_VES* ves)
{
  FEM_MAILLAGE* fem=ves->get_fem_maillage();
  MG_CG_GROUPE_FORME* groupe_forme=NULL;
  if(m_nom_groupe_forme!="ALL") groupe_forme=ves->get_mgcg_modele()->get_mgcg_groupe_forme(m_nom_groupe_forme);
  TPL_MAP_ENTITE<MG_CG_FORME*> tpl_map_forme;
  if(groupe_forme!=NULL)
  {
    std::map<long,MG_CG_FORME*>::iterator it_forme;
    for(MG_CG_FORME* forme=groupe_forme->get_premiere_mgcg_forme(it_forme);forme!=NULL;forme=groupe_forme->get_suivante_mgcg_forme(it_forme))
    {
      tpl_map_forme.ajouter(forme);
    }
  }
  else
  {
    std::map<long,MG_CG_FORME*>::iterator it_forme;
    MG_CG_ASSEMBLAGE* mgcg_ass=ves->get_mgcg_assemblage();
    for(MG_CG_FORME*forme=mgcg_ass->get_premiere_mgcg_forme(it_forme);forme!=NULL;forme=mgcg_ass->get_suivante_mgcg_forme(it_forme))
    {
      tpl_map_forme.ajouter(forme);
    }
  }
  MSTRUCT_OUTILS::statistiques_fem_maillage(fem,
                                    m_boite_analyse,
                                    tpl_map_forme,
                                    m_nb_element_2D_moyenne,m_nb_element_3D_moyenne,
                                    m_2D_jacobien_min_moyenne, m_2D_jacobien_min_ecart_type, m_2D_jacobien_min_min, m_2D_jacobien_min_max,m_2D_jacobien_histogramme_min,
                                    m_2D_jacobien_max_moyenne, m_2D_jacobien_max_ecart_type, m_2D_jacobien_max_min, m_2D_jacobien_max_max,m_2D_jacobien_histogramme_max,
                                    m_3D_jacobien_min_moyenne, m_3D_jacobien_min_ecart_type, m_3D_jacobien_min_min, m_3D_jacobien_min_max,m_3D_jacobien_histogramme_min,
                                    m_3D_jacobien_max_moyenne, m_3D_jacobien_max_ecart_type, m_3D_jacobien_max_min, m_3D_jacobien_max_max,m_3D_jacobien_histogramme_max,
                                    m_2D_distortion_moyenne,m_2D_distortion_ecart_type,m_2D_distortion_min,m_2D_distortion_max,m_2D_distortion_histogramme,
                                    m_3D_distortion_moyenne,m_3D_distortion_ecart_type,m_3D_distortion_min,m_3D_distortion_max,m_3D_distortion_histogramme,
                                    m_volume_moyenne,
                                    m_fraction_volumique_moyenne);
  m_nb_element_2D_min=m_nb_element_2D_moyenne;
  m_nb_element_2D_max=m_nb_element_2D_moyenne;
  m_nb_element_2D_ecart_type=0.0;
  m_nb_element_3D_min=m_nb_element_3D_moyenne;
  m_nb_element_3D_max=m_nb_element_3D_moyenne;
  m_nb_element_3D_ecart_type=0.0;  
  m_volume_min=m_volume_moyenne;
  m_volume_max=m_volume_moyenne;
  m_volume_ecart_type=0.0;
  m_fraction_volumique_min=m_fraction_volumique_moyenne;
  m_fraction_volumique_max=m_fraction_volumique_moyenne;
  m_fraction_volumique_ecart_type=0.0;
}

void MSTRUCT_ANALYSE_FEM_MAILLAGE::exporter(std::ofstream& ofstrm, long i, bool avec_entete, bool avec_histo, char* prefix_histo)
{
  if(avec_entete) ofstrm << "#(1) volume[moy(2) ±(3) min(4) max(5)] frac_vol[moy(6) ±(7) min(8) max(9)] nb_ele_2D[moy(10) ±(11) min(12) max(13)] nb_ele_3D[moy(14) ±(15) min(16) max(17)] jacobien_min_2D[moy(18) ±(19) min(20) max(21)] jacobien_max_2D[moy(22) ±(23) min(24) max(25)] jacobien_min_3D[moy(26) ±(27) min(28) max(29)] jacobien_max_3D[moy(30) ±(31) min(32) max(33)] distortion_2D[moy(34) ±(35) min(36) max(37)] distortion_3D[moy(38) ±(39) min(40) max(41)]" << std::endl; 
  ofstrm << i << " "
         << m_volume_moyenne << " " 
         << m_volume_ecart_type << " " 
         << m_volume_max << " " 
         << m_volume_max << " " 
         << m_fraction_volumique_moyenne << " "
         << m_fraction_volumique_ecart_type << " "
         << m_fraction_volumique_min << " "
         << m_fraction_volumique_max << " "
         << m_nb_element_2D_moyenne << " "
         << m_nb_element_2D_ecart_type << " "
         << m_nb_element_2D_min << " "
         << m_nb_element_2D_max << " "
         << m_nb_element_3D_moyenne << " "
         << m_nb_element_3D_ecart_type << " "
         << m_nb_element_3D_min << " "
         << m_nb_element_3D_max << " "
         << m_2D_jacobien_min_moyenne << " "
         << m_2D_jacobien_min_ecart_type << " "
         << m_2D_jacobien_min_min << " "
         << m_2D_jacobien_min_max << " "
         << m_2D_jacobien_max_moyenne << " "
         << m_2D_jacobien_max_ecart_type << " "
         << m_2D_jacobien_max_min << " "
         << m_2D_jacobien_max_max << " "
         << m_3D_jacobien_min_moyenne << " "
         << m_3D_jacobien_min_ecart_type << " "
         << m_3D_jacobien_min_min << " "
         << m_3D_jacobien_min_max << " "
         << m_3D_jacobien_max_moyenne << " "
         << m_3D_jacobien_max_ecart_type << " "
         << m_3D_jacobien_max_min << " "
         << m_3D_jacobien_max_max << " "
         << m_2D_distortion_moyenne << " "
         << m_2D_distortion_ecart_type << " "
         << m_2D_distortion_min << " "
         << m_2D_distortion_max << " "
         << m_3D_distortion_moyenne << " "
         << m_3D_distortion_ecart_type << " "
         << m_3D_distortion_min << " "
         << m_3D_distortion_max << std::endl;
  if(avec_histo)
  {
    char nom_fichier[500];
    sprintf(nom_fichier,"%s/histo_%s_jacobien_min_2D.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_javcobien_min_2d(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_javcobien_min_2d.precision(16);
    of_histo_javcobien_min_2d.setf(std::ios::showpoint);
    m_2D_jacobien_histogramme_min.exporter(of_histo_javcobien_min_2d);
    of_histo_javcobien_min_2d.close();
    
    sprintf(nom_fichier,"%s/histo_%s_jacobien_max_2D.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_javcobien_max_2d(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_javcobien_max_2d.precision(16);
    of_histo_javcobien_max_2d.setf(std::ios::showpoint);
    m_2D_jacobien_histogramme_max.exporter(of_histo_javcobien_max_2d);
    of_histo_javcobien_max_2d.close();
    
    sprintf(nom_fichier,"%s/histo_%s_jacobien_min_3D.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_javcobien_min_3d(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_javcobien_min_3d.precision(16);
    of_histo_javcobien_min_3d.setf(std::ios::showpoint);
    m_3D_jacobien_histogramme_min.exporter(of_histo_javcobien_min_3d);
    of_histo_javcobien_min_3d.close();
    
    sprintf(nom_fichier,"%s/histo_%s_jacobien_max_3D.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_javcobien_max_3d(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_javcobien_max_3d.precision(16);
    of_histo_javcobien_max_3d.setf(std::ios::showpoint);
    m_3D_jacobien_histogramme_max.exporter(of_histo_javcobien_max_3d);
    of_histo_javcobien_max_3d.close();
    
    sprintf(nom_fichier,"%s/histo_%s_distortion_2D.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_distortion_2D(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_distortion_2D.precision(16);
    of_histo_distortion_2D.setf(std::ios::showpoint);
    m_2D_distortion_histogramme.exporter(of_histo_distortion_2D);
    of_histo_distortion_2D.close();
    
    sprintf(nom_fichier,"%s/histo_%s_distortion_3D.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_distortion_3D(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_distortion_3D.precision(16);
    of_histo_distortion_3D.setf(std::ios::showpoint);
    m_3D_distortion_histogramme.exporter(of_histo_distortion_3D);
    of_histo_distortion_3D.close(); 
    
    sprintf(nom_fichier,"%s/histo_%s_volume.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_volume(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_volume.precision(16);
    of_histo_volume.setf(std::ios::showpoint);
    m_volume_histogramme.exporter(of_histo_volume);
    of_histo_volume.close();
    
    sprintf(nom_fichier,"%s/histo_%s_frac_vol.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_frac_vol(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_frac_vol.precision(16);
    of_histo_frac_vol.setf(std::ios::showpoint);
    m_fraction_volumique_histogramme.exporter(of_histo_frac_vol);
    of_histo_frac_vol.close();
    
    sprintf(nom_fichier,"%s/histo_%s_nb_ele_2D.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_nb_ele_2d(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_nb_ele_2d.precision(16);
    of_histo_nb_ele_2d.setf(std::ios::showpoint);
    m_nb_element_2D_histogramme.exporter(of_histo_nb_ele_2d);
    of_histo_nb_ele_2d.close();
    
    sprintf(nom_fichier,"%s/histo_%s_nb_ele_3D.txt",prefix_histo,m_identifiant.c_str());
    std::ofstream of_histo_nb_ele_3d(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_nb_ele_3d.precision(16);
    of_histo_nb_ele_3d.setf(std::ios::showpoint);
    m_nb_element_3D_histogramme.exporter(of_histo_nb_ele_3d);
    of_histo_nb_ele_3d.close();
  }
}

void MSTRUCT_ANALYSE_FEM_MAILLAGE::enregistrer(std::ofstream& ofstrm)
{
  long type_analyse=get_type();
  ofstrm.write((char*)&type_analyse,sizeof(long));
  MSTRUCT_ANALYSE::enregistrer(ofstrm);
  ofstrm.write((char*)&m_id_fem_maillage,sizeof(long));
  
  ofstrm.write((char*)&m_nb_element_2D_min,sizeof(long));
  ofstrm.write((char*)&m_nb_element_2D_max,sizeof(long));
  ofstrm.write((char*)&m_nb_element_2D_moyenne,sizeof(long));
  ofstrm.write((char*)&m_nb_element_2D_ecart_type,sizeof(long));
  m_nb_element_2D_histogramme.enregistrer_bin(ofstrm);
  
  ofstrm.write((char*)&m_nb_element_3D_min,sizeof(long));
  ofstrm.write((char*)&m_nb_element_3D_max,sizeof(long));
  ofstrm.write((char*)&m_nb_element_3D_moyenne,sizeof(long));
  ofstrm.write((char*)&m_nb_element_3D_ecart_type,sizeof(long));
  m_nb_element_3D_histogramme.enregistrer_bin(ofstrm);
  
  ofstrm.write((char*)&m_2D_jacobien_min_min,sizeof(double));
  ofstrm.write((char*)&m_2D_jacobien_min_max,sizeof(double));
  ofstrm.write((char*)&m_2D_jacobien_min_moyenne,sizeof(double));
  ofstrm.write((char*)&m_2D_jacobien_min_ecart_type,sizeof(double));
  m_2D_jacobien_histogramme_min.enregistrer_bin(ofstrm);
  
  ofstrm.write((char*)&m_2D_jacobien_max_min,sizeof(double));
  ofstrm.write((char*)&m_2D_jacobien_max_max,sizeof(double));
  ofstrm.write((char*)&m_2D_jacobien_max_moyenne,sizeof(double));
  ofstrm.write((char*)&m_2D_jacobien_max_ecart_type,sizeof(double));
  m_2D_jacobien_histogramme_max.enregistrer_bin(ofstrm);
  
  ofstrm.write((char*)&m_3D_jacobien_min_min,sizeof(double));
  ofstrm.write((char*)&m_3D_jacobien_min_max,sizeof(double));
  ofstrm.write((char*)&m_3D_jacobien_min_moyenne,sizeof(double));
  ofstrm.write((char*)&m_3D_jacobien_min_ecart_type,sizeof(double));
  m_3D_jacobien_histogramme_min.enregistrer_bin(ofstrm);
  
  ofstrm.write((char*)&m_3D_jacobien_max_min,sizeof(double));
  ofstrm.write((char*)&m_3D_jacobien_max_max,sizeof(double));
  ofstrm.write((char*)&m_3D_jacobien_max_moyenne,sizeof(double));
  ofstrm.write((char*)&m_3D_jacobien_max_ecart_type,sizeof(double));
  m_3D_jacobien_histogramme_max.enregistrer_bin(ofstrm);
  
  ofstrm.write((char*)&m_2D_distortion_min,sizeof(double));
  ofstrm.write((char*)&m_2D_distortion_max,sizeof(double));
  ofstrm.write((char*)&m_2D_distortion_moyenne,sizeof(double));
  ofstrm.write((char*)&m_2D_distortion_ecart_type,sizeof(double));
  m_2D_distortion_histogramme.enregistrer_bin(ofstrm);
  
  ofstrm.write((char*)&m_3D_distortion_min,sizeof(double));
  ofstrm.write((char*)&m_3D_distortion_max,sizeof(double));
  ofstrm.write((char*)&m_3D_distortion_moyenne,sizeof(double));
  ofstrm.write((char*)&m_3D_distortion_ecart_type,sizeof(double));
  m_3D_distortion_histogramme.enregistrer_bin(ofstrm);
  
  ofstrm.write((char*)&m_volume_moyenne,sizeof(double));
  ofstrm.write((char*)&m_volume_ecart_type,sizeof(double));
  ofstrm.write((char*)&m_volume_min,sizeof(double));
  ofstrm.write((char*)&m_volume_max,sizeof(double));
  m_volume_histogramme.enregistrer_bin(ofstrm);
  ofstrm.write((char*)&m_fraction_volumique_moyenne,sizeof(double));
  ofstrm.write((char*)&m_fraction_volumique_ecart_type,sizeof(double));
  ofstrm.write((char*)&m_fraction_volumique_min,sizeof(double));
  ofstrm.write((char*)&m_fraction_volumique_max,sizeof(double));
  m_fraction_volumique_histogramme.enregistrer_bin(ofstrm);
}

void MSTRUCT_ANALYSE_FEM_MAILLAGE::ouvrir(std::ifstream& ifstrm)
{
  MSTRUCT_ANALYSE::ouvrir(ifstrm);
  ifstrm.read((char*)&m_id_fem_maillage,sizeof(long));
  
  ifstrm.read((char*)&m_nb_element_2D_min,sizeof(long));
  ifstrm.read((char*)&m_nb_element_2D_max,sizeof(long));
  ifstrm.read((char*)&m_nb_element_2D_moyenne,sizeof(long));
  ifstrm.read((char*)&m_nb_element_2D_ecart_type,sizeof(long));
  m_nb_element_2D_histogramme.ouvrir_bin(ifstrm);
  
  ifstrm.read((char*)&m_nb_element_3D_min,sizeof(long));
  ifstrm.read((char*)&m_nb_element_3D_max,sizeof(long));
  ifstrm.read((char*)&m_nb_element_3D_moyenne,sizeof(long));
  ifstrm.read((char*)&m_nb_element_3D_ecart_type,sizeof(long));
  m_nb_element_3D_histogramme.ouvrir_bin(ifstrm);
  
  ifstrm.read((char*)&m_2D_jacobien_min_min,sizeof(double));
  ifstrm.read((char*)&m_2D_jacobien_min_max,sizeof(double));
  ifstrm.read((char*)&m_2D_jacobien_min_moyenne,sizeof(double));
  ifstrm.read((char*)&m_2D_jacobien_min_ecart_type,sizeof(double));
  m_2D_jacobien_histogramme_min.ouvrir_bin(ifstrm);
  
  ifstrm.read((char*)&m_2D_jacobien_max_min,sizeof(double));
  ifstrm.read((char*)&m_2D_jacobien_max_max,sizeof(double));
  ifstrm.read((char*)&m_2D_jacobien_max_moyenne,sizeof(double));
  ifstrm.read((char*)&m_2D_jacobien_max_ecart_type,sizeof(double));
  m_2D_jacobien_histogramme_max.ouvrir_bin(ifstrm);
  
  ifstrm.read((char*)&m_3D_jacobien_min_min,sizeof(double));
  ifstrm.read((char*)&m_3D_jacobien_min_max,sizeof(double));
  ifstrm.read((char*)&m_3D_jacobien_min_moyenne,sizeof(double));
  ifstrm.read((char*)&m_3D_jacobien_min_ecart_type,sizeof(double));
  m_3D_jacobien_histogramme_min.ouvrir_bin(ifstrm);
  
  ifstrm.read((char*)&m_3D_jacobien_max_min,sizeof(double));
  ifstrm.read((char*)&m_3D_jacobien_max_max,sizeof(double));
  ifstrm.read((char*)&m_3D_jacobien_max_moyenne,sizeof(double));
  ifstrm.read((char*)&m_3D_jacobien_max_ecart_type,sizeof(double));
  m_3D_jacobien_histogramme_max.ouvrir_bin(ifstrm);
  
  ifstrm.read((char*)&m_2D_distortion_min,sizeof(double));
  ifstrm.read((char*)&m_2D_distortion_max,sizeof(double));
  ifstrm.read((char*)&m_2D_distortion_moyenne,sizeof(double));
  ifstrm.read((char*)&m_2D_distortion_ecart_type,sizeof(double));
  m_2D_distortion_histogramme.ouvrir_bin(ifstrm);
  
  ifstrm.read((char*)&m_3D_distortion_min,sizeof(double));
  ifstrm.read((char*)&m_3D_distortion_max,sizeof(double));
  ifstrm.read((char*)&m_3D_distortion_moyenne,sizeof(double));
  ifstrm.read((char*)&m_3D_distortion_ecart_type,sizeof(double));
  m_3D_distortion_histogramme.ouvrir_bin(ifstrm);
  
  ifstrm.read((char*)&m_volume_moyenne,sizeof(double));
  ifstrm.read((char*)&m_volume_ecart_type,sizeof(double));
  ifstrm.read((char*)&m_volume_min,sizeof(double));
  ifstrm.read((char*)&m_volume_max,sizeof(double));
  m_volume_histogramme.ouvrir_bin(ifstrm);
  ifstrm.read((char*)&m_fraction_volumique_moyenne,sizeof(double));
  ifstrm.read((char*)&m_fraction_volumique_ecart_type,sizeof(double));
  ifstrm.read((char*)&m_fraction_volumique_min,sizeof(double));
  ifstrm.read((char*)&m_fraction_volumique_max,sizeof(double));
  m_fraction_volumique_histogramme.ouvrir_bin(ifstrm);
}

void MSTRUCT_ANALYSE_FEM_MAILLAGE::affiche_contenu(fonction_affiche* fonc)
{
  MSTRUCT_ANALYSE::affiche_contenu(fonc);
  char ligne[5000];
  sprintf(ligne,"MSTRUCT_ANALYSE_CAO");fonc(ligne);
  sprintf(ligne,"-> ID MG_MAILLAGE : %li",m_id_fem_maillage);fonc(ligne);
  
  sprintf(ligne,"-> Moyenne nb element 2D    : %li",m_nb_element_2D_moyenne);fonc(ligne);
  sprintf(ligne,"-> Ecart-type nb element 2D : %li",m_nb_element_2D_ecart_type);fonc(ligne);
  sprintf(ligne,"-> Min nb element 2D        : %li",m_nb_element_2D_min);fonc(ligne);
  sprintf(ligne,"-> Max nb element 2D        : %li",m_nb_element_2D_max);fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME nb element 2D : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_nb_element_2D_histogramme.get_nb_colonne(),
                                                                                                              m_nb_element_2D_histogramme.get_largeur_colonne(),
                                                                                                              m_nb_element_2D_histogramme.get_x_min(),
                                                                                                              m_nb_element_2D_histogramme.get_x_max());
  fonc(ligne);
  sprintf(ligne,"-> Moyenne nb element 3D    : %li",m_nb_element_3D_moyenne);fonc(ligne);
  sprintf(ligne,"-> Ecart-type nb element 3D : %li",m_nb_element_3D_ecart_type);fonc(ligne);
  sprintf(ligne,"-> Min nb element 3D        : %li",m_nb_element_3D_min);fonc(ligne);
  sprintf(ligne,"-> Max nb element 3D        : %li",m_nb_element_3D_max);fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME nb element 3D : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_nb_element_3D_histogramme.get_nb_colonne(),
                                                                                                              m_nb_element_3D_histogramme.get_largeur_colonne(),
                                                                                                              m_nb_element_3D_histogramme.get_x_min(),
                                                                                                              m_nb_element_3D_histogramme.get_x_max());
  fonc(ligne);
  
  sprintf(ligne,"-> 2D Jacobien Min moyenne :    %lf",m_2D_jacobien_min_moyenne);fonc(ligne);
  sprintf(ligne,"-> 2D Jacobien Min ecart-type : %lf",m_2D_jacobien_min_ecart_type);fonc(ligne);
  sprintf(ligne,"-> 2D Jacobien Min min :        %lf",m_2D_jacobien_min_min);fonc(ligne);
  sprintf(ligne,"-> 2D Jacobien Min max :        %lf",m_2D_jacobien_min_max);fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME 2D Jacobien Min : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_2D_jacobien_histogramme_min.get_nb_colonne(),
                                                                                                                    m_2D_jacobien_histogramme_min.get_largeur_colonne(),
                                                                                                                    m_2D_jacobien_histogramme_min.get_x_min(),
                                                                                                                    m_2D_jacobien_histogramme_min.get_x_max());
  fonc(ligne);
  
  sprintf(ligne,"-> 2D Jacobien Max moyenne :    %lf",m_2D_jacobien_max_moyenne);fonc(ligne);
  sprintf(ligne,"-> 2D Jacobien Max ecart-type : %lf",m_2D_jacobien_max_ecart_type);fonc(ligne);
  sprintf(ligne,"-> 2D Jacobien Max min :        %lf",m_2D_jacobien_max_min);fonc(ligne);
  sprintf(ligne,"-> 2D Jacobien Max max :        %lf",m_2D_jacobien_max_max);fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME 2D Jacobien Min : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_2D_jacobien_histogramme_max.get_nb_colonne(),
                                                                                                                    m_2D_jacobien_histogramme_max.get_largeur_colonne(),
                                                                                                                    m_2D_jacobien_histogramme_max.get_x_min(),
                                                                                                                    m_2D_jacobien_histogramme_max.get_x_max());
  fonc(ligne);
  
  sprintf(ligne,"-> 3D Jacobien Min moyenne :    %lf",m_3D_jacobien_min_moyenne);fonc(ligne);
  sprintf(ligne,"-> 3D Jacobien Min ecart-type : %lf",m_3D_jacobien_min_ecart_type);fonc(ligne);
  sprintf(ligne,"-> 3D Jacobien Min min :        %lf",m_3D_jacobien_min_min);fonc(ligne);
  sprintf(ligne,"-> 3D Jacobien Min max :        %lf",m_3D_jacobien_min_max);fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME 3D Jacobien Min : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_3D_jacobien_histogramme_min.get_nb_colonne(),
                                                                                                                    m_3D_jacobien_histogramme_min.get_largeur_colonne(),
                                                                                                                    m_3D_jacobien_histogramme_min.get_x_min(),
                                                                                                                    m_3D_jacobien_histogramme_min.get_x_max());
  fonc(ligne);
  
  sprintf(ligne,"-> 3D Jacobien Max moyenne :    %lf",m_3D_jacobien_max_moyenne);fonc(ligne);
  sprintf(ligne,"-> 3D Jacobien Max ecart-type : %lf",m_3D_jacobien_max_ecart_type);fonc(ligne);
  sprintf(ligne,"-> 3D Jacobien Max min :        %lf",m_3D_jacobien_max_min);fonc(ligne);
  sprintf(ligne,"-> 3D Jacobien Max max :        %lf",m_3D_jacobien_max_max);fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME 3D Jacobien Min : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_3D_jacobien_histogramme_max.get_nb_colonne(),
                                                                                                                    m_3D_jacobien_histogramme_max.get_largeur_colonne(),
                                                                                                                    m_3D_jacobien_histogramme_max.get_x_min(),
                                                                                                                    m_3D_jacobien_histogramme_max.get_x_max());
  fonc(ligne);
  
  sprintf(ligne,"-> 2D Distortion moyenne :     %lf",m_2D_distortion_moyenne);fonc(ligne);
  sprintf(ligne,"-> 2D Distortion ecart-type :  %lf",m_2D_distortion_ecart_type);fonc(ligne);
  sprintf(ligne,"-> 2D Distortion min :         %lf",m_2D_distortion_min);fonc(ligne);
  sprintf(ligne,"-> 2D Distortion max :         %lf",m_2D_distortion_max);fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME 2D Jacobien Min : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_2D_distortion_histogramme.get_nb_colonne(),
                                                                                                                    m_2D_distortion_histogramme.get_largeur_colonne(),
                                                                                                                    m_2D_distortion_histogramme.get_x_min(),
                                                                                                                    m_2D_distortion_histogramme.get_x_max());
  fonc(ligne);
  
  sprintf(ligne,"-> 3D Distortion moyenne :     %lf",m_3D_distortion_moyenne);fonc(ligne);
  sprintf(ligne,"-> 3D Distortion ecart-type :  %lf",m_3D_distortion_ecart_type);fonc(ligne);
  sprintf(ligne,"-> 3D Distortion min :         %lf",m_3D_distortion_min);fonc(ligne);
  sprintf(ligne,"-> 3D Distortion max :         %lf",m_3D_distortion_max);fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME 3D Jacobien Min : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_3D_distortion_histogramme.get_nb_colonne(),
                                                                                                                    m_3D_distortion_histogramme.get_largeur_colonne(),
                                                                                                                    m_3D_distortion_histogramme.get_x_min(),
                                                                                                                    m_3D_distortion_histogramme.get_x_max());
  fonc(ligne);
  sprintf(ligne,"-> Moyenne volume      : %lf",m_volume_moyenne); fonc(ligne);
  sprintf(ligne,"-> Ecart-type volume   : %lf",m_volume_ecart_type); fonc(ligne);
  sprintf(ligne,"-> Min volume          : %lf",m_volume_min); fonc(ligne);
  sprintf(ligne,"-> Max volume          : %lf",m_volume_max); fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME volume : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_volume_histogramme.get_nb_colonne(),
                                                                                                          m_volume_histogramme.get_largeur_colonne(),
                                                                                                          m_volume_histogramme.get_x_min(),
                                                                                                          m_volume_histogramme.get_x_max());
  fonc(ligne);
  sprintf(ligne,"-> Moyenne fraction volumique      : %lf",m_fraction_volumique_moyenne); fonc(ligne);
  sprintf(ligne,"-> Ecart-type fraction volumique      : %lf",m_fraction_volumique_ecart_type); fonc(ligne);
  sprintf(ligne,"-> Min fraction volumique      : %lf",m_fraction_volumique_min); fonc(ligne);
  sprintf(ligne,"-> Max fraction volumique      : %lf",m_fraction_volumique_max); fonc(ligne);
  sprintf(ligne,"-> OT_HISTOGRAMME fraction volumique : nb_colonne(%li), largeur_colonne(%lf), xmin(%lf), xmax(%lf)", m_fraction_volumique_histogramme.get_nb_colonne(),
                                                                                                          m_fraction_volumique_histogramme.get_largeur_colonne(),
                                                                                                          m_fraction_volumique_histogramme.get_x_min(),
                                                                                                          m_fraction_volumique_histogramme.get_x_max());
  fonc(ligne);
}


MSTRUCT_ANALYSE_EROSION::MSTRUCT_ANALYSE_EROSION(void): MSTRUCT_ANALYSE()
{
  m_nb_couche=0;
  m_epaisseur_couche=0;
}

MSTRUCT_ANALYSE_EROSION::MSTRUCT_ANALYSE_EROSION(std::string identifiant,
                                                 MSTRUCT_ANALYSE* analyse_initiale,
                                                 long nb_couche,
                                                 double epaisseur_couche): MSTRUCT_ANALYSE(identifiant,
                                                                                           analyse_initiale->get_nom_groupe_forme(),
                                                                                           analyse_initiale->get_boite_analyse()),
                                                                                           m_nb_couche(nb_couche),
                                                                                           m_epaisseur_couche(epaisseur_couche)
{
  std::string iden_ini=identifiant+"_0";
  analyse_initiale->change_identifiant(iden_ini);
  ajouter_analyse(analyse_initiale);
  int type_analyse = analyse_initiale->get_type();
  for(long i=1;i<m_nb_couche;i++)
  {
    MSTRUCT_ANALYSE* nouvelle_analyse;
    if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CHAMP)
    {
      MSTRUCT_ANALYSE_CHAMP* analyse_ini_champ = (MSTRUCT_ANALYSE_CHAMP*)analyse_initiale;
      MSTRUCT_ANALYSE_CHAMP* analyse_champ = new MSTRUCT_ANALYSE_CHAMP(*analyse_ini_champ);
      nouvelle_analyse=analyse_champ;      
    }
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::ORIENTATION)
    {
      MSTRUCT_ANALYSE_ORIENTATION* analyse_ini_ori = (MSTRUCT_ANALYSE_ORIENTATION*)analyse_initiale;
      MSTRUCT_ANALYSE_ORIENTATION* analyse_ori = new MSTRUCT_ANALYSE_ORIENTATION(*analyse_ini_ori);
      nouvelle_analyse=analyse_ori;  
    }
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::ORIENTATION_PONDEREE)
    {
      MSTRUCT_ANALYSE_ORIENTATION_PONDEREE* analyse_ini_ori = (MSTRUCT_ANALYSE_ORIENTATION_PONDEREE*)analyse_initiale;
      MSTRUCT_ANALYSE_ORIENTATION_PONDEREE* analyse_ori = new MSTRUCT_ANALYSE_ORIENTATION_PONDEREE(*analyse_ini_ori);
      nouvelle_analyse=analyse_ori;  
    }
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CAO)
    {
      MSTRUCT_ANALYSE_CAO* analyse_ini_cao = (MSTRUCT_ANALYSE_CAO*)analyse_initiale;
      MSTRUCT_ANALYSE_CAO* analyse_cao = new MSTRUCT_ANALYSE_CAO(*analyse_ini_cao);
      nouvelle_analyse=analyse_cao;  
    }
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_MG)
    {
      MSTRUCT_ANALYSE_MG_MAILLAGE* analyse_ini_mg_maill = (MSTRUCT_ANALYSE_MG_MAILLAGE*)analyse_initiale;
      MSTRUCT_ANALYSE_MG_MAILLAGE* analyse_mg_maill = new MSTRUCT_ANALYSE_MG_MAILLAGE(*analyse_ini_mg_maill);
      nouvelle_analyse=analyse_mg_maill;  
    }
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_FEM)
    {
      MSTRUCT_ANALYSE_FEM_MAILLAGE* analyse_ini_fem_maill = (MSTRUCT_ANALYSE_FEM_MAILLAGE*)analyse_initiale;
      MSTRUCT_ANALYSE_FEM_MAILLAGE* analyse_fem_maill = new MSTRUCT_ANALYSE_FEM_MAILLAGE(*analyse_ini_fem_maill);
      nouvelle_analyse=analyse_fem_maill;  
    }
    char iden[500];
    sprintf(iden,"%s_%li",identifiant.c_str(),i);
    nouvelle_analyse->change_identifiant(iden);
    if(nouvelle_analyse->get_boite_analyse()==NULL)
    {
      nouvelle_analyse->change_boite_analyse(BOITE_3D(0.0,0.0,0.0,1.0,1.0,1.0));
    }
    double xmin,ymin,zmin,xmax,ymax,zmax;
    xmin=nouvelle_analyse->get_boite_analyse()->get_xmin();
    ymin=nouvelle_analyse->get_boite_analyse()->get_ymin();
    zmin=nouvelle_analyse->get_boite_analyse()->get_zmin();
    xmax=nouvelle_analyse->get_boite_analyse()->get_xmax();
    ymax=nouvelle_analyse->get_boite_analyse()->get_ymax();
    zmax=nouvelle_analyse->get_boite_analyse()->get_zmax();
    xmin=xmin+i*m_epaisseur_couche;
    ymin=ymin+i*m_epaisseur_couche;
    zmin=zmin+i*m_epaisseur_couche;
    xmax=xmax-i*m_epaisseur_couche;
    ymax=ymax-i*m_epaisseur_couche;
    zmax=zmax-i*m_epaisseur_couche;
    nouvelle_analyse->get_boite_analyse()->reinit(xmin,ymin,zmin,xmax,ymax,zmax);
    ajouter_analyse(nouvelle_analyse);
  }
}


MSTRUCT_ANALYSE_EROSION::MSTRUCT_ANALYSE_EROSION(std::vector< MSTRUCT_ANALYSE_EROSION* >& vector_analyse): MSTRUCT_ANALYSE()
{
  std::vector<MSTRUCT_ANALYSE_EROSION*>::iterator it_analyse_erosion=vector_analyse.begin();
  MSTRUCT_ANALYSE_EROSION* analyse_erosion = *it_analyse_erosion;
  m_identifiant=analyse_erosion->get_identifiant();
  if(analyse_erosion->get_boite_analyse()!=NULL) change_boite_analyse(*analyse_erosion->get_boite_analyse());
  m_nom_groupe_forme=analyse_erosion->get_nom_groupe_forme();
  m_nb_ves=vector_analyse.size();
  m_nb_couche=analyse_erosion->get_nb_couche();
  m_epaisseur_couche=analyse_erosion->get_epaisseur_couche();
  int type_analyse = analyse_erosion->get_type();
  long nb_analyse=analyse_erosion->get_nb_analyse();  
  if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CHAMP)
  {
    long i=0;
    while(i<nb_analyse)
    {
      std::vector<MSTRUCT_ANALYSE_CHAMP*> vector_analyse_compile;
      for(it_analyse_erosion=vector_analyse.begin();it_analyse_erosion!=vector_analyse.end();it_analyse_erosion++)
      {
        MSTRUCT_ANALYSE_EROSION* analyse_erosion = *it_analyse_erosion;
        vector_analyse_compile.push_back((MSTRUCT_ANALYSE_CHAMP*)analyse_erosion->get_analyse(i));
      }
      MSTRUCT_ANALYSE_CHAMP* nouvelle_analyse = new MSTRUCT_ANALYSE_CHAMP(vector_analyse_compile);
      ajouter_analyse(nouvelle_analyse);
      i++;
    }
  }
  else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::ORIENTATION)
  {
    long i=0;
    while(i<nb_analyse)
    {
      std::vector<MSTRUCT_ANALYSE_ORIENTATION*> vector_analyse_compile;
      for(it_analyse_erosion=vector_analyse.begin();it_analyse_erosion!=vector_analyse.end();it_analyse_erosion++)
      {
        MSTRUCT_ANALYSE_EROSION* analyse_erosion = *it_analyse_erosion;
        vector_analyse_compile.push_back((MSTRUCT_ANALYSE_ORIENTATION*)analyse_erosion->get_analyse(i));
      }
      MSTRUCT_ANALYSE_ORIENTATION* nouvelle_analyse = new MSTRUCT_ANALYSE_ORIENTATION(vector_analyse_compile);
      ajouter_analyse(nouvelle_analyse);
      i++;
    } 
  }
  else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::ORIENTATION_PONDEREE)
  {
    long i=0;
    while(i<nb_analyse)
    {
      std::vector<MSTRUCT_ANALYSE_ORIENTATION*> vector_analyse_compile;
      for(it_analyse_erosion=vector_analyse.begin();it_analyse_erosion!=vector_analyse.end();it_analyse_erosion++)
      {
        MSTRUCT_ANALYSE_EROSION* analyse_erosion = *it_analyse_erosion;
        vector_analyse_compile.push_back((MSTRUCT_ANALYSE_ORIENTATION_PONDEREE*)analyse_erosion->get_analyse(i));
      }
      MSTRUCT_ANALYSE_ORIENTATION_PONDEREE* nouvelle_analyse = new MSTRUCT_ANALYSE_ORIENTATION_PONDEREE(vector_analyse_compile);
      ajouter_analyse(nouvelle_analyse);
      i++;
    } 
  }
  else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CAO)
  {
    long i=0;
    while(i<nb_analyse)
    {
      std::vector<MSTRUCT_ANALYSE_CAO*> vector_analyse_compile;
      for(it_analyse_erosion=vector_analyse.begin();it_analyse_erosion!=vector_analyse.end();it_analyse_erosion++)
      {
        MSTRUCT_ANALYSE_EROSION* analyse_erosion = *it_analyse_erosion;
        vector_analyse_compile.push_back((MSTRUCT_ANALYSE_CAO*)analyse_erosion->get_analyse(i));
      }
      MSTRUCT_ANALYSE_CAO* nouvelle_analyse = new MSTRUCT_ANALYSE_CAO(vector_analyse_compile);
      ajouter_analyse(nouvelle_analyse);
      i++;
    } 
  }
  else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_MG)
  {
    long i=0;
    while(i<nb_analyse)
    {
      std::vector<MSTRUCT_ANALYSE_MG_MAILLAGE*> vector_analyse_compile;
      for(it_analyse_erosion=vector_analyse.begin();it_analyse_erosion!=vector_analyse.end();it_analyse_erosion++)
      {
        MSTRUCT_ANALYSE_EROSION* analyse_erosion = *it_analyse_erosion;
        vector_analyse_compile.push_back((MSTRUCT_ANALYSE_MG_MAILLAGE*)analyse_erosion->get_analyse(i));
      }
      MSTRUCT_ANALYSE_MG_MAILLAGE* nouvelle_analyse = new MSTRUCT_ANALYSE_MG_MAILLAGE(vector_analyse_compile);
      ajouter_analyse(nouvelle_analyse);
      i++;
    }
  }
  else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_FEM)
  {
    long i=0;
    while(i<nb_analyse)
    {
      std::vector<MSTRUCT_ANALYSE_FEM_MAILLAGE*> vector_analyse_compile;
      for(it_analyse_erosion=vector_analyse.begin();it_analyse_erosion!=vector_analyse.end();it_analyse_erosion++)
      {
        MSTRUCT_ANALYSE_EROSION* analyse_erosion = *it_analyse_erosion;
        vector_analyse_compile.push_back((MSTRUCT_ANALYSE_FEM_MAILLAGE*)analyse_erosion->get_analyse(i));
      }
      MSTRUCT_ANALYSE_FEM_MAILLAGE* nouvelle_analyse = new MSTRUCT_ANALYSE_FEM_MAILLAGE(vector_analyse_compile);
      ajouter_analyse(nouvelle_analyse);
      i++;
    }
  }
}

MSTRUCT_ANALYSE_EROSION::MSTRUCT_ANALYSE_EROSION(MSTRUCT_ANALYSE_EROSION& mdd): MSTRUCT_ANALYSE(mdd)
{
  m_nb_couche=mdd.m_nb_couche;
  m_epaisseur_couche=mdd.m_epaisseur_couche;
  std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse;
  for(MSTRUCT_ANALYSE* analyse=mdd.get_premiere_analyse(it_analyse);analyse!=NULL;analyse=mdd.get_suivante_analyse(it_analyse))
  {
    int type_analyse=analyse->get_type();
    if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CHAMP) ajouter_analyse(new MSTRUCT_ANALYSE_CHAMP(*(MSTRUCT_ANALYSE_CHAMP*)analyse));    
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::ORIENTATION) ajouter_analyse(new MSTRUCT_ANALYSE_ORIENTATION(*(MSTRUCT_ANALYSE_ORIENTATION*)analyse));
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::ORIENTATION_PONDEREE) ajouter_analyse(new MSTRUCT_ANALYSE_ORIENTATION_PONDEREE(*(MSTRUCT_ANALYSE_ORIENTATION_PONDEREE*)analyse));
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CAO) ajouter_analyse(new MSTRUCT_ANALYSE_CAO(*(MSTRUCT_ANALYSE_CAO*)analyse));
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_MG) ajouter_analyse(new MSTRUCT_ANALYSE_MG_MAILLAGE(*(MSTRUCT_ANALYSE_MG_MAILLAGE*)analyse));
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_FEM) ajouter_analyse(new MSTRUCT_ANALYSE_FEM_MAILLAGE(*(MSTRUCT_ANALYSE_FEM_MAILLAGE*)analyse));
  }
}

MSTRUCT_ANALYSE_EROSION::~MSTRUCT_ANALYSE_EROSION(void)
{
  std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse;
  for(MSTRUCT_ANALYSE* analyse=get_premiere_analyse(it_analyse);analyse!=NULL;analyse=get_suivante_analyse(it_analyse)) delete analyse;
}

long int MSTRUCT_ANALYSE_EROSION::get_nb_couche(void)
{
  return m_nb_couche;
}

double MSTRUCT_ANALYSE_EROSION::get_epaisseur_couche(void)
{
  return m_epaisseur_couche;
}

long int MSTRUCT_ANALYSE_EROSION::get_nb_analyse(void)
{
  return m_vector_analyse.size();
}

int MSTRUCT_ANALYSE_EROSION::ajouter_analyse(MSTRUCT_ANALYSE* analyse)
{
  m_vector_analyse.push_back(analyse);
}

MSTRUCT_ANALYSE* MSTRUCT_ANALYSE_EROSION::get_premiere_analyse(std::vector<MSTRUCT_ANALYSE*>::iterator& it)
{
  it=m_vector_analyse.begin();
  if(it!=m_vector_analyse.end()) return *it;
  else return NULL;
}

MSTRUCT_ANALYSE* MSTRUCT_ANALYSE_EROSION::get_suivante_analyse(std::vector<MSTRUCT_ANALYSE*>::iterator& it)
{
  it++;
  if(it!=m_vector_analyse.end()) return *it;
  else return NULL;
}

MSTRUCT_ANALYSE* MSTRUCT_ANALYSE_EROSION::get_analyse(long num)
{
  return m_vector_analyse.at(num);
}

long int MSTRUCT_ANALYSE_EROSION::get_type(void)
{
  return TYPE_ANALYSE::EROSION;
}

void MSTRUCT_ANALYSE_EROSION::executer(MSTRUCT_VES* ves)
{
  std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse;
  for(MSTRUCT_ANALYSE* analyse=get_premiere_analyse(it_analyse);analyse!=NULL;analyse=get_suivante_analyse(it_analyse)) analyse->executer(ves);
}

void MSTRUCT_ANALYSE_EROSION::exporter(std::ofstream& ofstrm, long i, bool avec_entete, bool avec_histo, char* prefix_histo)
{
  std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse;
  for(MSTRUCT_ANALYSE* analyse=get_premiere_analyse(it_analyse);analyse!=NULL;analyse=get_suivante_analyse(it_analyse))
  {
    ofstrm << analyse->get_identifiant() << std::endl;
    analyse->exporter(ofstrm,i,avec_entete,avec_histo,prefix_histo);
  }
}

void MSTRUCT_ANALYSE_EROSION::enregistrer(std::ofstream& ofstrm)
{
  long type_analyse=get_type();
  ofstrm.write((char*)&type_analyse,sizeof(long));
  MSTRUCT_ANALYSE::enregistrer(ofstrm);
  ofstrm.write((char*)&m_nb_couche,sizeof(long));
  ofstrm.write((char*)&m_epaisseur_couche,sizeof(double));
  long nb_analyse=get_nb_analyse();
  ofstrm.write((char*)&nb_analyse,sizeof(long));
  std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse;
  for(MSTRUCT_ANALYSE* analyse=get_premiere_analyse(it_analyse);analyse!=NULL;analyse=get_suivante_analyse(it_analyse)) analyse->enregistrer(ofstrm);  
}

void MSTRUCT_ANALYSE_EROSION::ouvrir(std::ifstream& ifstrm)
{
  MSTRUCT_ANALYSE::ouvrir(ifstrm);
  ifstrm.read((char*)&m_nb_couche,sizeof(long));
  ifstrm.read((char*)&m_epaisseur_couche,sizeof(double));
  long nb_analyse;
  ifstrm.read((char*)&nb_analyse,sizeof(long));
  for(long i=0;i<nb_analyse;i++)
  {
    long type_analyse;
    ifstrm.read((char*)&type_analyse,sizeof(long));
    MSTRUCT_ANALYSE *analyse;
    if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CHAMP)
    {
      analyse = new MSTRUCT_ANALYSE_CHAMP;
      analyse->ouvrir(ifstrm);      
    }
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::ORIENTATION)
    {
      analyse = new MSTRUCT_ANALYSE_ORIENTATION;
      analyse->ouvrir(ifstrm);      
    }
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::ORIENTATION_PONDEREE)
    {
      analyse = new MSTRUCT_ANALYSE_ORIENTATION_PONDEREE;
      analyse->ouvrir(ifstrm);      
    }
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CAO)
    {
      analyse = new MSTRUCT_ANALYSE_CAO;
      analyse->ouvrir(ifstrm);      
    }
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_MG)
    {
      analyse = new MSTRUCT_ANALYSE_MG_MAILLAGE;
      analyse->ouvrir(ifstrm);      
    }
    else if(type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_FEM)
    {
      analyse = new MSTRUCT_ANALYSE_FEM_MAILLAGE;
      analyse->ouvrir(ifstrm);      
    }
    ajouter_analyse(analyse);
  }
}

void MSTRUCT_ANALYSE_EROSION::affiche_contenu(fonction_affiche* fonc)
{
  MSTRUCT_ANALYSE::affiche_contenu(fonc);
  char ligne[5000];
  sprintf(ligne,"MSTRUCT_ANALYSE_EROSION");fonc(ligne);
  sprintf(ligne,"-> Nb analyse : %li",get_nb_analyse());fonc(ligne);
  sprintf(ligne,"-> Nb couche  : %li",m_nb_couche);fonc(ligne);
  sprintf(ligne,"-> Epaisseur couche  : %lf",m_epaisseur_couche);fonc(ligne);
  std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse;
  for(MSTRUCT_ANALYSE* analyse=get_premiere_analyse(it_analyse);analyse!=NULL;analyse=get_suivante_analyse(it_analyse))
  {
    analyse->affiche_contenu(fonc);
  }
}


MSTRUCT_ANALYSE_MODULES_MECA::MSTRUCT_ANALYSE_MODULES_MECA(MSTRUCT_ANALYSE_CHAMP* epsilon_sph,
                                                           MSTRUCT_ANALYSE_CHAMP* sigma_sph,
                                                           MSTRUCT_ANALYSE_CHAMP* epsilon_dev,
                                                           MSTRUCT_ANALYSE_CHAMP* sigma_dev,
                                                           double largeur_colonne_distribution_module_Kapp,
                                                           double largeur_colonne_distribution_module_Gapp,
                                                           double largeur_colonne_distribution_module_Eapp,
                                                           double largeur_colonne_distribution_module_Nuapp)
{
  m_Kapp_moyenne=0;
  m_Kapp_ecart_type=0;
  m_Kapp_min=0.0;
  m_Kapp_max=0.0;
  m_Kapp_histogramme.fixe_largeur_colonne(largeur_colonne_distribution_module_Kapp);
  m_Gapp_moyenne=0;
  m_Gapp_ecart_type=0;
  m_Gapp_min=0.0;
  m_Gapp_max=0.0;
  m_Gapp_histogramme.fixe_largeur_colonne(largeur_colonne_distribution_module_Gapp);
  m_Eapp_moyenne=0;
  m_Eapp_ecart_type=0;
  m_Eapp_min=0.0;
  m_Eapp_max=0.0;
  m_Eapp_histogramme.fixe_largeur_colonne(largeur_colonne_distribution_module_Eapp);
  m_Nuapp_moyenne=0;
  m_Nuapp_ecart_type=0;
  m_Nuapp_min=0.0;
  m_Nuapp_max=0.0;
  m_Nuapp_histogramme.fixe_largeur_colonne(largeur_colonne_distribution_module_Nuapp);
  m_Kapp_moyenne = (sigma_sph->get_moyenne()[0]+sigma_sph->get_moyenne()[1]+sigma_sph->get_moyenne()[2])/(3.0*(epsilon_sph->get_moyenne()[0]+epsilon_sph->get_moyenne()[1]+epsilon_sph->get_moyenne()[2]));
  m_Gapp_moyenne = (1./3.)*((sigma_dev->get_moyenne()[3]/(2*epsilon_dev->get_moyenne()[3]))+
                          (sigma_dev->get_moyenne()[4]/(2*epsilon_dev->get_moyenne()[4]))+
                          (sigma_dev->get_moyenne()[5]/(2*epsilon_dev->get_moyenne()[5])));
  m_Eapp_moyenne = (9.0*m_Kapp_moyenne*m_Gapp_moyenne)/(3.0*m_Kapp_moyenne+m_Gapp_moyenne);
  m_Nuapp_moyenne = (3.0*m_Kapp_moyenne-2.0*m_Gapp_moyenne)/(2.0*(3.0*m_Kapp_moyenne+m_Gapp_moyenne));
  
  m_Kapp_ecart_type=m_Kapp_moyenne;
  m_Kapp_min=m_Kapp_moyenne;
  m_Kapp_max=m_Kapp_moyenne;
  
  m_Gapp_ecart_type=m_Gapp_moyenne;
  m_Gapp_min=m_Gapp_moyenne;
  m_Gapp_max=m_Gapp_moyenne;
  
  m_Eapp_ecart_type=m_Eapp_moyenne;
  m_Eapp_min=m_Eapp_moyenne;
  m_Eapp_max=m_Eapp_moyenne;
  
  m_Nuapp_ecart_type=m_Nuapp_moyenne;
  m_Nuapp_min=m_Nuapp_moyenne;
  m_Nuapp_max=m_Nuapp_moyenne;
}

MSTRUCT_ANALYSE_MODULES_MECA::MSTRUCT_ANALYSE_MODULES_MECA(std::vector< MSTRUCT_ANALYSE_MODULES_MECA* >& vector_analyse)
{
  std::vector<MSTRUCT_ANALYSE_MODULES_MECA*>::iterator it_analyse=vector_analyse.begin();
  MSTRUCT_ANALYSE_MODULES_MECA* analyse=*it_analyse;
  m_Kapp_histogramme.fixe_largeur_colonne(analyse->get_Kapp_histogramme()->get_largeur_colonne());
  m_Gapp_histogramme.fixe_largeur_colonne(analyse->get_Gapp_histogramme()->get_largeur_colonne());
  m_Eapp_histogramme.fixe_largeur_colonne(analyse->get_Eapp_histogramme()->get_largeur_colonne());
  m_Nuapp_histogramme.fixe_largeur_colonne(analyse->get_Nuapp_histogramme()->get_largeur_colonne());
  m_Kapp_moyenne=0;
  m_Kapp_ecart_type=0;
  m_Kapp_min=std::numeric_limits<double>::max();
  m_Kapp_max=std::numeric_limits<double>::min();
  m_Gapp_moyenne=0;
  m_Gapp_ecart_type=0;
  m_Gapp_min=std::numeric_limits<double>::max();
  m_Gapp_max=std::numeric_limits<double>::min();
  m_Eapp_moyenne=0;
  m_Eapp_ecart_type=0;
  m_Eapp_min=std::numeric_limits<double>::max();
  m_Eapp_max=std::numeric_limits<double>::min();
  m_Nuapp_moyenne=0;
  m_Nuapp_ecart_type=0;
  m_Nuapp_min=std::numeric_limits<double>::max();
  m_Nuapp_max=std::numeric_limits<double>::min();
  m_nb_ves=vector_analyse.size();
  for(it_analyse=vector_analyse.begin();it_analyse!=vector_analyse.end();it_analyse++)
  {
    analyse=*it_analyse;
    m_Kapp_moyenne+=analyse->get_Kapp_moyenne();
    if(analyse->get_Kapp_moyenne()<m_Kapp_min) m_Kapp_min=analyse->get_Kapp_moyenne();
    if(analyse->get_Kapp_moyenne()>m_Kapp_max) m_Kapp_max=analyse->get_Kapp_moyenne();
    m_Kapp_histogramme.ajouter_valeur(analyse->get_Kapp_moyenne(),1.0/m_nb_ves);
    
    m_Gapp_moyenne+=analyse->get_Gapp_moyenne();
    if(analyse->get_Gapp_moyenne()<m_Gapp_min) m_Gapp_min=analyse->get_Gapp_moyenne();
    if(analyse->get_Gapp_moyenne()>m_Gapp_max) m_Gapp_max=analyse->get_Gapp_moyenne();
    m_Gapp_histogramme.ajouter_valeur(analyse->get_Gapp_moyenne(),1.0/m_nb_ves);
    
    m_Eapp_moyenne+=analyse->get_Eapp_moyenne();
    if(analyse->get_Eapp_moyenne()<m_Eapp_min) m_Eapp_min=analyse->get_Eapp_moyenne();
    if(analyse->get_Eapp_moyenne()>m_Eapp_max) m_Eapp_max=analyse->get_Eapp_moyenne();
    m_Eapp_histogramme.ajouter_valeur(analyse->get_Eapp_moyenne(),1.0/m_nb_ves);
    
    m_Nuapp_moyenne+=analyse->get_Nuapp_moyenne();
    if(analyse->get_Nuapp_moyenne()<m_Nuapp_min) m_Nuapp_min=analyse->get_Nuapp_moyenne();
    if(analyse->get_Nuapp_moyenne()>m_Nuapp_max) m_Nuapp_max=analyse->get_Nuapp_moyenne();
    m_Nuapp_histogramme.ajouter_valeur(analyse->get_Nuapp_moyenne(),1.0/m_nb_ves);
  }
  m_Kapp_moyenne=m_Kapp_moyenne/m_nb_ves;
  m_Gapp_moyenne=m_Gapp_moyenne/m_nb_ves;
  m_Eapp_moyenne=m_Eapp_moyenne/m_nb_ves;
  m_Nuapp_moyenne=m_Nuapp_moyenne/m_nb_ves;
  if(m_nb_ves>1)
  {
    for(it_analyse=vector_analyse.begin();it_analyse!=vector_analyse.end();it_analyse++)
    {
      analyse=*it_analyse;
      m_Kapp_ecart_type+=(analyse->get_Kapp_moyenne()-m_Kapp_moyenne)*(analyse->get_Kapp_moyenne()-m_Kapp_moyenne);
      m_Gapp_ecart_type+=(analyse->get_Gapp_moyenne()-m_Gapp_moyenne)*(analyse->get_Gapp_moyenne()-m_Gapp_moyenne);
      m_Eapp_ecart_type+=(analyse->get_Eapp_moyenne()-m_Eapp_moyenne)*(analyse->get_Eapp_moyenne()-m_Eapp_moyenne);
      m_Nuapp_ecart_type+=(analyse->get_Nuapp_moyenne()-m_Nuapp_moyenne)*(analyse->get_Nuapp_moyenne()-m_Nuapp_moyenne);
    }
    m_Kapp_ecart_type=sqrt(m_Kapp_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_Gapp_ecart_type=sqrt(m_Gapp_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_Eapp_ecart_type=sqrt(m_Eapp_ecart_type*(1.0/(m_nb_ves-1.0)));
    m_Nuapp_ecart_type=sqrt(m_Nuapp_ecart_type*(1.0/(m_nb_ves-1.0)));
  }
}

MSTRUCT_ANALYSE_MODULES_MECA::~MSTRUCT_ANALYSE_MODULES_MECA(void)
{
}

long int MSTRUCT_ANALYSE_MODULES_MECA::get_nb_ves(void)
{
  return m_nb_ves;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Kapp_moyenne(void)
{
  return m_Kapp_moyenne;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Kapp_ecart_type(void)
{
  return m_Kapp_ecart_type;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Kapp_min(void)
{
  return m_Kapp_min;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Kapp_max(void)
{
  return m_Kapp_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_MODULES_MECA::get_Kapp_histogramme(void)
{
  return &m_Kapp_histogramme;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Gapp_moyenne(void)
{
  return m_Gapp_moyenne;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Gapp_ecart_type(void)
{
  return m_Gapp_ecart_type;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Gapp_min(void)
{
  return m_Gapp_min;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Gapp_max(void)
{
  return m_Gapp_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_MODULES_MECA::get_Gapp_histogramme(void)
{
  return &m_Gapp_histogramme;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Nuapp_moyenne(void)
{
  return m_Nuapp_moyenne;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Nuapp_ecart_type(void)
{
  return m_Nuapp_ecart_type;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Nuapp_min(void)
{
  return m_Nuapp_min;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Nuapp_max(void)
{
  return m_Nuapp_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_MODULES_MECA::get_Nuapp_histogramme(void)
{
  return &m_Nuapp_histogramme;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Eapp_moyenne(void)
{
  return m_Eapp_moyenne;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Eapp_ecart_type(void)
{
  return m_Eapp_ecart_type;
}

double MSTRUCT_ANALYSE_MODULES_MECA::get_Eapp_min(void)
{
  return m_Eapp_min;
}

double MSTRUCT_ANALYSE_MODULES_MECA::v_Eapp_max(void)
{
  return m_Eapp_max;
}

OT_HISTOGRAMME* MSTRUCT_ANALYSE_MODULES_MECA::get_Eapp_histogramme(void)
{
  return &m_Eapp_histogramme;
}

void MSTRUCT_ANALYSE_MODULES_MECA::exporter(std::ofstream& ofstrm, long i, bool avec_entete, bool avec_histo, char* prefix_histo)
{
  if(avec_entete) ofstrm << "#(1) Eapp[moy(2) ±(3) min(4) max(5)] Nuapp[moy(6) ±(7) min(8) max(9)] Gapp[moy(10) ±(11) min(12) max(13)] Kapp[moy(14) ±(15) min(16) max(17)]" << std::endl;
  ofstrm << i << " " 
         << m_Eapp_moyenne << " "
         << m_Eapp_ecart_type << " "
         << m_Eapp_min << " "
         << m_Eapp_max << " "
         << m_Nuapp_moyenne << " "
         << m_Nuapp_ecart_type << " "
         << m_Nuapp_min << " "
         << m_Nuapp_max << " "
         << m_Gapp_moyenne << " "
         << m_Gapp_ecart_type << " "
         << m_Gapp_min << " "
         << m_Gapp_max << " "
         << m_Kapp_moyenne << " "
         << m_Kapp_ecart_type << " "
         << m_Kapp_min << " "
         << m_Kapp_max << std::endl;    
  if(avec_histo)
  {
    char nom_fichier[500];
    sprintf(nom_fichier,"%s/histo_Eapp.txt",prefix_histo);
    std::ofstream of_histo_Eapp(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_Eapp.precision(16);
    of_histo_Eapp.setf(std::ios::showpoint);
    m_Eapp_histogramme.exporter(of_histo_Eapp);
    of_histo_Eapp.close();
    
    sprintf(nom_fichier,"%s/histo_Nuapp.txt",prefix_histo);
    std::ofstream of_histo_Nuapp(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_Nuapp.precision(16);
    of_histo_Nuapp.setf(std::ios::showpoint);
    m_Nuapp_histogramme.exporter(of_histo_Nuapp);
    of_histo_Nuapp.close();
    
    sprintf(nom_fichier,"%s/histo_Gapp.txt",prefix_histo);
    std::ofstream of_histo_Gapp(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_Gapp.precision(16);
    of_histo_Gapp.setf(std::ios::showpoint);
    m_Gapp_histogramme.exporter(of_histo_Gapp);
    of_histo_Gapp.close();
    
    sprintf(nom_fichier,"%s/histo_Kapp.txt",prefix_histo);
    std::ofstream of_histo_Kapp(nom_fichier,std::ios::out|std::ios::trunc);
    of_histo_Kapp.precision(16);
    of_histo_Kapp.setf(std::ios::showpoint);
    m_Kapp_histogramme.exporter(of_histo_Kapp);
    of_histo_Kapp.close();
  }
}


Revision:	951
Committed:	Fri Aug 10 15:17:17 2018 UTC (6 years, 9 months ago) by couturad
File size:	151019 byte(s)
Log Message:	-> Ajout de Project Chrono (voir CMakeLists.txt). -> Ajout d'un générateur de microstructure basé sur la dynamique des corps rigides (MSTRUCT_GENERATEUR_DCR). -> Ajout d'un opérateur de décallage de la topologie (MG_CG_OP_TRANSF_DECALLAGE). -> Retrait de «using namespace std» (conflit avec namespace chrono) et modification des fichiers affectés. -> Modification de mailleur2d.cpp afin d'enregistrer un fichier MAGiC (void.magic) lorsque le nombre d'itération dépasse la valeur maximale.