mstruct_analyse_champ.cpp

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mstruct_analyse_champ.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "mstruct_analyse_champ.h"
#include "mstruct_definition.h"
#include "magic_plot.h"
#include "ot_mathematique.h"
#include "fem_solution.h"
#include "mstruct_outils.h"
#include "mg_cg_forme.h"
#include "mg_cg_groupe_forme.h"
#include "mg_cg_assemblage.h"
#include "mg_cg_modele.h"
#include "mg_gestionnaire.h"
#include <string.h>
#include <math.h>
#include <limits>
 
MSTRUCT_ANALYSE_CHAMP::MSTRUCT_ANALYSE_CHAMP(void): MSTRUCT_ANALYSE()
{
}
 
MSTRUCT_ANALYSE_CHAMP::MSTRUCT_ANALYSE_CHAMP(MSTRUCT_VES* ves,
                                             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(ves,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_moyenne[i]=0.0;
    m_ecart_type[i]=0.0;
    m_min[i]=0.0;
    m_max[i]=0.0;
    m_tab_histogramme[i] = new OT_HISTOGRAMME(largeur_colonne);
  }  
}
 
MSTRUCT_ANALYSE_CHAMP::MSTRUCT_ANALYSE_CHAMP(std::string identifiant, int nb_champ, double largeur_colonne) : MSTRUCT_ANALYSE(identifiant)
{
  m_id_fem_solution=-1;
  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_moyenne[i]=0.0;
    m_ecart_type[i]=0.0;
    m_min[i]=0.0;
    m_max[i]=0.0;
    m_tab_histogramme[i] = new OT_HISTOGRAMME(largeur_colonne);
  }
}
 
 
MSTRUCT_ANALYSE_CHAMP::MSTRUCT_ANALYSE_CHAMP(MSTRUCT_ANALYSE_CHAMP& mdd,bool cpy_data): MSTRUCT_ANALYSE(mdd,cpy_data)
{
  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++)
  {
    if(cpy_data)
    {
      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] = new OT_HISTOGRAMME(*mdd.m_tab_histogramme[i]);
    }
    else
    {
      m_moyenne[i]=0.0;
      m_ecart_type[i]=0.0;
      m_min[i]=0.0;
      m_max[i]=0.0;
      m_tab_histogramme[i] = new OT_HISTOGRAMME(mdd.m_tab_histogramme[i]->get_largeur_colonne());
    }    
  }
}
 
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_ecart_type(void)
{
  return m_ecart_type;
}
 
double* MSTRUCT_ANALYSE_CHAMP::get_min(void)
{
  return m_min;
}
 
double* MSTRUCT_ANALYSE_CHAMP::get_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 MSTRUCT::TYPE_ANALYSE::CHAMP;
}
 
MSTRUCT_ANALYSE_CHAMP * MSTRUCT_ANALYSE_CHAMP::calculer_ecart(std::string identifiant, double largeur_colonne, MSTRUCT_ANALYSE_CHAMP* champ_compare, int type_ecart)
{
  MSTRUCT_ANALYSE_CHAMP* ecart = new MSTRUCT_ANALYSE_CHAMP;
  ecart->change_identifiant(identifiant);
  ecart->m_nb_champ=m_nb_champ;
  ecart->m_id_fem_solution=-1;
  ecart->m_moyenne = new double[m_nb_champ];
  ecart->m_ecart_type = new double[m_nb_champ];
  ecart->m_min = new double[m_nb_champ];
  ecart->m_max = new double[m_nb_champ];
  ecart->m_tab_histogramme=new OT_HISTOGRAMME*[m_nb_champ];
  for(int i=0;i<ecart->m_nb_champ;i++)
  {
    ecart->m_moyenne[i]=0.0;
    ecart->m_ecart_type[i]=0.0;
    ecart->m_min[i]=0.0;
    ecart->m_max[i]=0.0;
    ecart->m_tab_histogramme[i]=new OT_HISTOGRAMME(largeur_colonne);
  }
  for(int i=0;i<ecart->m_nb_champ;i++)
  {
    if(type_ecart==MSTRUCT::TYPE_COMPARAISON::ECART_RELATIF)
    {
      if(std::fabs(champ_compare->m_moyenne[i])>1.0e-16) ecart->m_moyenne[i]=(m_moyenne[i]-champ_compare->m_moyenne[i])/champ_compare->m_moyenne[i];
      else ecart->m_moyenne[i]=nan("");
      ecart->m_ecart_type[i]=nan("");
      ecart->m_min[i]=nan("");
      ecart->m_max[i]=nan("");
      std::map<long,double>::iterator it_his;
      double val;
      long l;
      int k=get_distribution(i)->get_premiere_valeur(it_his,val,l);      
      while(k!=0)
      {
        double valcompare;
        ecart->get_distribution(i)->get_valeur(l,valcompare);
        if(std::fabs(valcompare)>1.0e-16) ecart->m_tab_histogramme[i]->ajouter_valeur(l,(val-valcompare)/valcompare);
        else ecart->m_tab_histogramme[i]->ajouter_valeur(l,nan(""));
        k=get_distribution(i)->get_suivante_valeur(it_his,val,l);
      }
    }
    if(type_ecart==MSTRUCT::TYPE_COMPARAISON::ECART_RELATIF_ABSOLUE)
    {
      if(std::fabs(champ_compare->m_moyenne[i])>1.0e-16) ecart->m_moyenne[i]=std::fabs((m_moyenne[i]-champ_compare->m_moyenne[i])/champ_compare->m_moyenne[i]);
      else ecart->m_moyenne[i]=nan("");
      ecart->m_ecart_type[i]=nan("");
      ecart->m_min[i]=nan("");
      ecart->m_max[i]=nan("");
      std::map<long,double>::iterator it_his;
      double val;
      long l;
      int k=get_distribution(i)->get_premiere_valeur(it_his,val,l);      
      while(k!=0)
      {
        double valcompare;
        ecart->get_distribution(i)->get_valeur(l,valcompare);
        if(std::fabs(valcompare)>1.0e-16) ecart->m_tab_histogramme[i]->ajouter_valeur(l,std::fabs((val-valcompare)/valcompare));
        else ecart->m_tab_histogramme[i]->ajouter_valeur(l,nan(""));
        k=get_distribution(i)->get_suivante_valeur(it_his,val,l);
      }
    }
    else if(type_ecart==MSTRUCT::TYPE_COMPARAISON::ECART_ABSOLUE)
    {
      ecart->m_moyenne[i]=std::fabs(m_moyenne[i]-champ_compare->m_moyenne[i]);
      ecart->m_ecart_type[i]=nan("");
      ecart->m_min[i]=nan("");
      ecart->m_max[i]=nan("");
      std::map<long,double>::iterator it_his;
      double val;
      long l;
      int k=get_distribution(i)->get_premiere_valeur(it_his,val,l);      
      while(k!=0)
      {
        double valcompare;
        ecart->get_distribution(i)->get_valeur(l,valcompare);
        ecart->m_tab_histogramme[i]->ajouter_valeur(l,std::fabs(val-valcompare));
        k=get_distribution(i)->get_suivante_valeur(it_his,val,l);
      }
    }
    else if(type_ecart==MSTRUCT::TYPE_COMPARAISON::ECART_QUADRATIQUE)
    {
      double val=(m_moyenne[i]-champ_compare->m_moyenne[i]);
      ecart->m_moyenne[i]=val*val;
      ecart->m_ecart_type[i]=nan("");
      ecart->m_min[i]=nan("");
      ecart->m_max[i]=nan("");
      std::map<long,double>::iterator it_his;
      long l;
      int k=get_distribution(i)->get_premiere_valeur(it_his,val,l);      
      while(k!=0)
      {
        double valcompare;
        ecart->get_distribution(i)->get_valeur(l,valcompare);
        ecart->m_tab_histogramme[i]->ajouter_valeur(l,(val-valcompare)*(val-valcompare));
        k=get_distribution(i)->get_suivante_valeur(it_his,val,l);
      }
    }
  }
  return ecart;
}
 
MSTRUCT_ANALYSE_CHAMP * MSTRUCT_ANALYSE_CHAMP::calculer_ecart_chargement(std::string identifiant, double largeur_colonne, int type_chargement, int type_ecart)
{
  MSTRUCT_ANALYSE_CHAMP* ecart = new MSTRUCT_ANALYSE_CHAMP;
  ecart->change_identifiant(identifiant);
  ecart->m_nb_champ=1;
  ecart->m_id_fem_solution=-1;
  ecart->m_moyenne = new double[m_nb_champ];
  ecart->m_ecart_type = new double[m_nb_champ];
  ecart->m_min = new double[m_nb_champ];
  ecart->m_max = new double[m_nb_champ];
  ecart->m_tab_histogramme=new OT_HISTOGRAMME*[m_nb_champ];
  ecart->m_moyenne[0]=0.0;
  ecart->m_ecart_type[0]=0.0;
  ecart->m_min[0]=std::numeric_limits<double>::max();
  ecart->m_max[0]=std::numeric_limits<double>::min();
  ecart->m_tab_histogramme[0]=new OT_HISTOGRAMME(largeur_colonne);
  double err[6];
  if(type_chargement==MSTRUCT::TYPE_CHARGEMENT::SPHERIQUE)
  {
    err[0]=(3.0*m_moyenne[0])/(m_moyenne[0]+m_moyenne[1]+m_moyenne[2])-1.0;
    err[1]=(3.0*m_moyenne[1])/(m_moyenne[0]+m_moyenne[1]+m_moyenne[2])-1.0;
    err[2]=(3.0*m_moyenne[2])/(m_moyenne[0]+m_moyenne[1]+m_moyenne[2])-1.0;
    err[3]=(3.0*m_moyenne[3])/(m_moyenne[0]+m_moyenne[1]+m_moyenne[2]);
    err[4]=(3.0*m_moyenne[4])/(m_moyenne[0]+m_moyenne[1]+m_moyenne[2]);
    err[5]=(3.0*m_moyenne[5])/(m_moyenne[0]+m_moyenne[1]+m_moyenne[2]);
  }
  else if(type_chargement==MSTRUCT::TYPE_CHARGEMENT::DEVIATORIQUE)
  {
    err[0]=(3.0*m_moyenne[0])/(m_moyenne[3]+m_moyenne[4]+m_moyenne[5]);
    err[1]=(3.0*m_moyenne[1])/(m_moyenne[3]+m_moyenne[4]+m_moyenne[5]);
    err[2]=(3.0*m_moyenne[2])/(m_moyenne[3]+m_moyenne[4]+m_moyenne[5]);
    err[3]=(3.0*m_moyenne[3])/(m_moyenne[3]+m_moyenne[4]+m_moyenne[5])-1.0;
    err[4]=(3.0*m_moyenne[4])/(m_moyenne[3]+m_moyenne[4]+m_moyenne[5])-1.0;
    err[5]=(3.0*m_moyenne[5])/(m_moyenne[3]+m_moyenne[4]+m_moyenne[5])-1.0;
  }
  if(type_ecart==MSTRUCT::TYPE_COMPARAISON::ECART_RELATIF_ABSOLUE)
  {
    for(int i=0;i<6;i++) err[i]=std::fabs(err[i]);
  }
  else if(type_ecart==MSTRUCT::TYPE_COMPARAISON::ECART_QUADRATIQUE)
  {
    for(int i=0;i<6;i++) err[i]*=err[i];
  }  
  for(int i=0;i<6;i++)
  {
    ecart->m_moyenne[0]+=err[i];
    if(err[i]<ecart->m_min[0]) ecart->m_min[0]=err[i];
    if(err[i]>ecart->m_max[0]) ecart->m_max[0]=err[i];
    ecart->m_tab_histogramme[0]->ajouter_valeur(err[i],(1./6.));
  }
  for(int i=0;i<6;i++)
  {
    ecart->m_ecart_type[0]+=(err[0]-ecart->m_moyenne[0])*(err[0]-ecart->m_moyenne[0]);
  }
  ecart->m_ecart_type[0]=std::sqrt(ecart->m_ecart_type[0]*(1.0/(5.0)));
  return ecart;
}
 
MSTRUCT_ANALYSE_CHAMP * MSTRUCT_ANALYSE_CHAMP::normaliser(std::string identifiant,double valeur_ref,double largeur_colonne)
{
  MSTRUCT_ANALYSE_CHAMP* norm = new MSTRUCT_ANALYSE_CHAMP;
  norm->change_identifiant(identifiant);
  norm->m_nb_champ=m_nb_champ;
  norm->m_id_fem_solution=-1;
  norm->m_moyenne = new double[m_nb_champ];
  norm->m_ecart_type = new double[m_nb_champ];
  norm->m_min = new double[m_nb_champ];
  norm->m_max = new double[m_nb_champ];
  norm->m_tab_histogramme=new OT_HISTOGRAMME*[m_nb_champ];
  for(int i=0;i<m_nb_champ;i++)
  {
    norm->m_tab_histogramme[i]=new OT_HISTOGRAMME(largeur_colonne);
  }
  for(int i=0;i<m_nb_champ;i++)
  {
    norm->m_moyenne[i]=m_moyenne[i]/valeur_ref;
    norm->m_ecart_type[i]=m_ecart_type[i]/valeur_ref;
    norm->m_min[i]=m_min[i]/valeur_ref;
    norm->m_max[i]=m_max[i]/valeur_ref;
    double lar_col=get_distribution(i)->get_largeur_colonne();
    std::map<long,double>::iterator it_his;
    double val;
    long l;
    int k=get_distribution(i)->get_premiere_valeur(it_his,val,l);      
    while(k!=0)
    {
      norm->m_tab_histogramme[i]->ajouter_valeur((l*lar_col)/valeur_ref,val);
      k=get_distribution(i)->get_suivante_valeur(it_his,val,l);
    }
  }
  return norm;
}
 
void MSTRUCT_ANALYSE_CHAMP::executer(void)
{
  FEM_SOLUTION* fem_sol = m_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=m_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_graph, char* prefix_graph)
{
  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_graph)
    for(int j=0;j<m_nb_champ;j++)
    {
      if(m_tab_histogramme[j]!=NULL)
      {
        char nom_fichier[500];
        sprintf(nom_fichier,"%s/histo_%s_%i.txt",prefix_graph,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();
        MAGIC_PLOT magic_plot;
        char nom_plot[500];
        sprintf(nom_plot,"%s/histo_%s_%i.plt",prefix_graph,m_identifiant.c_str(),j);
        magic_plot.histogramme_couleur=MAGIC_PLOT::COULEUR::GRIS;
        magic_plot.histogramme_titre=m_identifiant.c_str();
        magic_plot.histogramme_axeX_nom="Valeur champ";
        magic_plot.histogramme_axeY_nom="";
        magic_plot.histogramme_nom_fichier_eps=std::string(m_identifiant+".eps").c_str();
        sprintf(nom_fichier,"histo_%s_%i.txt",m_identifiant.c_str(),j);
        magic_plot.plot_script_histogramme(nom_fichier,nom_plot,true);
      }
      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_graph,m_identifiant.c_str());
        MAGIC_PLOT magic_plot;
        magic_plot.tenseur_couleur=MAGIC_PLOT::COULEUR::GRIS;
        magic_plot.tenseur_titre=m_identifiant.c_str();
        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);
  }
}