microstructure/src/mstruct_ves.cpp

#include "mstruct_ves.h"
#include "mg_volume.h"
#include "mg_geometrie.h"
#include "mg_maillage.h"
#include "fem_maillage.h"
#include "mg_gestionnaire.h"
#include "mstruct_groupe_volume.h"
#include "mstruct_parametres.h"
#include "mstruct_generateur_rsa.h"
#include "mstruct_generateur_dcr.h"
#include "mstruct_definition.h"
#include "mstruct_analyse_champ.h"
#include "mstruct_analyse_orientation.h"
#include "mstruct_analyse_cao.h"
#include "mstruct_analyse_propriete_massique.h"
#include "mstruct_analyse_mg_maillage.h"
#include "mstruct_analyse_fem_maillage.h"
#include "mstruct_analyse_erosion.h"
#include "mstruct_analyse_modules_elasticite.h"
#include "mstruct_analyse_conductivite_thermique.h"
#include "mg_cg_modele.h"
#include "mg_cg_assemblage.h"
#include "mg_sous_geometrie.h"
#include "mg_cg_forme_multi_volume.h"
#include "mg_cg_info.h"
#include "mg_file.h"
#include "fct_taille_fem_solution_generateur_microstructure.h"
#include "mailleur3d_couche.h"
#include "mailleur0d.h"
#include "mailleur1d.h"
#include "mailleur2d.h"
#include "mailleur3d.h"
#include "mailleur_fem.h"
#include "mailleur_analyse.h"
#include <fstream>
#include "mgaster.h"
#include "ot_cpu.h"
#include "mstruct_outils.h"
#include "mg_cg_groupe_forme.h"
#include "mstruct_ves_file.h"
#include "fem_tetra4.h"
#include "fem_tetra10.h"
#include "fem_penta6.h"
#include "fem_penta15.h"
#include "parse.h"
#include "pars_argument.h"
MSTRUCT_VES::MSTRUCT_VES(void)
{
  m_mg_gestionnaire=new MG_GESTIONNAIRE;
  m_mg_geometrie=NULL;
  m_mgcg_modele=NULL;
  m_mgcg_assemblage=NULL;
  m_mg_maillage=NULL;
  m_fem_maillage=NULL;
  m_ves_file=new MSTRUCT_VES_FILE;
  change_boite_3D_ves(BOITE_3D(0.0,0.0,0.0,1.0,1.0,1.0));
  change_precision(1.0e-06);
  change_temps_geometrie(0.0);
  change_temps_carte(0.0);
  change_temps_maillage(0.0);
  change_temps_fem_maillage(0.0);
  change_temps_etude(0.0);
  change_temps_calcul(0.0);
  change_temps_analyse(0.0);
}

MSTRUCT_VES::MSTRUCT_VES(char* fichier_ves)
{
  m_ves_file=new MSTRUCT_VES_FILE;
  m_ves_file->ouvrir(fichier_ves);
  m_mg_gestionnaire = new MG_FILE(m_ves_file->get_nom_fichier_magic());  
  if(m_ves_file->get_id_mgcg_modele()>0) m_mgcg_modele = m_mg_gestionnaire->get_mgcg_modeleid(m_ves_file->get_id_mgcg_modele());
  else m_mgcg_modele=NULL;
  if(m_ves_file->get_id_mgcg_assemblage()>0) m_mgcg_assemblage = m_mgcg_modele->get_mgcg_assemblageid(m_ves_file->get_id_mgcg_assemblage());
  else m_mgcg_assemblage=NULL;
  if(m_ves_file->get_id_mg_geometrie()>0) m_mg_geometrie = m_mg_gestionnaire->get_mg_geometrieid(m_ves_file->get_id_mg_geometrie());
  else m_mg_geometrie = NULL;
  if(m_ves_file->get_id_mg_maillage()>0) m_mg_maillage = m_mg_gestionnaire->get_mg_maillageid(m_ves_file->get_id_mg_maillage());
  else m_mg_maillage = NULL;
  if(m_ves_file->get_id_fem_maillage()>0) m_fem_maillage = m_mg_gestionnaire->get_fem_maillageid(m_ves_file->get_id_fem_maillage());
  else m_fem_maillage = NULL;
}

MSTRUCT_VES::~MSTRUCT_VES(void)
{
  delete m_mg_gestionnaire;
  delete m_ves_file;
}

MG_GESTIONNAIRE* MSTRUCT_VES::get_mg_gestionnaire(void)
{
  return m_mg_gestionnaire;
}

void MSTRUCT_VES::change_mg_gestionnaire(MG_GESTIONNAIRE* gest)
{
  m_mg_gestionnaire=gest;
}

void MSTRUCT_VES::change_mg_geometrie(MG_GEOMETRIE* mg_geometrie)
{
  m_mg_geometrie=mg_geometrie;
  m_ves_file->change_id_mg_geometrie(m_mg_geometrie->get_id());
}

MG_GEOMETRIE* MSTRUCT_VES::get_mg_geometrie(void)
{
  return m_mg_geometrie;
}

void MSTRUCT_VES::change_mgcg_assemblage(MG_CG_ASSEMBLAGE* mgcg_assemblage)
{
  m_mgcg_assemblage=mgcg_assemblage;
  m_ves_file->change_id_mgcg_assemblage(m_mgcg_assemblage->get_id());
}

MG_CG_ASSEMBLAGE* MSTRUCT_VES::get_mgcg_assemblage(void)
{
  return m_mgcg_assemblage;
}

void MSTRUCT_VES::change_mgcg_modele(MG_CG_MODELE* mgcg_modele)
{
  m_mgcg_modele=mgcg_modele;
  m_ves_file->change_id_mgcg_modele(m_mgcg_modele->get_id());
}

MG_CG_MODELE* MSTRUCT_VES::get_mgcg_modele(void)
{
  return m_mgcg_modele;
}

MG_MAILLAGE* MSTRUCT_VES::get_mg_maillage(void)
{
  return m_mg_maillage;
}

void MSTRUCT_VES::change_mg_maillage(MG_MAILLAGE* mg_maillage)
{
  m_mg_maillage=mg_maillage;
  m_ves_file->change_id_mg_maillage(m_mg_maillage->get_id());
}

FEM_MAILLAGE* MSTRUCT_VES::get_fem_maillage(void)
{
  return m_fem_maillage;
}

void MSTRUCT_VES::change_fem_maillage(FEM_MAILLAGE* fem_maillage)
{
  m_fem_maillage=fem_maillage;
  m_ves_file->change_id_fem_maillage(m_fem_maillage->get_id());
}

BOITE_3D MSTRUCT_VES::get_boite3d_ves(void)
{
  return m_ves_file->get_boite_3D_ves();
}

void MSTRUCT_VES::change_boite_3D_ves(BOITE_3D boite3D)
{
  m_ves_file->change_boite_3D_ves(boite3D);
}

double MSTRUCT_VES::get_precision(void)
{
  return m_ves_file->get_precision();
}

void MSTRUCT_VES::change_precision(double precision)
{
  m_ves_file->change_precision(precision);
}

double MSTRUCT_VES::get_temps_geometrie(void)
{
  return m_ves_file->get_temps_geometrie();
}

void MSTRUCT_VES::change_temps_geometrie(double temps)
{
  m_ves_file->change_temps_geometrie(temps);
}

double MSTRUCT_VES::get_temps_materiau(void)
{
  return m_ves_file->get_temps_materiau();
}

void MSTRUCT_VES::change_temps_materiau(double temps)
{
  m_ves_file->change_temps_materiau(temps);
}

double MSTRUCT_VES::get_temps_carte(void)
{
  return m_ves_file->get_temps_carte();
}

void MSTRUCT_VES::change_temps_carte(double temps)
{
  m_ves_file->change_temps_carte(temps);
}

double MSTRUCT_VES::get_temps_maillage(void)
{
  return m_ves_file->get_temps_maillage();
}

void MSTRUCT_VES::change_temps_maillage(double temps)
{
  m_ves_file->change_temps_maillage(temps);
}

double MSTRUCT_VES::get_temps_fem_maillage(void)
{
  return m_ves_file->get_temps_fem_maillage();
}

void MSTRUCT_VES::change_temps_fem_maillage(double temps)
{
  m_ves_file->change_temps_fem_maillage(temps);
}

double MSTRUCT_VES::get_temps_etude(void)
{
  return m_ves_file->get_temps_etude();
}

void MSTRUCT_VES::change_temps_etude(double temps)
{
  m_ves_file->change_temps_etude(temps);
}

double MSTRUCT_VES::get_temps_calcul(void)
{
  return m_ves_file->get_temps_calcul();
}

void MSTRUCT_VES::change_temps_calcul(double temps)
{
  m_ves_file->change_temps_calcul(temps);
}

double MSTRUCT_VES::get_temps_analyse(void)
{
  return m_ves_file->get_temps_analyse();
}

void MSTRUCT_VES::change_temps_analyse(double temps)
{
  m_ves_file->change_temps_analyse(temps);
}

long int MSTRUCT_VES::get_nb_analyse(void)
{
  return m_ves_file->get_nb_analyse();
}

int MSTRUCT_VES::ajouter_analyse(MSTRUCT_ANALYSE* analyse_ves)
{
  return m_ves_file->ajouter_analyse(analyse_ves);
}

MSTRUCT_ANALYSE* MSTRUCT_VES::get_premiere_analyse(std::map< std::string, MSTRUCT_ANALYSE* >::iterator& it)
{
  return m_ves_file->get_premiere_analyse(it);
}

MSTRUCT_ANALYSE* MSTRUCT_VES::get_suivante_analyse(std::map< std::string, MSTRUCT_ANALYSE* >::iterator& it)
{
  return m_ves_file->get_suivante_analyse(it);
}

MSTRUCT_ANALYSE* MSTRUCT_VES::get_analyse(std::string identifiant)
{
  return m_ves_file->get_analyse(identifiant);
}

int MSTRUCT_VES::supprimer_analyse(std::string identifiant)
{
  return m_ves_file->supprimer_analyse(identifiant);
}

int MSTRUCT_VES::supprimer_tout_analyse(void)
{
  return m_ves_file->supprimer_tout_analyse();
}

int MSTRUCT_VES::generer_geometrie(std::vector< OT_PARAMETRES* >& vector_params_geometrie)
{
  OT_CPU ot_cpu;
  ot_cpu.initialise();
  MSTRUCT_GENERATEUR* generateur=NULL;
  std::vector<OT_PARAMETRES*>::iterator it;
  for(it=vector_params_geometrie.begin();it!=vector_params_geometrie.end();it++)
  {
    OT_PARAMETRES* param = *it;
    if(((int)param->get_valeur((char*)"Type_generateur"))==MSTRUCT::TYPE_GENERATEUR::RSA)
    {
      std::string Nom_mgcg_modele = param->get_nom((char*)"Nom_mgcg_modele");
      MSTRUCT_GENERATEUR_RSA *RSA;
      if(generateur==NULL)
      {
        RSA = new MSTRUCT_GENERATEUR_RSA(m_mg_gestionnaire,(char*)Nom_mgcg_modele.c_str());
        generateur=RSA; 
        RSA->active_affichage(fonc_affiche);
      }
      
      double Boite3D_distribution_Xmin = param->get_valeur((char*)"Boite3D_distribution_Xmin");
      double Boite3D_distribution_Ymin = param->get_valeur((char*)"Boite3D_distribution_Ymin");
      double Boite3D_distribution_Zmin = param->get_valeur((char*)"Boite3D_distribution_Zmin");
      double Boite3D_distribution_Xmax = param->get_valeur((char*)"Boite3D_distribution_Xmax");
      double Boite3D_distribution_Ymax = param->get_valeur((char*)"Boite3D_distribution_Ymax");
      double Boite3D_distribution_Zmax = param->get_valeur((char*)"Boite3D_distribution_Zmax");
      BOITE_3D Boite3D_distribution(Boite3D_distribution_Xmin,
                                    Boite3D_distribution_Ymin,
                                    Boite3D_distribution_Zmin,
                                    Boite3D_distribution_Xmax,
                                    Boite3D_distribution_Ymax,
                                    Boite3D_distribution_Zmax);
      RSA->change_boite3d_distribution(Boite3D_distribution);
      double Nb_pas_X = param->get_valeur((char*)"Nb_pas_X");
      double Nb_pas_Y = param->get_valeur((char*)"Nb_pas_Y");
      double Nb_pas_Z = param->get_valeur((char*)"Nb_pas_Z");      
      RSA->change_nb_pas_grille(Nb_pas_X);     
      double Distance_min_inter_volume = param->get_valeur((char*)"Distance_min_inter_volume");
      RSA->change_distance_inter_volume_min(Distance_min_inter_volume);
      double Volume_min = param->get_valeur((char*)"Volume_min");
      RSA->change_volume_min(Volume_min);
      double Aire_min = param->get_valeur((char*)"Aire_min");
      RSA->change_aire_min(Aire_min);
      double Longueur_min = param->get_valeur((char*)"Longueur_min");
      RSA->change_longueur_min(Longueur_min);
      double Angle_min = param->get_valeur((char*)"Angle_min");
      RSA->change_angle_min(Angle_min);
      double Nb_iteration_max = param->get_valeur((char*)"Nb_iteration_max");
      RSA->change_nb_iteration_max(Nb_iteration_max);      
      bool Avec_intersections = (bool)param->get_valeur((char*)"Avec_intersections");
      RSA->change_intersection_bords_ves(Avec_intersections);
      std::string Nom_groupe_inclusion = param->get_nom((char*)"Nom_groupe_inclusion");
      char message[1000];
      sprintf(message,"Generateur RSA : %s",Nom_groupe_inclusion.c_str());
      affiche(message);
      int Type_inclusion = param->get_valeur((char*)"Type_inclusion");
      double Fraction_volumique_cible = param->get_valeur((char*)"Fraction_volumique_cible");
      double Eps_fraction_volumique = param->get_valeur((char*)"Eps_fraction_volumique");     
      bool Porosite = (bool)param->get_valeur((char*)"Porosite");
      std::string multicouche = param->get_nom((char*)"Multicouche");
      PARS_ARGUMENT parse_param[100];
      PARSE parse;
      parse.decode(multicouche.c_str(),"@,(&)",parse_param);
      std::vector<double> *vector_epaisseur=NULL;
      int nb_couche = atoi(parse_param[0].argument[0].c_str());
      if(nb_couche>0)
      {
          vector_epaisseur=new std::vector<double>;
          for(int i=0;i<nb_couche;i++)
          {
              double epaisseur=atof(parse_param[1].argument[i].c_str());
              vector_epaisseur->push_back(epaisseur);
          }
      }      
      if(Type_inclusion==MSTRUCT::TYPE_INCLUSION::SPHERE)
      {
        double Mu_rayon = param->get_valeur((char*)"Mu_rayon");
        double Sigma_rayon = param->get_valeur((char*)"Sigma_rayon");
        double Type_distribution_rayon = param->get_valeur((char*)"Type_distribution_rayon");
        double fraction_volumique_actuelle=0.0;
        RSA->tirrage_aleatoire_sphere(Nom_groupe_inclusion,Mu_rayon,Sigma_rayon,Type_distribution_rayon,Fraction_volumique_cible,Eps_fraction_volumique,fraction_volumique_actuelle,vector_epaisseur,Porosite);
      }
      else if(Type_inclusion==MSTRUCT::TYPE_INCLUSION::CYLINDRE)
      {
        double Mu_rayon = param->get_valeur((char*)"Mu_rayon");
        double Sigma_rayon = param->get_valeur((char*)"Sigma_rayon");
        double Type_distribution_rayon = param->get_valeur((char*)"Type_distribution_rayon");
        double Mu_longueur = param->get_valeur((char*)"Mu_longueur");
        double Sigma_longueur = param->get_valeur((char*)"Sigma_longueur");
        double Type_distribution_longueur = param->get_valeur((char*)"Type_distribution_longueur");
        double Mu_theta = param->get_valeur((char*)"Mu_theta");
        double Sigma_theta = param->get_valeur((char*)"Sigma_theta");
        double Type_distribution_theta = param->get_valeur((char*)"Type_distribution_theta");
        double Mu_phi = param->get_valeur((char*)"Mu_phi");
        double Sigma_phi = param->get_valeur((char*)"Sigma_phi");
        double Type_distribution_phi = param->get_valeur((char*)"Type_distribution_phi");
        double fraction_volumique_actuelle=0.0;
        RSA->tirrage_aleatoire_cylindre(Nom_groupe_inclusion,
                        Mu_rayon,Sigma_rayon,Type_distribution_rayon,
                        Mu_longueur,Sigma_longueur,Type_distribution_longueur,
                        Mu_theta,Sigma_theta,Type_distribution_theta,
                        Mu_phi,Sigma_phi,Type_distribution_phi,
                        Fraction_volumique_cible,Eps_fraction_volumique,fraction_volumique_actuelle,
                        vector_epaisseur,
                        Porosite);
      }
      else if(Type_inclusion==MSTRUCT::TYPE_INCLUSION::ELLIPSOIDE)
      {
        double Mu_rayon_majeur = param->get_valeur((char*)"Mu_rayon_majeur");
        double Sigma_rayon_majeur = param->get_valeur((char*)"Sigma_rayon_majeur");
        double Type_distribution_rayon_majeur = param->get_valeur((char*)"Type_distribution_rayon_majeur");
        double Mu_rayon_mineur = param->get_valeur((char*)"Mu_rayon_mineur");
        double Sigma_rayon_mineur = param->get_valeur((char*)"Sigma_rayon_mineur");
        double Type_distribution_rayon_mineur = param->get_valeur((char*)"Type_distribution_rayon_mineur");
        double Mu_theta = param->get_valeur((char*)"Mu_theta");
        double Sigma_theta = param->get_valeur((char*)"Sigma_theta");
        double Type_distribution_theta = param->get_valeur((char*)"Type_distribution_theta");
        double Mu_phi = param->get_valeur((char*)"Mu_phi");
        double Sigma_phi = param->get_valeur((char*)"Sigma_phi");
        double Type_distribution_phi = param->get_valeur((char*)"Type_distribution_phi");
        double fraction_volumique_actuelle=0.0;
        RSA->tirrage_aleatoire_ellipsoide(Nom_groupe_inclusion,
                        Mu_rayon_majeur,Sigma_rayon_majeur,Type_distribution_rayon_majeur,
                        Mu_rayon_mineur,Sigma_rayon_mineur,Type_distribution_rayon_mineur,
                        Mu_theta,Sigma_theta,Type_distribution_theta,
                        Mu_phi,Sigma_phi,Type_distribution_phi,
                        Fraction_volumique_cible,Eps_fraction_volumique,fraction_volumique_actuelle,
                        vector_epaisseur,
                        Porosite);
      }
      if(vector_epaisseur!=NULL) delete vector_epaisseur;
    }
    else if(((int)param->get_valeur((char*)"Type_generateur"))==MSTRUCT::TYPE_GENERATEUR::DCR)
    {
#ifdef PROJECT_CHRONO
      std::string Nom_mgcg_modele = param->get_nom((char*)"Nom_mgcg_modele");
      MSTRUCT_GENERATEUR_DCR *DCR;
      if(generateur==NULL)
      {
        DCR = new MSTRUCT_GENERATEUR_DCR(m_mg_gestionnaire,(char*)Nom_mgcg_modele.c_str());
        generateur=DCR; 
        DCR->active_affichage(fonc_affiche);
      }      
      double Boite3D_distribution_Xmin = param->get_valeur((char*)"Boite3D_distribution_Xmin");
      double Boite3D_distribution_Ymin = param->get_valeur((char*)"Boite3D_distribution_Ymin");
      double Boite3D_distribution_Zmin = param->get_valeur((char*)"Boite3D_distribution_Zmin");
      double Boite3D_distribution_Xmax = param->get_valeur((char*)"Boite3D_distribution_Xmax");
      double Boite3D_distribution_Ymax = param->get_valeur((char*)"Boite3D_distribution_Ymax");
      double Boite3D_distribution_Zmax = param->get_valeur((char*)"Boite3D_distribution_Zmax");
      BOITE_3D Boite3D_distribution(Boite3D_distribution_Xmin,
                                    Boite3D_distribution_Ymin,
                                    Boite3D_distribution_Zmin,
                                    Boite3D_distribution_Xmax,
                                    Boite3D_distribution_Ymax,
                                    Boite3D_distribution_Zmax);
      DCR->change_boite3d_distribution(Boite3D_distribution);
      double Nb_pas_X = param->get_valeur((char*)"Nb_pas_X");
      double Nb_pas_Y = param->get_valeur((char*)"Nb_pas_Y");
      double Nb_pas_Z = param->get_valeur((char*)"Nb_pas_Z");      
      DCR->change_nb_pas_grille(Nb_pas_X);     
      double Distance_min_inter_volume = param->get_valeur((char*)"Distance_min_inter_volume");
      DCR->change_distance_inter_volume_min(Distance_min_inter_volume);
      double Volume_min = param->get_valeur((char*)"Volume_min");
      DCR->change_volume_min(Volume_min);
      double Aire_min = param->get_valeur((char*)"Aire_min");
      DCR->change_aire_min(Aire_min);
      double Longueur_min = param->get_valeur((char*)"Longueur_min");
      DCR->change_longueur_min(Longueur_min);
      double Angle_min = param->get_valeur((char*)"Angle_min");
      DCR->change_angle_min(Angle_min);
      long Nb_iteration_max = (long)param->get_valeur((char*)"Nb_iteration_max");
      bool Avec_intersections = (bool)param->get_valeur((char*)"Avec_intersections");
      DCR->change_intersection_bords_ves(Avec_intersections);
      std::string Nom_groupe_inclusion = param->get_nom((char*)"Nom_groupe_inclusion");
      char message[1000];
      sprintf(message,"Generateur DCR : %s",Nom_groupe_inclusion.c_str());
      affiche(message);
      int Type_inclusion = param->get_valeur((char*)"Type_inclusion");
      double Fraction_volumique_cible = param->get_valeur((char*)"Fraction_volumique_cible");
      double Eps_fraction_volumique = param->get_valeur((char*)"Eps_fraction_volumique");     
      bool Porosite = (bool)param->get_valeur((char*)"Porosite");
      std::string multicouche = param->get_nom((char*)"Multicouche");
      
      bool Avec_interface_graphique = (bool)param->get_valeur((char*)"Avec_interface_graphique");
      double Facteur_reduction_vitesse = param->get_valeur((char*)"Facteur_reduction_vitesse");
      double Friction = param->get_valeur((char*)"Friction");
      double Pas_temps_sim = param->get_valeur((char*)"Pas_temps_sim");
      double Temps_max_sim = param->get_valeur((char*)"Temps_max_sim");
      double Eps_vitesse = param->get_valeur((char*)"Eps_vitesse");     
      DCR->active_interface_graphique(Avec_interface_graphique);
      DCR->change_facteur_reduction_vitesse(Facteur_reduction_vitesse);
      DCR->change_eps_vitesse(Eps_vitesse);
      DCR->change_friction(Friction);
      DCR->change_pas_temps(Pas_temps_sim);
      DCR->change_temps_max_sim(Temps_max_sim);
            
      if(Type_inclusion==MSTRUCT::TYPE_INCLUSION::SPHERE)
      {
        double Mu_rayon = param->get_valeur((char*)"Mu_rayon");
        double Sigma_rayon = param->get_valeur((char*)"Sigma_rayon");
        double Type_distribution_rayon = param->get_valeur((char*)"Type_distribution_rayon");
        DCR->ajouter_spheres(Nom_groupe_inclusion,Mu_rayon,Sigma_rayon,Type_distribution_rayon,Fraction_volumique_cible,Eps_fraction_volumique,Porosite);
      }
      else if(Type_inclusion==MSTRUCT::TYPE_INCLUSION::CYLINDRE)
      {
        double Mu_rayon = param->get_valeur((char*)"Mu_rayon");
        double Sigma_rayon = param->get_valeur((char*)"Sigma_rayon");
        double Type_distribution_rayon = param->get_valeur((char*)"Type_distribution_rayon");
        double Mu_longueur = param->get_valeur((char*)"Mu_longueur");
        double Sigma_longueur = param->get_valeur((char*)"Sigma_longueur");
        double Type_distribution_longueur = param->get_valeur((char*)"Type_distribution_longueur");
        double Mu_theta = param->get_valeur((char*)"Mu_theta");
        double Sigma_theta = param->get_valeur((char*)"Sigma_theta");
        double Type_distribution_theta = param->get_valeur((char*)"Type_distribution_theta");
        double Mu_phi = param->get_valeur((char*)"Mu_phi");
        double Sigma_phi = param->get_valeur((char*)"Sigma_phi");
        double Type_distribution_phi = param->get_valeur((char*)"Type_distribution_phi");
        DCR->ajouter_cylindres(Nom_groupe_inclusion,
                    Mu_rayon,Sigma_rayon,Type_distribution_rayon,
                    Mu_longueur,Sigma_longueur,Type_distribution_longueur,
                    Mu_theta,Sigma_theta,Type_distribution_theta,
                    Mu_phi,Sigma_phi,Type_distribution_phi,
                    Fraction_volumique_cible,Eps_fraction_volumique,
                    Porosite);
      }
#else
  std::cerr << "*** ERREUR : MSTRUCT_VES::generer_geometrie : PROJECT_CHRONO absent ***" << std::endl;
#endif      
    }
  }
  if(generateur->get_type()==MSTRUCT::TYPE_GENERATEUR::DCR)
  {
#ifdef PROJECT_CHRONO
    MSTRUCT_GENERATEUR_DCR *DCR= (MSTRUCT_GENERATEUR_DCR*)generateur;
    if(DCR->lancer_simulation()==FAIL)
    {
      delete generateur;
      return FAIL;
    }
    DCR->generer_geometrie();
#else
  std::cerr << "*** ERREUR : MSTRUCT_VES::generer_geometrie : PROJECT_CHRONO absent ***" << std::endl;
#endif     
  }
  ot_cpu.ajouter_etape((char*)"generation_geometrie");
  double temps_generation_geometrie;
  ot_cpu.get_etape((char*)"generation_geometrie",temps_generation_geometrie);
  change_temps_geometrie(get_temps_geometrie()+temps_generation_geometrie);
  generateur->construire(this);  
  delete generateur;
  return OK;
}

int MSTRUCT_VES::generer_materiau(std::vector< OT_PARAMETRES* >& vector_params_materiau)
{
  OT_CPU ot_cpu;
  ot_cpu.initialise();
  std::vector<OT_PARAMETRES*>::iterator it;
  for(it=vector_params_materiau.begin();it!=vector_params_materiau.end();it++)
  {
    OT_PARAMETRES* param = *it;
    std::string Nom_groupe_forme = param->get_nom((char*)"Nom_groupe_forme");
    bool Etude_mecanique = (bool)param->get_valeur((char*)"Etude_mecanique");
    if(Etude_mecanique)
    {
      double Mu_E = param->get_valeur((char*)"Mu_E");
      double Sigma_E = param->get_valeur((char*)"Sigma_E");
      int Type_distribution_E = (int)param->get_valeur((char*)"Type_distribution_E");
      double Mu_nu = param->get_valeur((char*)"Mu_nu");
      double Sigma_nu = param->get_valeur((char*)"Sigma_nu");
      int Type_distribution_nu = (int)param->get_valeur((char*)"Type_distribution_nu");
      std::random_device seed;
      std::mt19937_64 generateur(seed()); 
      std::uniform_real_distribution<double> uniform_distribution_E(Mu_E-Sigma_E,Mu_E+Sigma_E);
      std::normal_distribution<double> normal_distribution_E(Mu_E,Sigma_E);
      std::uniform_real_distribution<double> uniform_distribution_nu(Mu_nu-Sigma_nu,Mu_nu+Sigma_nu);
      std::normal_distribution<double> normal_distribution_nu(Mu_nu,Sigma_nu);     
      MG_CG_GROUPE_FORME* mgcg_groupe_forme = m_mgcg_modele->get_mgcg_groupe_forme(Nom_groupe_forme);    
      std::map<long,MG_CG_FORME*>::iterator it_forme;
      for(MG_CG_FORME* forme = mgcg_groupe_forme->get_premiere_mgcg_forme(it_forme);forme!=NULL;forme=mgcg_groupe_forme->get_suivante_mgcg_forme(it_forme))
      {
        double E;
        if(Type_distribution_E==MSTRUCT::TYPE_DISTRIBUTION::FIXE) E=Mu_E;
        else if(Type_distribution_E==MSTRUCT::TYPE_DISTRIBUTION::UNIFORME) E=uniform_distribution_E(generateur);
        else if(Type_distribution_E==MSTRUCT::TYPE_DISTRIBUTION::NORMALE) E=normal_distribution_E(generateur);
        double nu;
        if(Type_distribution_nu==MSTRUCT::TYPE_DISTRIBUTION::FIXE) nu=Mu_nu;
        else if(Type_distribution_nu==MSTRUCT::TYPE_DISTRIBUTION::UNIFORME) nu=uniform_distribution_nu(generateur);
        else if(Type_distribution_nu==MSTRUCT::TYPE_DISTRIBUTION::NORMALE) nu=normal_distribution_nu(generateur);        
        if(forme->get_type_forme()==MG_CG_FORME::TYPE_FORME::VOLUME)
        {
          MG_CG_FORME_VOLUME* forme_volume = (MG_CG_FORME_VOLUME*)forme;
          forme_volume->get_mg_volume()->ajouter_ccf((char*)"Em",E);
          forme_volume->get_mg_volume()->ajouter_ccf((char*)"nu",nu);
        }
        if(forme->get_type_forme()==MG_CG_FORME::TYPE_FORME::MULTI_VOLUME)
        {
          MG_CG_FORME_MULTI_VOLUME* forme_multi_volume = (MG_CG_FORME_MULTI_VOLUME*)forme;
          std::map<long,MG_VOLUME*>::iterator it_volume;
          for(MG_VOLUME* volume = forme_multi_volume->get_premier_mg_volume(it_volume);volume!=NULL;volume=forme_multi_volume->get_suivant_mg_volume(it_volume))
          {
            volume->ajouter_ccf((char*)"Em",E);
            volume->ajouter_ccf((char*)"nu",nu);
          }
        }
      }
    }
    bool Etude_thermique = (bool)param->get_valeur((char*)"Etude_thermique");
    if(Etude_thermique)
    {
      double Mu_Lambda = param->get_valeur((char*)"Mu_Lambda");
      double Sigma_Lambda = param->get_valeur((char*)"Sigma_Lambda");
      int Type_distribution_Lambda = (int)param->get_valeur((char*)"Type_distribution_Lambda");
      double Mu_Ro = param->get_valeur((char*)"Mu_Ro");
      double Sigma_Ro = param->get_valeur((char*)"Sigma_Ro");
      int Type_distribution_Ro = (int)param->get_valeur((char*)"Type_distribution_Ro");
      double Mu_Cp = param->get_valeur((char*)"Mu_Cp");
      double Sigma_Cp = param->get_valeur((char*)"Sigma_Cp");
      int Type_distribution_Cp = (int)param->get_valeur((char*)"Type_distribution_Cp");
      std::random_device seed;
      std::mt19937_64 generateur(seed()); 
      std::uniform_real_distribution<double> uniform_distribution_Lambda(Mu_Lambda-Sigma_Lambda,Mu_Lambda+Sigma_Lambda);
      std::normal_distribution<double> normal_distribution_Lambda(Mu_Lambda,Sigma_Lambda);      
      std::uniform_real_distribution<double> uniform_distribution_Ro(Mu_Ro-Sigma_Ro,Mu_Ro+Sigma_Ro);
      std::normal_distribution<double> normal_distribution_Ro(Mu_Ro,Sigma_Ro);      
      std::uniform_real_distribution<double> uniform_distribution_Cp(Mu_Cp-Sigma_Cp,Mu_Cp+Sigma_Cp);
      std::normal_distribution<double> normal_distribution_Cp(Mu_Cp,Sigma_Cp);
      MG_CG_GROUPE_FORME* mgcg_groupe_forme = m_mgcg_modele->get_mgcg_groupe_forme(Nom_groupe_forme);    
      std::map<long,MG_CG_FORME*>::iterator it_forme;
      for(MG_CG_FORME* forme = mgcg_groupe_forme->get_premiere_mgcg_forme(it_forme);forme!=NULL;forme=mgcg_groupe_forme->get_suivante_mgcg_forme(it_forme))
      {
        double Lambda;
        if(Type_distribution_Lambda==MSTRUCT::TYPE_DISTRIBUTION::FIXE) Lambda=Mu_Lambda;
        else if(Type_distribution_Lambda==MSTRUCT::TYPE_DISTRIBUTION::UNIFORME) Lambda=uniform_distribution_Lambda(generateur);
        else if(Type_distribution_Lambda==MSTRUCT::TYPE_DISTRIBUTION::NORMALE) Lambda=normal_distribution_Lambda(generateur);
        double Ro;
        if(Type_distribution_Ro==MSTRUCT::TYPE_DISTRIBUTION::FIXE) Ro=Mu_Ro;
        else if(Type_distribution_Ro==MSTRUCT::TYPE_DISTRIBUTION::UNIFORME) Ro=uniform_distribution_Ro(generateur);
        else if(Type_distribution_Ro==MSTRUCT::TYPE_DISTRIBUTION::NORMALE) Ro=normal_distribution_Ro(generateur);
        double Cp;
        if(Type_distribution_Cp==MSTRUCT::TYPE_DISTRIBUTION::FIXE) Cp=Mu_Cp;
        else if(Type_distribution_Cp==MSTRUCT::TYPE_DISTRIBUTION::UNIFORME) Cp=uniform_distribution_Cp(generateur);
        else if(Type_distribution_Cp==MSTRUCT::TYPE_DISTRIBUTION::NORMALE) Cp=normal_distribution_Cp(generateur);        
        if(forme->get_type_forme()==MG_CG_FORME::TYPE_FORME::VOLUME)
        {
          MG_CG_FORME_VOLUME* forme_volume = (MG_CG_FORME_VOLUME*)forme;
          forme_volume->get_mg_volume()->ajouter_ccf((char*)"Kx",Lambda);
          forme_volume->get_mg_volume()->ajouter_ccf((char*)"Ro",Ro);
          forme_volume->get_mg_volume()->ajouter_ccf((char*)"Cp",Cp);
        }
        if(forme->get_type_forme()==MG_CG_FORME::TYPE_FORME::MULTI_VOLUME)
        {
          MG_CG_FORME_MULTI_VOLUME* forme_multi_volume = (MG_CG_FORME_MULTI_VOLUME*)forme;
          std::map<long,MG_VOLUME*>::iterator it_volume;
          for(MG_VOLUME* volume = forme_multi_volume->get_premier_mg_volume(it_volume);volume!=NULL;volume=forme_multi_volume->get_suivant_mg_volume(it_volume))
          {
            volume->ajouter_ccf((char*)"Kx",Lambda);
            volume->ajouter_ccf((char*)"Ro",Ro);
            volume->ajouter_ccf((char*)"Cp",Cp);            
          }
        }
      }
    }
  }  
  ot_cpu.ajouter_etape((char*)"generation_materiau");
  double temps_generation_materiau;
  ot_cpu.get_etape((char*)"generation_materiau",temps_generation_materiau);
  change_temps_materiau(get_temps_materiau()+temps_generation_materiau);
  return OK;
}

int MSTRUCT_VES::generer_carte(OT_PARAMETRES *param)
{
  double Ecart_nodal = param->get_valeur((char*)"Ecart_nodal");
  double Ecart_nodal_face_particule = param->get_valeur((char*)"Ecart_nodal_face_particule");
  double Fechantillonnage = param->get_valeur((char*)"Fechantillonnage");
  double Nb_cellule_direction = param->get_valeur((char*)"Nb_cellule_direction");
  std::string Nom_fem_solution = param->get_nom((char*)"Nom_fem_solution");
  std::string Nom_mg_gestionnaire_carte = param->get_nom((char*)"Nom_mg_gestionnaire_carte");
  std::string Nom_carte = param->get_nom((char*)"Nom_carte");
  double Nb_couche_min = param->get_valeur((char*)"Nb_couche_min");
  double Nb_pas = param->get_valeur((char*)"Nb_pas");
  double Facteur_augmentation = param->get_valeur((char*)"Facteur_augmentation");
  MG_GESTIONNAIRE *mggest_carte = new MG_GESTIONNAIRE;
  MG_CG_GROUPE_FORME* mgcg_groupe_matrice = m_mgcg_modele->get_mgcg_groupe_forme((char*)"Matrice");
  TPL_MAP_ENTITE<MG_VOLUME*> tpl_map_volume_matrice = mgcg_groupe_matrice->get_tpl_map_volume();
  OT_CPU ot_cpu;
  ot_cpu.initialise();
  FCT_TAILLE_FEM_SOLUTION_GENERATEUR_MICROSTRUCTURE *carte = new FCT_TAILLE_FEM_SOLUTION_GENERATEUR_MICROSTRUCTURE(mggest_carte,
                                                                                                                  m_mg_geometrie,
                                                                                                                  Ecart_nodal,
                                                                                                                  Ecart_nodal_face_particule,
                                                                                                                  Fechantillonnage,
                                                                                                                  Nb_cellule_direction,
                                                                                                                  (char*)Nom_fem_solution.c_str(),
                                                                                                                  tpl_map_volume_matrice,
                                                                                                                  Nb_couche_min,
                                                                                                                  Nb_pas,
                                                                                                                  Facteur_augmentation);
  
  
  carte->active_affichage(fonc_affiche);
  carte->construit();
  ot_cpu.ajouter_etape((char*)"generation_carte");
  double temps_generation_carte;
  ot_cpu.get_etape((char*)"generation_carte",temps_generation_carte);
  change_temps_carte(get_temps_carte()+temps_generation_carte); 
  mggest_carte->enregistrer(Nom_mg_gestionnaire_carte.c_str());  
  carte->enregistrer((char*)Nom_carte.c_str());
  char message[1000];
  std::sprintf(message,"Fichier CARTE de sortie : %s",Nom_carte.c_str());
  affiche(message);
  m_ves_file->change_nom_fichier_carte((char*)Nom_carte.c_str());
  return OK;
}

int MSTRUCT_VES::generer_maillage(OT_PARAMETRES *param,FCT_TAILLE_FEM_SOLUTION* carte)
{
  OT_CPU ot_cpu;
  ot_cpu.initialise();
  int Niveau = (int)param->get_valeur((char*)"Niveau");
  int Niveau_opt_2d = (int)param->get_valeur((char*)"Niveau_opt_2d");
  int Niveau_opt_3d = (int)param->get_valeur((char*)"Niveau_opt_3d");
  double Priorite_metrique = param->get_valeur((char*)"Priorite_metrique");
  int Analyse = (int)param->get_valeur((char*)"Analyse");   
  affiche((char*)"Maillage du VER :");
  m_mg_maillage = new MG_MAILLAGE(m_mg_geometrie);
  m_mg_gestionnaire->ajouter_mg_maillage(m_mg_maillage);
  change_mg_maillage(m_mg_maillage); 
  affiche((char*)"Maillage 3D_couche :");
  MAILLEUR3D_COUCHE m3d_couche(m_mg_maillage,m_mg_geometrie,carte);
  m3d_couche.active_affichage(fonc_affiche);  
  LISTE_MG_VOLUME::iterator it_volume;
  for(MG_VOLUME* volume=m_mg_geometrie->get_premier_volume(it_volume);volume!=NULL;volume=m_mg_geometrie->get_suivant_volume(it_volume))
  {
    if(volume->est_mince())
    {
      char message[1000];
      sprintf(message,"-> Maillage du volume id %li",volume->get_id());
      affiche(message);
      if(m3d_couche.maille(volume)==FAIL) return FAIL;
    }
  }
  if(Niveau>=0)
  {
    long i=1;
    long nb=m_mg_geometrie->get_nb_mg_sommet();
    MAILLEUR0D m0d(m_mg_maillage,m_mg_geometrie);
    affiche((char*)"Maillage 0D :");
    LISTE_MG_SOMMET::iterator it_sommet;
    for(MG_SOMMET* sommet=m_mg_geometrie->get_premier_sommet(it_sommet);sommet!=NULL;sommet=m_mg_geometrie->get_suivant_sommet(it_sommet))
    {
      if(sommet->get_lien_maillage()->get_nb()>0) continue;
      char message[1000];
      sprintf(message,"[%4li/%li] Maillage du sommet id %li",i,nb,sommet->get_id());
      affiche(message);
      if(m0d.maille(sommet)==FAIL) return FAIL;
      i++;
    }
  }
  if(Niveau>=1)
  {
    long i=1;
    long nb=m_mg_geometrie->get_nb_mg_arete();
    MAILLEUR1D m1d(m_mg_maillage,m_mg_geometrie,carte);
    affiche((char*)"Maillage 1D :");
    m1d.active_affichage(fonc_affiche);  
    LISTE_MG_ARETE::iterator it_arete;
    for(MG_ARETE* arete=m_mg_geometrie->get_premier_arete(it_arete);arete!=NULL;arete=m_mg_geometrie->get_suivant_arete(it_arete))
    {
      if(arete->get_lien_maillage()->get_nb()>0) continue;
      char message[1000];
      sprintf(message,"[%4li/%li] Maillage de l'arete id %li",i,nb,arete->get_id());
      affiche(message);
      if(m1d.maille(arete)==FAIL) return FAIL;
      i++;
    }
  }
  if(Niveau>=2)
  {
    long i=1;
    long nb=m_mg_geometrie->get_nb_mg_face();
    MAILLEUR2D m2d(m_mg_maillage,m_mg_geometrie,carte);
    m2d.change_niveau_optimisation(Niveau_opt_2d);
    m2d.change_priorite_metrique(Priorite_metrique);
    affiche((char*)"Maillage 2D :");
    m2d.active_affichage(fonc_affiche);
    LISTE_MG_FACE::iterator it_face;
    for(MG_FACE* face=m_mg_geometrie->get_premier_face(it_face);face!=NULL;face=m_mg_geometrie->get_suivant_face(it_face))
    {
      if(face->get_lien_maillage()->get_nb()>0) continue;
      char message[1000];
      sprintf(message,"[%4li/%li] Maillage de la face id %li",i,nb,face->get_id());
      affiche(message);
      if(m2d.maille(face)==FAIL) return FAIL;
      i++;
    }
  }
  if(Niveau>=3)
  {
    long i=1;
    long nb=m_mg_geometrie->get_nb_mg_volume();
    MAILLEUR3D m3d(m_mg_maillage,m_mg_geometrie,carte,false);
    m3d.change_niveau_optimisation(Niveau_opt_3d);
    m3d.change_priorite_metrique(Priorite_metrique);
    affiche((char*)"Maillage 3D :");
    m3d.active_affichage(fonc_affiche);
    for(MG_VOLUME* volume=m_mg_geometrie->get_premier_volume(it_volume);volume!=NULL;volume=m_mg_geometrie->get_suivant_volume(it_volume))
    {
      if(volume->get_lien_maillage()->get_nb()>0) continue;
      if(volume->est_mince()) continue;
      char message[1000];
      sprintf(message,"[%4li/%li] Maillage du volume id %li",i,nb,volume->get_id());
      affiche(message);
      if(m3d.maille(volume)==FAIL) return FAIL;
      i++;
    }
  }
  ot_cpu.ajouter_etape((char*)"generation_maillage");
  double temps_generation_maillage;
  ot_cpu.get_etape((char*)"generation_maillage",temps_generation_maillage);
  change_temps_maillage(get_temps_maillage()+temps_generation_maillage);
  return OK;
}

int MSTRUCT_VES::generer_fem_maillage(OT_PARAMETRES *param)
{
  OT_CPU ot_cpu;
  ot_cpu.initialise();
  int Degre = (int)param->get_valeur((char*)"Degre");
  int Analyse = (int)param->get_valeur((char*)"Analyse");
  int Optimisation_num_noeud = (int)param->get_valeur((char*)"Optimisation_num_noeud");
  MAILLEUR_FEM mailleurfem;
  mailleurfem.active_affichage(fonc_affiche);
  m_fem_maillage = new FEM_MAILLAGE(m_mg_maillage->get_mg_geometrie(),m_mg_maillage,Degre);
  m_mg_gestionnaire->ajouter_fem_maillage(m_fem_maillage);
  change_fem_maillage(m_fem_maillage);  
  if(Optimisation_num_noeud) {if(mailleurfem.maille(m_fem_maillage,1)==FAIL) return FAIL;}
  else {if(mailleurfem.maille(m_fem_maillage,0)==FAIL) return FAIL;};
  if(Analyse) 
  {
    MAILLEUR_ANALYSE m3d(m_fem_maillage);
    m3d.active_affichage(fonc_affiche);
//     m3d.analyse();
  }
  ot_cpu.ajouter_etape((char*)"generation_fem_maillage");
  double temps_generation_fem_maillage;
  ot_cpu.get_etape((char*)"generation_fem_maillage",temps_generation_fem_maillage);
  change_temps_fem_maillage(get_temps_fem_maillage()+temps_generation_fem_maillage);
  return OK;
}

int MSTRUCT_VES::generer_etude(OT_PARAMETRES *param)
{
  OT_CPU ot_cpu;
  ot_cpu.initialise();
  BOITE_3D boite3D_ves = get_boite3d_ves();
  double eps = get_precision();
  int Type_etude = (int)param->get_valeur((char*)"Type_etude");
  int Type_Chargement = (int)param->get_valeur((char*)"Type_Chargement");
  int Type_CL = (int)param->get_valeur((char*)"Type_CL");
  double Valeur_CL = param->get_valeur((char*)"Valeur_CL");
  int Direction = (int)param->get_valeur((char*)"Direction");
  MSTRUCT_OUTILS::appliquer_conditions_limites(m_mg_geometrie,boite3D_ves,Type_etude,Type_CL,Type_Chargement,Valeur_CL,Direction,eps);
  ot_cpu.ajouter_etape((char*)"generation_etude");
  double temps_generation_etude;
  ot_cpu.get_etape((char*)"generation_etude",temps_generation_etude);
  change_temps_etude(get_temps_etude()+temps_generation_etude);
  return OK;
}

int MSTRUCT_VES::generer_calcul(OT_PARAMETRES *param,char* param_aster,std::string nom_etude)
{
  int Type_etude = (int)param->get_valeur((char*)"Type_etude");
  int Type_calcul;
  if(Type_etude==MSTRUCT::TYPE_ETUDE::MECANIQUE) Type_calcul=MAGIC::CALCUL_ASTER::ELASTIQUE;
  else if(Type_etude==MSTRUCT::TYPE_ETUDE::THERMIQUE) Type_calcul=MAGIC::CALCUL_ASTER::THERMIQUE;
  std::string Code_resu = param->get_nom((char*)"Code_resu");  
  MGASTER mgaster;
  mgaster.active_affichage(fonc_affiche);
  OT_CPU ot_cpu;
  ot_cpu.initialise();
  mgaster.calcule(param_aster,m_fem_maillage,(char*)nom_etude.c_str(),Type_calcul,(char*)Code_resu.c_str());
  ot_cpu.ajouter_etape((char*)"calcul");
  double temps_calcul;
  ot_cpu.get_etape((char*)"calcul",temps_calcul);
  change_temps_calcul(get_temps_calcul()+temps_calcul);
}

int MSTRUCT_VES::generer_post_traitement(std::vector<OT_PARAMETRES *>& vector_params_post_traitement)
{
  OT_CPU ot_cpu;
  ot_cpu.initialise();
  std::vector<OT_PARAMETRES*>::iterator it;
  char ligne[1000];
  for(it=vector_params_post_traitement.begin();it!=vector_params_post_traitement.end();it++)
  {
    OT_PARAMETRES* param = *it;
    int Type_post_traitement = (int)param->get_valeur((char*)"Type_post_traitement");
    std::string Identifiant = param->get_nom((char*)"Identifiant");
    if(get_analyse(Identifiant)!=NULL)
    {
      std::cerr << "*** Analyse [" << Identifiant << "]  existante ***" << std::endl;
      continue;
    }
    sprintf(ligne,"-> %s",Identifiant.c_str());
    affiche(ligne);
    if(Type_post_traitement==MSTRUCT::TYPE_POST_TRAITEMENT::POST_CHAMP)
    {
      long Num_solution = (long)param->get_valeur((char*)"Num_solution");
      std::string Nom_groupe_forme = param->get_nom((char*)"Nom_groupe_forme");
      double Largeur_colonne_distribution = (double)param->get_valeur((char*)"Largeur_colonne_distribution");
      BOITE_3D *boite_3d_analyse=NULL;
      int Boite_analyse = (int)param->get_valeur((char*)"Boite_analyse");
      if(Boite_analyse)
      {
        double Xmin = (double)param->get_valeur((char*)"Boite3D_analyse_Xmin");
        double Ymin = (double)param->get_valeur((char*)"Boite3D_analyse_Ymin");
        double Zmin = (double)param->get_valeur((char*)"Boite3D_analyse_Zmin");
        double Xmax = (double)param->get_valeur((char*)"Boite3D_analyse_Xmax");
        double Ymax = (double)param->get_valeur((char*)"Boite3D_analyse_Ymax");
        double Zmax = (double)param->get_valeur((char*)"Boite3D_analyse_Zmax");
        boite_3d_analyse = new BOITE_3D(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax);
      }
      int Analyse_erosion = (int)param->get_valeur((char*)"Analyse_erosion");      
      FEM_SOLUTION* sol = m_mg_gestionnaire->get_fem_solution(Num_solution);
      int nb_champ = sol->get_nb_champ();
      MSTRUCT_ANALYSE_CHAMP* analyse_champ = new MSTRUCT_ANALYSE_CHAMP(this,Identifiant,sol->get_id(),nb_champ,Largeur_colonne_distribution,Nom_groupe_forme,boite_3d_analyse);
      if(Analyse_erosion)
      {
        long Nb_couche = (long)param->get_valeur((char*)"Nb_couche");
        double Epaisseur_couche = (double)param->get_valeur((char*)"Epaisseur_couche");
        MSTRUCT_ANALYSE_EROSION* analyse_erosion = new MSTRUCT_ANALYSE_EROSION(Identifiant,analyse_champ,Nb_couche,Epaisseur_couche);
        analyse_erosion->executer();
        ajouter_analyse(analyse_erosion);
      }
      else
      {
        analyse_champ->executer();
        ajouter_analyse(analyse_champ);
      }
      if(boite_3d_analyse!=NULL) delete boite_3d_analyse;      
    }
    else if(Type_post_traitement==MSTRUCT::TYPE_POST_TRAITEMENT::POST_ORIENTATION)
    {
      std::string Nom_groupe_forme = param->get_nom((char*)"Nom_groupe_forme");
      int Avec_fem_maillage = (int)param->get_valeur((char*)"Avec_fem_maillage");
      BOITE_3D *boite_3d_analyse=NULL;
      int Boite_analyse = (int)param->get_valeur((char*)"Boite_analyse");
      if(Boite_analyse)
      {
        double Xmin = (double)param->get_valeur((char*)"Boite3D_analyse_Xmin");
        double Ymin = (double)param->get_valeur((char*)"Boite3D_analyse_Ymin");
        double Zmin = (double)param->get_valeur((char*)"Boite3D_analyse_Zmin");
        double Xmax = (double)param->get_valeur((char*)"Boite3D_analyse_Xmax");
        double Ymax = (double)param->get_valeur((char*)"Boite3D_analyse_Ymax");
        double Zmax = (double)param->get_valeur((char*)"Boite3D_analyse_Zmax");
        boite_3d_analyse = new BOITE_3D(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax);
      }
      MSTRUCT_ANALYSE_ORIENTATION* analyse_orientation = new MSTRUCT_ANALYSE_ORIENTATION(this,Identifiant,Nom_groupe_forme,boite_3d_analyse,Avec_fem_maillage);
      int Analyse_erosion = (int)param->get_valeur((char*)"Analyse_erosion");  
      if(Analyse_erosion)
      {
        long Nb_couche = (long)param->get_valeur((char*)"Nb_couche");
        double Epaisseur_couche = (double)param->get_valeur((char*)"Epaisseur_couche");
        MSTRUCT_ANALYSE_EROSION* analyse_erosion = new MSTRUCT_ANALYSE_EROSION(Identifiant,analyse_orientation,Nb_couche,Epaisseur_couche);
        analyse_erosion->executer();
        ajouter_analyse(analyse_erosion);
      }
      else
      {
        analyse_orientation->executer();
        ajouter_analyse(analyse_orientation);
      }
      if(boite_3d_analyse!=NULL) delete boite_3d_analyse;      
    }
    else if(Type_post_traitement==MSTRUCT::TYPE_POST_TRAITEMENT::POST_CAO)
    {
      std::string Nom_groupe_forme = param->get_nom((char*)"Nom_groupe_forme");
      double Largeur_colonne_distribution_volume_forme = (double)param->get_valeur((char*)"Largeur_colonne_distribution_volume_forme");
      MSTRUCT_ANALYSE_CAO* analyse_cao = new MSTRUCT_ANALYSE_CAO(this,Identifiant,Largeur_colonne_distribution_volume_forme,Nom_groupe_forme);
      analyse_cao->executer();
      ajouter_analyse(analyse_cao);      
    }
    else if(Type_post_traitement==MSTRUCT::TYPE_POST_TRAITEMENT::POST_PROPRIETE_MASSIQUE)
    {
      std::string Nom_groupe_forme = param->get_nom((char*)"Nom_groupe_forme");
      MSTRUCT_ANALYSE_PROPRIETE_MASSIQUE* analyse_prop_mass = new MSTRUCT_ANALYSE_PROPRIETE_MASSIQUE(this,Identifiant,Nom_groupe_forme);
      analyse_prop_mass->executer();
      ajouter_analyse(analyse_prop_mass);      
    }
    else if(Type_post_traitement==MSTRUCT::TYPE_POST_TRAITEMENT::POST_MAILLAGE_MG)
    {
      std::string Nom_groupe_forme = param->get_nom((char*)"Nom_groupe_forme");
      double Largeur_colonne_distribution_qualite_2D = (double)param->get_valeur((char*)"Largeur_colonne_distribution_qualite_2D");
      double Largeur_colonne_distribution_qualite_3D = (double)param->get_valeur((char*)"Largeur_colonne_distribution_qualite_3D");
      double Largeur_colonne_distribution_taille_2D = (double)param->get_valeur((char*)"Largeur_colonne_distribution_taille_2D");
      double Largeur_colonne_distribution_taille_3D = (double)param->get_valeur((char*)"Largeur_colonne_distribution_taille_3D");
      BOITE_3D *boite_3d_analyse=NULL;
      int Boite_analyse = (int)param->get_valeur((char*)"Boite_analyse");
      if(Boite_analyse)
      {
        double Xmin = (double)param->get_valeur((char*)"Boite3D_analyse_Xmin");
        double Ymin = (double)param->get_valeur((char*)"Boite3D_analyse_Ymin");
        double Zmin = (double)param->get_valeur((char*)"Boite3D_analyse_Zmin");
        double Xmax = (double)param->get_valeur((char*)"Boite3D_analyse_Xmax");
        double Ymax = (double)param->get_valeur((char*)"Boite3D_analyse_Ymax");
        double Zmax = (double)param->get_valeur((char*)"Boite3D_analyse_Zmax");
        boite_3d_analyse = new BOITE_3D(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax);
      }
      MSTRUCT_ANALYSE_MG_MAILLAGE* analyse_mg_maillage = new MSTRUCT_ANALYSE_MG_MAILLAGE(this,
                                                                                         Identifiant,
                                                                                         m_mg_maillage->get_id(),
                                                                                         Largeur_colonne_distribution_qualite_2D,
                                                                                         Largeur_colonne_distribution_taille_2D,
                                                                                         Largeur_colonne_distribution_qualite_3D,
                                                                                         Largeur_colonne_distribution_taille_3D,
                                                                                         Nom_groupe_forme,boite_3d_analyse);
      int Analyse_erosion = (int)param->get_valeur((char*)"Analyse_erosion");  
      if(Analyse_erosion)
      {
        long Nb_couche = (long)param->get_valeur((char*)"Nb_couche");
        double Epaisseur_couche = (double)param->get_valeur((char*)"Epaisseur_couche");
        MSTRUCT_ANALYSE_EROSION* analyse_erosion = new MSTRUCT_ANALYSE_EROSION(Identifiant,analyse_mg_maillage,Nb_couche,Epaisseur_couche);
        analyse_erosion->executer();
        ajouter_analyse(analyse_erosion);
      }
      else
      {
        analyse_mg_maillage->executer();
        ajouter_analyse(analyse_mg_maillage);
      }
      if(boite_3d_analyse!=NULL) delete boite_3d_analyse; 
    }
    else if(Type_post_traitement==MSTRUCT::TYPE_POST_TRAITEMENT::POST_MAILLAGE_FEM)
    {
      std::string Nom_groupe_forme = param->get_nom((char*)"Nom_groupe_forme");
      double Largeur_colonne_distribution_jacobien_2D_min = (double)param->get_valeur((char*)"Largeur_colonne_distribution_jacobien_2D_min");
      double Largeur_colonne_distribution_jacobien_2D_max = (double)param->get_valeur((char*)"Largeur_colonne_distribution_jacobien_2D_max");
      double Largeur_colonne_distribution_jacobien_3D_min = (double)param->get_valeur((char*)"Largeur_colonne_distribution_jacobien_3D_min");
      double Largeur_colonne_distribution_jacobien_3D_max = (double)param->get_valeur((char*)"Largeur_colonne_distribution_jacobien_3D_max");
      double Largeur_colonne_distribution_distortion_2D = (double)param->get_valeur((char*)"Largeur_colonne_distribution_distortion_2D");
      double Largeur_colonne_distribution_distortion_3D = (double)param->get_valeur((char*)"Largeur_colonne_distribution_distortion_3D");
      BOITE_3D *boite_3d_analyse=NULL;
      int Boite_analyse = (int)param->get_valeur((char*)"Boite_analyse");
      if(Boite_analyse)
      {
        double Xmin = (double)param->get_valeur((char*)"Boite3D_analyse_Xmin");
        double Ymin = (double)param->get_valeur((char*)"Boite3D_analyse_Ymin");
        double Zmin = (double)param->get_valeur((char*)"Boite3D_analyse_Zmin");
        double Xmax = (double)param->get_valeur((char*)"Boite3D_analyse_Xmax");
        double Ymax = (double)param->get_valeur((char*)"Boite3D_analyse_Ymax");
        double Zmax = (double)param->get_valeur((char*)"Boite3D_analyse_Zmax");
        boite_3d_analyse = new BOITE_3D(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax);
      }
      MSTRUCT_ANALYSE_FEM_MAILLAGE* analyse_maillage_fem = new MSTRUCT_ANALYSE_FEM_MAILLAGE(this,
                                                                                            Identifiant,
                                                                                            m_fem_maillage->get_id(),
                                                                                            Largeur_colonne_distribution_jacobien_2D_min,
                                                                                            Largeur_colonne_distribution_jacobien_2D_max,
                                                                                            Largeur_colonne_distribution_jacobien_3D_min,
                                                                                            Largeur_colonne_distribution_jacobien_3D_max,
                                                                                            Largeur_colonne_distribution_distortion_2D,
                                                                                            Largeur_colonne_distribution_distortion_3D,
                                                                                            Nom_groupe_forme,
                                                                                            boite_3d_analyse);
      int Analyse_erosion = (int)param->get_valeur((char*)"Analyse_erosion");  
      if(Analyse_erosion)
      {
        long Nb_couche = (long)param->get_valeur((char*)"Nb_couche");
        double Epaisseur_couche = (double)param->get_valeur((char*)"Epaisseur_couche");
        MSTRUCT_ANALYSE_EROSION* analyse_erosion = new MSTRUCT_ANALYSE_EROSION(Identifiant,analyse_maillage_fem,Nb_couche,Epaisseur_couche);
        analyse_erosion->executer();
        ajouter_analyse(analyse_erosion);
      }
      else
      {
        analyse_maillage_fem->executer();
        ajouter_analyse(analyse_maillage_fem);
      }
      if(boite_3d_analyse!=NULL) delete boite_3d_analyse;      
    }
    else if(Type_post_traitement==MSTRUCT::TYPE_POST_TRAITEMENT::POST_CHAMP_NORMALISE)
    {
      std::string Identifiant_champ = param->get_nom((char*)"Identifiant_champ");
      std::string Identifiant_champ_reference = param->get_nom((char*)"Identifiant_champ_reference");
      double Largeur_colonne_distribution = (double)param->get_valeur((char*)"Largeur_colonne_distribution");
      if(get_analyse(Identifiant_champ)->get_type()==MSTRUCT::TYPE_ANALYSE::CHAMP)
      {
        MSTRUCT_ANALYSE_CHAMP* analyse_champ = (MSTRUCT_ANALYSE_CHAMP*)get_analyse(Identifiant_champ);
        MSTRUCT_ANALYSE_CHAMP* analyse_champ_reference = (MSTRUCT_ANALYSE_CHAMP*)get_analyse(Identifiant_champ_reference);
        double valeur_ref=0.0;
        int nb_champ=analyse_champ_reference->get_nb_champ();
        for(int i=0;i<nb_champ;i++)
        {
          valeur_ref+=analyse_champ_reference->get_moyenne()[i]*analyse_champ_reference->get_moyenne()[i];
        }
        valeur_ref=sqrt(valeur_ref);
//         for(int i=0;i<nb_champ;i++) if(abs(analyse_champ_reference->get_moyenne()[i])>valeur_ref) valeur_ref=abs(analyse_champ_reference->get_moyenne()[i]);
        MSTRUCT_ANALYSE_CHAMP* analyse_normalise = analyse_champ->normaliser(Identifiant,valeur_ref,Largeur_colonne_distribution);
        ajouter_analyse(analyse_normalise);
      }
      else if(get_analyse(Identifiant_champ)->get_type()==MSTRUCT::TYPE_ANALYSE::EROSION)
      {
        MSTRUCT_ANALYSE_EROSION* analyse_erosion_champ = (MSTRUCT_ANALYSE_EROSION*)get_analyse(Identifiant_champ);
        double epaisseur_couche = analyse_erosion_champ->get_epaisseur_couche();
        std::string Nom_groupe_forme = analyse_erosion_champ->get_nom_groupe_forme();
        BOITE_3D *boite_3d_analyse=analyse_erosion_champ->get_boite_analyse();
        MSTRUCT_ANALYSE_EROSION* analyse_erosion_normalise = new MSTRUCT_ANALYSE_EROSION(Identifiant,epaisseur_couche,Nom_groupe_forme,boite_3d_analyse);
        std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse_erosion;
        int k=0;
        double valeur_ref=0.0;
        for(MSTRUCT_ANALYSE* analyse=analyse_erosion_champ->get_premiere_analyse(it_analyse_erosion);analyse!=NULL;analyse=analyse_erosion_champ->get_suivante_analyse(it_analyse_erosion))
        {
          if(k==0)
          {
            std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse_erosion_reference;
            MSTRUCT_ANALYSE_EROSION* analyse_erosion_champ_reference = (MSTRUCT_ANALYSE_EROSION*)get_analyse(Identifiant_champ_reference);
            MSTRUCT_ANALYSE_CHAMP* analyse_champ_reference = (MSTRUCT_ANALYSE_CHAMP*)analyse_erosion_champ_reference->get_premiere_analyse(it_analyse_erosion_reference);
            int nb_champ=analyse_champ_reference->get_nb_champ();
            for(int i=0;i<nb_champ;i++) if(abs(analyse_champ_reference->get_moyenne()[i])>valeur_ref) valeur_ref=abs(analyse_champ_reference->get_moyenne()[i]);
          }
          MSTRUCT_ANALYSE_CHAMP* analyse_champ = (MSTRUCT_ANALYSE_CHAMP*)analyse;
          MSTRUCT_ANALYSE_CHAMP* analyse_normalise = analyse_champ->normaliser(Identifiant,valeur_ref,Largeur_colonne_distribution);
          analyse_erosion_normalise->ajouter_analyse(analyse_normalise);
          k++;
        }
        ajouter_analyse(analyse_erosion_normalise);
      }      
    }
    else if(Type_post_traitement==MSTRUCT::TYPE_POST_TRAITEMENT::POST_CHAMP_ECART)
    {
      std::string Identifiant_champ = param->get_nom((char*)"Identifiant_champ");
      if(get_analyse(Identifiant_champ)==NULL)
      {
        std::cerr << "*** Analyse [" << Identifiant << "]  inexistante ***" << std::endl;
        return FAIL;
      }
      std::string Identifiant_champ_compare = param->get_nom((char*)"Identifiant_champ_compare");
      if(get_analyse(Identifiant_champ_compare)==NULL)
      {
        std::cerr << "*** Analyse [" << Identifiant << "]  inexistante ***" << std::endl;
        return FAIL;
      }
      double Largeur_colonne_distribution = (double)param->get_valeur((char*)"Largeur_colonne_distribution");
      int Type_ecart = (int)param->get_valeur((char*)"Type_ecart");
      if(get_analyse(Identifiant_champ)->get_type()==MSTRUCT::TYPE_ANALYSE::CHAMP)
      {
        MSTRUCT_ANALYSE_CHAMP* analyse_champ = (MSTRUCT_ANALYSE_CHAMP*)get_analyse(Identifiant_champ);
        MSTRUCT_ANALYSE* analyse_compare = get_analyse(Identifiant_champ_compare);
        if(analyse_compare->get_type()==MSTRUCT::TYPE_ANALYSE::CHAMP)
        {
          MSTRUCT_ANALYSE_CHAMP* analyse_champ_compare = (MSTRUCT_ANALYSE_CHAMP*)analyse_compare;
          MSTRUCT_ANALYSE_CHAMP* analyse_ecart = analyse_champ->calculer_ecart(Identifiant,Largeur_colonne_distribution,analyse_champ_compare,Type_ecart);
          ajouter_analyse(analyse_ecart);        
        }
        else if(analyse_compare->get_type()==MSTRUCT::TYPE_ANALYSE::EROSION)
        {
          MSTRUCT_ANALYSE_EROSION* analyse_erosion_compare = (MSTRUCT_ANALYSE_EROSION*)analyse_compare;
          int Num_couche = (int)param->get_valeur((char*)"Num_couche");
          if(Num_couche>=0)
          {
            MSTRUCT_ANALYSE_CHAMP* analyse_champ_compare=(MSTRUCT_ANALYSE_CHAMP*)analyse_erosion_compare->get_analyse(Num_couche);
            MSTRUCT_ANALYSE_CHAMP* analyse_ecart = analyse_champ->calculer_ecart(Identifiant,Largeur_colonne_distribution,analyse_champ_compare,Type_ecart);
            ajouter_analyse(analyse_ecart);
          }
          else
          {
            double epaisseur_couche = analyse_erosion_compare->get_epaisseur_couche();
            std::string Nom_groupe_forme = analyse_erosion_compare->get_nom_groupe_forme();
            BOITE_3D *boite_3d_analyse=analyse_erosion_compare->get_boite_analyse();
            MSTRUCT_ANALYSE_EROSION* analyse_erosion_ecart = new MSTRUCT_ANALYSE_EROSION(Identifiant,epaisseur_couche,Nom_groupe_forme,boite_3d_analyse);
            std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse_erosion;
            for(MSTRUCT_ANALYSE* analyse_champ_compare=analyse_erosion_compare->get_premiere_analyse(it_analyse_erosion);analyse_champ_compare!=NULL;analyse_champ_compare=analyse_erosion_compare->get_suivante_analyse(it_analyse_erosion))
            {
              MSTRUCT_ANALYSE_CHAMP* analyse_ecart = analyse_champ->calculer_ecart(Identifiant,Largeur_colonne_distribution,(MSTRUCT_ANALYSE_CHAMP*)analyse_champ_compare,Type_ecart);
              analyse_erosion_ecart->ajouter_analyse(analyse_ecart);
            }
            ajouter_analyse(analyse_erosion_ecart);
          }
             
        }
      }
      else if(get_analyse(Identifiant_champ)->get_type()==MSTRUCT::TYPE_ANALYSE::EROSION)
      {
        MSTRUCT_ANALYSE_EROSION* analyse_erosion_champ = (MSTRUCT_ANALYSE_EROSION*)get_analyse(Identifiant_champ);
        double epaisseur_couche = analyse_erosion_champ->get_epaisseur_couche();
        std::string Nom_groupe_forme = analyse_erosion_champ->get_nom_groupe_forme();
        BOITE_3D *boite_3d_analyse=analyse_erosion_champ->get_boite_analyse();
        MSTRUCT_ANALYSE_EROSION* analyse_erosion_ecart = new MSTRUCT_ANALYSE_EROSION(Identifiant,epaisseur_couche,Nom_groupe_forme,boite_3d_analyse);
        std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse_erosion;
        for(MSTRUCT_ANALYSE* analyse=analyse_erosion_champ->get_premiere_analyse(it_analyse_erosion);analyse!=NULL;analyse=analyse_erosion_champ->get_suivante_analyse(it_analyse_erosion))
        {
          MSTRUCT_ANALYSE_CHAMP* analyse_champ = (MSTRUCT_ANALYSE_CHAMP*)analyse;
          MSTRUCT_ANALYSE* analyse_compare = get_analyse(Identifiant_champ_compare);
          if(analyse_compare->get_type()==MSTRUCT::TYPE_ANALYSE::CHAMP)
          {
            MSTRUCT_ANALYSE_CHAMP* analyse_champ_compare = (MSTRUCT_ANALYSE_CHAMP*)analyse_compare;
            MSTRUCT_ANALYSE_CHAMP* analyse_ecart = analyse_champ->calculer_ecart(Identifiant,Largeur_colonne_distribution,analyse_champ_compare,Type_ecart);
            analyse_erosion_ecart->ajouter_analyse(analyse_ecart);
          }
          else if(analyse_compare->get_type()==MSTRUCT::TYPE_ANALYSE::EROSION)
          {
            MSTRUCT_ANALYSE_EROSION* analyse_erosion_compare = (MSTRUCT_ANALYSE_EROSION*)analyse_compare;
            int Num_couche = (int)param->get_valeur((char*)"Num_couche");
            if(Num_couche>=0)
            {
              MSTRUCT_ANALYSE_CHAMP* analyse_champ_compare=(MSTRUCT_ANALYSE_CHAMP*)analyse_erosion_compare->get_analyse(Num_couche);
              MSTRUCT_ANALYSE_CHAMP* analyse_ecart = analyse_champ->calculer_ecart(Identifiant,Largeur_colonne_distribution,analyse_champ_compare,Type_ecart);
              analyse_erosion_ecart->ajouter_analyse(analyse_ecart);
            }
            else
            {
              
            }
            
          }
        }
        ajouter_analyse(analyse_erosion_ecart);
      }
    }
    else if(Type_post_traitement==MSTRUCT::TYPE_POST_TRAITEMENT::POST_CHAMP_ECART_CHARGEMENT)
    {
      std::string Identifiant_champ = param->get_nom((char*)"Identifiant_champ");
      if(get_analyse(Identifiant_champ)==NULL)
      {
        std::cerr << "*** Analyse [" << Identifiant << "]  inexistante ***" << std::endl;
        return FAIL;
      }
      double Largeur_colonne_distribution = (double)param->get_valeur((char*)"Largeur_colonne_distribution");
      int Type_chargement = (int)param->get_valeur((char*)"Type_chargement");
      int Type_ecart = (int)param->get_valeur((char*)"Type_ecart");
      if(get_analyse(Identifiant_champ)->get_type()==MSTRUCT::TYPE_ANALYSE::CHAMP)
      {
        MSTRUCT_ANALYSE_CHAMP* analyse_champ = (MSTRUCT_ANALYSE_CHAMP*)get_analyse(Identifiant_champ);
        MSTRUCT_ANALYSE_CHAMP* analyse_ecart = analyse_champ->calculer_ecart_chargement(Identifiant,Largeur_colonne_distribution,Type_chargement,Type_ecart);
        ajouter_analyse(analyse_ecart);
      }
      else if(get_analyse(Identifiant_champ)->get_type()==MSTRUCT::TYPE_ANALYSE::EROSION)
      {
        MSTRUCT_ANALYSE_EROSION* analyse_erosion_champ = (MSTRUCT_ANALYSE_EROSION*)get_analyse(Identifiant_champ);
        double epaisseur_couche = analyse_erosion_champ->get_epaisseur_couche();
        std::string Nom_groupe_forme = analyse_erosion_champ->get_nom_groupe_forme();
        BOITE_3D *boite_3d_analyse=analyse_erosion_champ->get_boite_analyse();
        MSTRUCT_ANALYSE_EROSION* analyse_erosion_ecart = new MSTRUCT_ANALYSE_EROSION(Identifiant,epaisseur_couche,Nom_groupe_forme,boite_3d_analyse);
        std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse_erosion;
        for(MSTRUCT_ANALYSE* analyse=analyse_erosion_champ->get_premiere_analyse(it_analyse_erosion);analyse!=NULL;analyse=analyse_erosion_champ->get_suivante_analyse(it_analyse_erosion))
        {
          MSTRUCT_ANALYSE_CHAMP* analyse_champ = (MSTRUCT_ANALYSE_CHAMP*)analyse;
          MSTRUCT_ANALYSE_CHAMP* analyse_ecart = analyse_champ->calculer_ecart_chargement(Identifiant,Largeur_colonne_distribution,Type_chargement,Type_ecart);
          analyse_erosion_ecart->ajouter_analyse(analyse_ecart);
        }
        ajouter_analyse(analyse_erosion_ecart);
      }
    }
    else if(Type_post_traitement==MSTRUCT::TYPE_POST_TRAITEMENT::POST_ORIENTATION_ECART)
    {
      std::string Identifiant_orientation = param->get_nom((char*)"Identifiant_orientation");
      if(get_analyse(Identifiant_orientation)==NULL)
      {
        std::cerr << "*** Analyse [" << Identifiant << "]  inexistante ***" << std::endl;
        return FAIL;
      }
      int Type_ecart = (int)param->get_valeur((char*)"Type_ecart");
      double tenseur_compare[6];
      tenseur_compare[0] = (double)param->get_valeur((char*)"a_11");
      tenseur_compare[1] = (double)param->get_valeur((char*)"a_22");
      tenseur_compare[2] = (double)param->get_valeur((char*)"a_33");
      tenseur_compare[3] = (double)param->get_valeur((char*)"a_12");
      tenseur_compare[4] = (double)param->get_valeur((char*)"a_23");
      tenseur_compare[5] = (double)param->get_valeur((char*)"a_13");
      if(get_analyse(Identifiant_orientation)->get_type()==MSTRUCT::TYPE_ANALYSE::ORIENTATION)
      {
        MSTRUCT_ANALYSE_ORIENTATION* analyse_orientation = (MSTRUCT_ANALYSE_ORIENTATION*)get_analyse(Identifiant_orientation);
        MSTRUCT_ANALYSE_ORIENTATION* analyse_compare = analyse_orientation->calculer_ecart(Identifiant,tenseur_compare,Type_ecart);        
        ajouter_analyse(analyse_compare);
      }
      else if(get_analyse(Identifiant_orientation)->get_type()==MSTRUCT::TYPE_ANALYSE::EROSION)
      {
        MSTRUCT_ANALYSE_EROSION* analyse_erosion_orientation = (MSTRUCT_ANALYSE_EROSION*)get_analyse(Identifiant_orientation);
        double epaisseur_couche = analyse_erosion_orientation->get_epaisseur_couche();
        std::string Nom_groupe_forme = analyse_erosion_orientation->get_nom_groupe_forme();
        BOITE_3D *boite_3d_analyse=analyse_erosion_orientation->get_boite_analyse();
        MSTRUCT_ANALYSE_EROSION* analyse_erosion_ecart = new MSTRUCT_ANALYSE_EROSION(Identifiant,epaisseur_couche,Nom_groupe_forme,boite_3d_analyse);
        std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse_erosion;
        for(MSTRUCT_ANALYSE* analyse=analyse_erosion_orientation->get_premiere_analyse(it_analyse_erosion);analyse!=NULL;analyse=analyse_erosion_orientation->get_suivante_analyse(it_analyse_erosion))
        {
          MSTRUCT_ANALYSE_ORIENTATION* analyse_orientation = (MSTRUCT_ANALYSE_ORIENTATION*)analyse;
          MSTRUCT_ANALYSE_ORIENTATION* analyse_compare = analyse_orientation->calculer_ecart(Identifiant,tenseur_compare,Type_ecart);        
          analyse_erosion_ecart->ajouter_analyse(analyse_compare);
        }
        ajouter_analyse(analyse_erosion_ecart);
      }
    }
    else if(Type_post_traitement==MSTRUCT::TYPE_POST_TRAITEMENT::POST_CONDUCTIVITE_THERMIQUE)
    {
      long Num_solution_temp=(long)param->get_valeur((char*)"Num_solution_temp");
      long Num_solution_flux=(long)param->get_valeur((char*)"Num_solution_flux");
      int Direction=(int)param->get_valeur((char*)"Direction");
      BOITE_3D *boite_3d_analyse=NULL;
      int Boite_analyse = (int)param->get_valeur((char*)"Boite_analyse");
      if(Boite_analyse)
      {
        double Xmin = (double)param->get_valeur((char*)"Boite3D_analyse_Xmin");
        double Ymin = (double)param->get_valeur((char*)"Boite3D_analyse_Ymin");
        double Zmin = (double)param->get_valeur((char*)"Boite3D_analyse_Zmin");
        double Xmax = (double)param->get_valeur((char*)"Boite3D_analyse_Xmax");
        double Ymax = (double)param->get_valeur((char*)"Boite3D_analyse_Ymax");
        double Zmax = (double)param->get_valeur((char*)"Boite3D_analyse_Zmax");
        boite_3d_analyse = new BOITE_3D(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax);
      }
      int Analyse_erosion = (int)param->get_valeur((char*)"Analyse_erosion");
      FEM_SOLUTION * fem_sol_temp=get_mg_gestionnaire()->get_fem_solution(Num_solution_temp);
      FEM_SOLUTION * fem_sol_flux=get_mg_gestionnaire()->get_fem_solution(Num_solution_flux);
      MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE* analyse_cond_ther = new MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE(this,Identifiant,fem_sol_temp->get_id(),fem_sol_flux->get_id(),Direction,boite_3d_analyse);
      if(Analyse_erosion)
      {
        long Nb_couche = (long)param->get_valeur((char*)"Nb_couche");
        double Epaisseur_couche = (double)param->get_valeur((char*)"Epaisseur_couche");
        MSTRUCT_ANALYSE_EROSION* analyse_erosion = new MSTRUCT_ANALYSE_EROSION(Identifiant,analyse_cond_ther,Nb_couche,Epaisseur_couche);
        analyse_erosion->executer();
        ajouter_analyse(analyse_erosion);
      }
      else
      {
        analyse_cond_ther->executer();
        ajouter_analyse(analyse_cond_ther);
      }
      if(boite_3d_analyse!=NULL) delete boite_3d_analyse;  
    }
    else if(Type_post_traitement==MSTRUCT::TYPE_POST_TRAITEMENT::POST_TEMPS)
    {
      
    }
    else
    {
      sprintf(ligne,"ERREUR -> %s",Identifiant.c_str());
      affiche(ligne);
    }
  }
  ot_cpu.ajouter_etape((char*)"analyse");
  double temps_analyse;
  ot_cpu.get_etape((char*)"analyse",temps_analyse);
  change_temps_analyse(get_temps_analyse()+temps_analyse);
}

int MSTRUCT_VES::generer_post_traitement(std::vector<OT_PARAMETRES *>& vector_params_post_traitement,
                                         MSTRUCT_VES_FILE* ves_sph,
                                         MSTRUCT_VES_FILE* ves_dev)
{
  OT_CPU ot_cpu;
  ot_cpu.initialise();
  std::vector<OT_PARAMETRES*>::iterator it;
  char ligne[1000];
  for(it=vector_params_post_traitement.begin();it!=vector_params_post_traitement.end();it++)
  {
    OT_PARAMETRES* param = *it;
    int Type_post_traitement = (int)param->get_valeur((char*)"Type_post_traitement");
    std::string Identifiant = param->get_nom((char*)"Identifiant");
    if(get_analyse(Identifiant)!=NULL)
    {
      std::cerr << "*** Analyse [" << Identifiant << "]  existante ***" << std::endl;
      return FAIL;
    }
    sprintf(ligne,"-> %s",Identifiant.c_str());
    affiche(ligne);
    if(Type_post_traitement==MSTRUCT::TYPE_POST_TRAITEMENT::POST_MODULES_ELASTICITE)
    {
      std::string Identifiant_epsilon = param->get_nom((char*)"Identifiant_epsilon");
      std::string Identifiant_sigma = param->get_nom((char*)"Identifiant_sigma");
      if(ves_sph->get_analyse(Identifiant_epsilon)->get_type()==MSTRUCT::TYPE_ANALYSE::CHAMP)
      {
        MSTRUCT_ANALYSE_CHAMP* epsilon_sph = (MSTRUCT_ANALYSE_CHAMP*)ves_sph->get_analyse(Identifiant_epsilon);
        MSTRUCT_ANALYSE_CHAMP* sigma_sph = (MSTRUCT_ANALYSE_CHAMP*)ves_sph->get_analyse(Identifiant_sigma);
        MSTRUCT_ANALYSE_CHAMP* epsilon_dev = (MSTRUCT_ANALYSE_CHAMP*)ves_dev->get_analyse(Identifiant_epsilon);
        MSTRUCT_ANALYSE_CHAMP* sigma_dev = (MSTRUCT_ANALYSE_CHAMP*)ves_dev->get_analyse(Identifiant_sigma);
        MSTRUCT_ANALYSE_MODULES_ELASTICITE* analyse_modules_elasticite = new MSTRUCT_ANALYSE_MODULES_ELASTICITE(Identifiant,epsilon_sph,sigma_sph,epsilon_dev,sigma_dev);
        analyse_modules_elasticite->executer();
        ajouter_analyse(analyse_modules_elasticite);
      }
      else if(ves_sph->get_analyse(Identifiant_epsilon)->get_type()==MSTRUCT::TYPE_ANALYSE::EROSION)
      {
        MSTRUCT_ANALYSE_EROSION* epsilon_sph_erosion = (MSTRUCT_ANALYSE_EROSION*)ves_sph->get_analyse(Identifiant_epsilon);
        MSTRUCT_ANALYSE_EROSION* sigma_sph_erosion = (MSTRUCT_ANALYSE_EROSION*)ves_sph->get_analyse(Identifiant_sigma);
        MSTRUCT_ANALYSE_EROSION* epsilon_dev_erosion = (MSTRUCT_ANALYSE_EROSION*)ves_dev->get_analyse(Identifiant_epsilon);
        MSTRUCT_ANALYSE_EROSION* sigma_dev_erosion = (MSTRUCT_ANALYSE_EROSION*)ves_dev->get_analyse(Identifiant_sigma);        
        long Nb_couche = epsilon_sph_erosion->get_nb_analyse();
        double Epaisseur_couche = epsilon_sph_erosion->get_epaisseur_couche();
        std::string Nom_groupe_forme = epsilon_sph_erosion->get_nom_groupe_forme();
        BOITE_3D *boite_3d_analyse=epsilon_sph_erosion->get_boite_analyse();
        MSTRUCT_ANALYSE_EROSION* analyse_modules_elasticite_erosion = new MSTRUCT_ANALYSE_EROSION(Identifiant,Epaisseur_couche,Nom_groupe_forme,boite_3d_analyse);
        for(int i=0;i<Nb_couche;i++)
        {
          MSTRUCT_ANALYSE_MODULES_ELASTICITE* analyse_modules_elasticite = new MSTRUCT_ANALYSE_MODULES_ELASTICITE(Identifiant,
                                                                                                                  (MSTRUCT_ANALYSE_CHAMP*)epsilon_sph_erosion->get_analyse(i),
                                                                                                                  (MSTRUCT_ANALYSE_CHAMP*)sigma_sph_erosion->get_analyse(i),
                                                                                                                  (MSTRUCT_ANALYSE_CHAMP*)epsilon_dev_erosion->get_analyse(i),
                                                                                                                  (MSTRUCT_ANALYSE_CHAMP*)sigma_dev_erosion->get_analyse(i));
          analyse_modules_elasticite->executer();
          analyse_modules_elasticite_erosion->ajouter_analyse(analyse_modules_elasticite);
        }
        ajouter_analyse(analyse_modules_elasticite_erosion);
      }
    }
    else
    {
      sprintf(ligne,"ERREUR -> %s",Identifiant.c_str());
      affiche(ligne);
    }
  }
  ot_cpu.ajouter_etape((char*)"analyse");
  double temps_analyse;
  ot_cpu.get_etape((char*)"analyse",temps_analyse);
  change_temps_analyse(get_temps_analyse()+temps_analyse);
}

int MSTRUCT_VES::generer_post_traitement(std::vector<OT_PARAMETRES *>& vector_params_post_traitement,
                                         MSTRUCT_VES_FILE* ves_lambda_x,
                                         MSTRUCT_VES_FILE* ves_lambda_y,
                                         MSTRUCT_VES_FILE* ves_lambda_z)
{
  OT_CPU ot_cpu;
  ot_cpu.initialise();
  std::vector<OT_PARAMETRES*>::iterator it;
  char ligne[1000];
  for(it=vector_params_post_traitement.begin();it!=vector_params_post_traitement.end();it++)
  {
    OT_PARAMETRES* param = *it;
    int Type_post_traitement = (int)param->get_valeur((char*)"Type_post_traitement");
    std::string Identifiant = param->get_nom((char*)"Identifiant");
    if(get_analyse(Identifiant)!=NULL)
    {
      std::cerr << "*** Analyse [" << Identifiant << "]  existante ***" << std::endl;
      return FAIL;
    }
    sprintf(ligne,"-> %s",Identifiant.c_str());
    affiche(ligne);
    if(Type_post_traitement==MSTRUCT::TYPE_POST_TRAITEMENT::POST_CONDUCTIVITE_THERMIQUE)
    {
      std::string Identifiant = param->get_nom((char*)"Identifiant");
      if(ves_lambda_x->get_analyse(Identifiant)->get_type()==MSTRUCT::TYPE_ANALYSE::EROSION &&
         ves_lambda_y->get_analyse(Identifiant)->get_type()==MSTRUCT::TYPE_ANALYSE::EROSION &&
         ves_lambda_z->get_analyse(Identifiant)->get_type()==MSTRUCT::TYPE_ANALYSE::EROSION)
      {
        MSTRUCT_ANALYSE_EROSION* erosion_lambda_x = (MSTRUCT_ANALYSE_EROSION*)ves_lambda_x->get_analyse(Identifiant);
        MSTRUCT_ANALYSE_EROSION* erosion_lambda_y = (MSTRUCT_ANALYSE_EROSION*)ves_lambda_y->get_analyse(Identifiant);
        MSTRUCT_ANALYSE_EROSION* erosion_lambda_z = (MSTRUCT_ANALYSE_EROSION*)ves_lambda_z->get_analyse(Identifiant);
        std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse_x;
        std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse_y;
        std::vector<MSTRUCT_ANALYSE*>::iterator it_analyse_z;
        MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE* analyse_lambda_x=(MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE*)erosion_lambda_x->get_premiere_analyse(it_analyse_x);
        MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE* analyse_lambda_y=(MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE*)erosion_lambda_y->get_premiere_analyse(it_analyse_y);
        MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE* analyse_lambda_z=(MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE*)erosion_lambda_z->get_premiere_analyse(it_analyse_z);
        MSTRUCT_ANALYSE_EROSION* erosion_lambda_app = new MSTRUCT_ANALYSE_EROSION(Identifiant,
                                                                                  erosion_lambda_x->get_epaisseur_couche(),
                                                                                  erosion_lambda_x->get_nom_groupe_forme(),
                                                                                  erosion_lambda_x->get_boite_analyse());
        while(analyse_lambda_x!=NULL && analyse_lambda_y!=NULL && analyse_lambda_z!=NULL)
        {
          MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE* analyse_lambda_app = new MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE(Identifiant,analyse_lambda_x,analyse_lambda_y,analyse_lambda_z);
          analyse_lambda_app->executer();
          erosion_lambda_app->ajouter_analyse(analyse_lambda_app);
          analyse_lambda_x=(MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE*)erosion_lambda_x->get_suivante_analyse(it_analyse_x);
          analyse_lambda_y=(MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE*)erosion_lambda_y->get_suivante_analyse(it_analyse_y);
          analyse_lambda_z=(MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE*)erosion_lambda_z->get_suivante_analyse(it_analyse_z);
        }
        ajouter_analyse(erosion_lambda_app);
      }
      if(ves_lambda_x->get_analyse(Identifiant)->get_type()==MSTRUCT::TYPE_ANALYSE::CONDUCTIVITE_THERMIQUE &&
         ves_lambda_y->get_analyse(Identifiant)->get_type()==MSTRUCT::TYPE_ANALYSE::CONDUCTIVITE_THERMIQUE &&
         ves_lambda_z->get_analyse(Identifiant)->get_type()==MSTRUCT::TYPE_ANALYSE::CONDUCTIVITE_THERMIQUE)
      {
        MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE* analyse_lambda_x=(MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE*)ves_lambda_x->get_analyse(Identifiant);
        MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE* analyse_lambda_y=(MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE*)ves_lambda_y->get_analyse(Identifiant);
        MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE* analyse_lambda_z=(MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE*)ves_lambda_z->get_analyse(Identifiant);
        MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE* analyse_lambda_app = new MSTRUCT_ANALYSE_CONDUCTIVITE_THERMIQUE(Identifiant,analyse_lambda_x,analyse_lambda_y,analyse_lambda_z);
        analyse_lambda_app->executer();
        ajouter_analyse(analyse_lambda_app);
      }      
    }
    else
    {
      sprintf(ligne,"ERREUR -> %s",Identifiant.c_str());
      affiche(ligne);
    }
  }
  ot_cpu.ajouter_etape((char*)"analyse");
  double temps_analyse;
  ot_cpu.get_etape((char*)"analyse",temps_analyse);
  change_temps_analyse(get_temps_analyse()+temps_analyse);
}


int MSTRUCT_VES::exporter_maillage_abaqus(char* dossier)
{
  std::ofstream f;
  char file[1000];
  sprintf(file,"%s/noeuds",dossier);
  f.open(file,std::ios::out);
  f.precision(16);
  f.setf(std::ios::showpoint);
  f << "*NODE"<< std::endl;
  LISTE_FEM_NOEUD::iterator  it;
  long index=1;
  for (FEM_NOEUD* noeud=m_fem_maillage->get_premier_noeud(it);noeud;noeud=m_fem_maillage->get_suivant_noeud(it))
  {
      noeud->change_numero(index);
      double *coord=noeud->get_coord();
      f << noeud->get_numero() <<  ", " << coord[0] <<  ", " << coord[1] <<  ", " << coord[2] << std::endl;
      index++;
  }
  f.close();
  sprintf(file,"%s/elements",dossier);
  f.open(file,std::ios::out);
  f.precision(16);
  f.setf(std::ios::showpoint);
  index=1;
  LISTE_FEM_ELEMENT3::iterator ittele3;
  bool tetralin=false;  
  for (FEM_ELEMENT3* ele3=m_fem_maillage->get_premier_element3(ittele3);ele3;ele3=m_fem_maillage->get_suivant_element3(ittele3))
  {
    if(ele3->get_type_entite()==IDFEM_TETRA4)
    {
      if(tetralin==false)
      {
        tetralin=true;
        f << "*ELEMENT,TYPE=C3D4,ELSET=tetralin"<< std::endl;
      }
      f << index << ", " 
        << ele3->get_fem_noeud(0)->get_numero() << ", " 
        << ele3->get_fem_noeud(1)->get_numero() << ", " 
        << ele3->get_fem_noeud(2)->get_numero() << ", " 
        << ele3->get_fem_noeud(3)->get_numero() << std::endl;
      ele3->change_numero(index);
      index++;
    }
  }
  bool pentalin=false;
  for (FEM_ELEMENT3* ele3=m_fem_maillage->get_premier_element3(ittele3);ele3;ele3=m_fem_maillage->get_suivant_element3(ittele3))
  {
    if(ele3->get_type_entite()==IDFEM_PENTA6)
    {
      if(pentalin==false)
      {
        pentalin=true;
        f << "*ELEMENT,TYPE=C3D6,ELSET=pentalin"<< std::endl;
      }
      f << index << ", " 
        << ele3->get_fem_noeud(0)->get_numero() << ", " 
        << ele3->get_fem_noeud(1)->get_numero() << ", " 
        << ele3->get_fem_noeud(2)->get_numero() << ", " 
        << ele3->get_fem_noeud(3)->get_numero() << ", " 
        << ele3->get_fem_noeud(4)->get_numero() << ", " 
        << ele3->get_fem_noeud(5)->get_numero() << std::endl;
      ele3->change_numero(index);
      index++;
    }
  }
  bool tetraquad=false;
  for (FEM_ELEMENT3* ele3=m_fem_maillage->get_premier_element3(ittele3);ele3;ele3=m_fem_maillage->get_suivant_element3(ittele3))
  {
    if(ele3->get_type_entite()==IDFEM_TETRA10)
    {
      if(tetraquad==false)
      {
        tetraquad=true;
        f << "*ELEMENT,TYPE=C3D10,ELSET=tetraquad"<< std::endl;
      }
      f << index << ", "        
        << ele3->get_fem_noeud(0)->get_numero() << ", " 
        << ele3->get_fem_noeud(2)->get_numero() << ", " 
        << ele3->get_fem_noeud(4)->get_numero() << ", " 
        << ele3->get_fem_noeud(9)->get_numero() << ", " 
        << ele3->get_fem_noeud(1)->get_numero() << ", " 
        << ele3->get_fem_noeud(3)->get_numero() << ", " 
        << ele3->get_fem_noeud(5)->get_numero() << ", " 
        << ele3->get_fem_noeud(6)->get_numero() << ", " 
        << ele3->get_fem_noeud(7)->get_numero() << ", " 
        << ele3->get_fem_noeud(8)->get_numero() << std::endl;
      ele3->change_numero(index);
      index++;
    }
  }
  bool pentaquad=false;
  f << "*ELEMENT,TYPE=C3D15,ELSET=pentaquad"<< std::endl;
  for (FEM_ELEMENT3* ele3=m_fem_maillage->get_premier_element3(ittele3);ele3;ele3=m_fem_maillage->get_suivant_element3(ittele3))
  {
    if(ele3->get_type_entite()==IDFEM_PENTA15)
    {
      if(pentaquad==false)
      {
        pentaquad=true;
        f << "*ELEMENT,TYPE=C3D15,ELSET=pentaquad"<< std::endl;
      }
      f << index << ", " 
        << ele3->get_fem_noeud(0)->get_numero() << ", " 
        << ele3->get_fem_noeud(2)->get_numero() << ", " 
        << ele3->get_fem_noeud(4)->get_numero() << ", " 
        << ele3->get_fem_noeud(9)->get_numero() << ", " 
        << ele3->get_fem_noeud(11)->get_numero() << ", " 
        << ele3->get_fem_noeud(13)->get_numero() << ", " 
        << ele3->get_fem_noeud(1)->get_numero() << ", " 
        << ele3->get_fem_noeud(3)->get_numero() << ", " 
        << ele3->get_fem_noeud(5)->get_numero() << ", " 
        << ele3->get_fem_noeud(10)->get_numero() << ", " 
        << ele3->get_fem_noeud(12)->get_numero() << ", " 
        << ele3->get_fem_noeud(14)->get_numero() << ", " 
        << ele3->get_fem_noeud(6)->get_numero() << ", " 
        << ele3->get_fem_noeud(7)->get_numero() << ", " 
        << ele3->get_fem_noeud(8)->get_numero() << std::endl;
      ele3->change_numero(index);
      index++;
    }
  }
  f.close();
  sprintf(file,"%s/BC_nsets",dossier);
  f.open(file,std::ios::out);
  f.precision(16);
  f.setf(std::ios::showpoint);
  BOITE_3D boite3D_ves = get_boite3d_ves();
  double eps = get_precision();
  TPL_MAP_ENTITE<MG_FACE*> plan_xy_z0;
  TPL_MAP_ENTITE<MG_FACE*> plan_xy_z1;
  TPL_MAP_ENTITE<MG_FACE*> plan_yz_x0;
  TPL_MAP_ENTITE<MG_FACE*> plan_yz_x1;
  TPL_MAP_ENTITE<MG_FACE*> plan_xz_y0;
  TPL_MAP_ENTITE<MG_FACE*> plan_xz_y1;
  std::map<unsigned long,MG_FACE*,std::less<unsigned long>>::iterator it_face;
  for(MG_FACE *face = m_mg_geometrie->get_premier_face(it_face);face!=NULL;face=m_mg_geometrie->get_suivant_face(it_face))
  {
    double xyzmin[3];
    double xyzmax[3];
    face->get_xyz_min_max(xyzmin,xyzmax,16);
    
    if(OPERATEUR::egal(xyzmin[0],boite3D_ves.get_xmin(),eps) && OPERATEUR::egal(xyzmax[0],boite3D_ves.get_xmin(),eps)) plan_yz_x0.ajouter(face);
    else if(OPERATEUR::egal(xyzmin[0],boite3D_ves.get_xmax(),eps) && OPERATEUR::egal(xyzmax[0],boite3D_ves.get_xmax(),eps)) plan_yz_x1.ajouter(face);
    else if(OPERATEUR::egal(xyzmin[1],boite3D_ves.get_ymin(),eps) && OPERATEUR::egal(xyzmax[1],boite3D_ves.get_ymin(),eps)) plan_xz_y0.ajouter(face);
    else if(OPERATEUR::egal(xyzmin[1],boite3D_ves.get_ymax(),eps) && OPERATEUR::egal(xyzmax[1],boite3D_ves.get_ymax(),eps)) plan_xz_y1.ajouter(face);
    else if(OPERATEUR::egal(xyzmin[2],boite3D_ves.get_zmin(),eps) && OPERATEUR::egal(xyzmax[2],boite3D_ves.get_zmin(),eps)) plan_xy_z0.ajouter(face);
    else if(OPERATEUR::egal(xyzmin[2],boite3D_ves.get_zmax(),eps) && OPERATEUR::egal(xyzmax[2],boite3D_ves.get_zmax(),eps)) plan_xy_z1.ajouter(face); 
  }
  MG_SOMMET* sommet_x0y0z0=NULL;
  MG_SOMMET* sommet_x1y0z0=NULL;
  MG_SOMMET* sommet_x0y1z0=NULL;
  MG_SOMMET* sommet_x1y1z0=NULL;
  MG_SOMMET* sommet_x0y0z1=NULL;
  MG_SOMMET* sommet_x1y0z1=NULL;
  MG_SOMMET* sommet_x0y1z1=NULL;
  MG_SOMMET* sommet_x1y1z1=NULL;
  std::map<unsigned long,MG_SOMMET*,std::less<unsigned long>>::iterator it_sommet;
  for(MG_SOMMET* som=m_mg_geometrie->get_premier_sommet(it_sommet);som!=NULL;som=m_mg_geometrie->get_suivant_sommet(it_sommet))
  {
    double xyz[3];
    som->get_point()->evaluer(xyz);
    if(OPERATEUR::egal(xyz[0],boite3D_ves.get_xmin(),eps) && OPERATEUR::egal(xyz[1],boite3D_ves.get_ymin(),eps) && OPERATEUR::egal(xyz[2],boite3D_ves.get_zmin(),eps)) sommet_x0y0z0=som;
    else if(OPERATEUR::egal(xyz[0],boite3D_ves.get_xmax(),eps) && OPERATEUR::egal(xyz[1],boite3D_ves.get_ymin(),eps) && OPERATEUR::egal(xyz[2],boite3D_ves.get_zmin(),eps)) sommet_x1y0z0=som; 
    else if(OPERATEUR::egal(xyz[0],boite3D_ves.get_xmin(),eps) && OPERATEUR::egal(xyz[1],boite3D_ves.get_ymax(),eps) && OPERATEUR::egal(xyz[2],boite3D_ves.get_zmin(),eps)) sommet_x0y1z0=som;
    else if(OPERATEUR::egal(xyz[0],boite3D_ves.get_xmax(),eps) && OPERATEUR::egal(xyz[1],boite3D_ves.get_ymax(),eps) && OPERATEUR::egal(xyz[2],boite3D_ves.get_zmin(),eps)) sommet_x1y1z0=som;    
    else if(OPERATEUR::egal(xyz[0],boite3D_ves.get_xmin(),eps) && OPERATEUR::egal(xyz[1],boite3D_ves.get_ymin(),eps) && OPERATEUR::egal(xyz[2],boite3D_ves.get_zmax(),eps)) sommet_x0y0z1=som;
    else if(OPERATEUR::egal(xyz[0],boite3D_ves.get_xmax(),eps) && OPERATEUR::egal(xyz[1],boite3D_ves.get_ymin(),eps) && OPERATEUR::egal(xyz[2],boite3D_ves.get_zmax(),eps)) sommet_x1y0z1=som; 
    else if(OPERATEUR::egal(xyz[0],boite3D_ves.get_xmin(),eps) && OPERATEUR::egal(xyz[1],boite3D_ves.get_ymax(),eps) && OPERATEUR::egal(xyz[2],boite3D_ves.get_zmax(),eps)) sommet_x0y1z1=som;
    else if(OPERATEUR::egal(xyz[0],boite3D_ves.get_xmax(),eps) && OPERATEUR::egal(xyz[1],boite3D_ves.get_ymax(),eps) && OPERATEUR::egal(xyz[2],boite3D_ves.get_zmax(),eps)) sommet_x1y1z1=som;
  }
  f << "*NSET,NSET=coin_x0y0z0" << std::endl;  
  FEM_NOEUD* coin_x0y0z0 = (FEM_NOEUD*)(sommet_x0y0z0->get_lien_fem_maillage()->get(0));
  f << coin_x0y0z0->get_numero() << std::endl;
  f << "*NSET,NSET=coin_x1y0z0" << std::endl;
  FEM_NOEUD* coin_x1y0z0 = (FEM_NOEUD*)(sommet_x1y0z0->get_lien_fem_maillage()->get(0));
  f << coin_x1y0z0->get_numero() << std::endl;
  f << "*NSET,NSET=coin_x0y1z0" << std::endl;
  FEM_NOEUD* coin_x0y1z0 = (FEM_NOEUD*)(sommet_x0y1z0->get_lien_fem_maillage()->get(0));
  f << coin_x0y1z0->get_numero() << std::endl;
  f << "*NSET,NSET=coin_x1y1z0" << std::endl;
  FEM_NOEUD* coin_x1y1z0 = (FEM_NOEUD*)(sommet_x1y1z0->get_lien_fem_maillage()->get(0));
  f << coin_x1y1z0->get_numero() << std::endl;
  f << "*NSET,NSET=coin_x0y0z1" << std::endl;
  FEM_NOEUD* coin_x0y0z1 = (FEM_NOEUD*)(sommet_x0y0z1->get_lien_fem_maillage()->get(0));
  f << coin_x0y0z1->get_numero() << std::endl;
  f << "*NSET,NSET=coin_x1y0z1" << std::endl;
  FEM_NOEUD* coin_x1y0z1 = (FEM_NOEUD*)(sommet_x1y0z1->get_lien_fem_maillage()->get(0));
  f << coin_x1y0z1->get_numero() << std::endl;
  f << "*NSET,NSET=coin_x0y1z1" << std::endl;
  FEM_NOEUD* coin_x0y1z1 = (FEM_NOEUD*)(sommet_x0y1z1->get_lien_fem_maillage()->get(0));
  f << coin_x0y1z1->get_numero() << std::endl;
  f << "*NSET,NSET=coin_x1y1z1" << std::endl;
  FEM_NOEUD* coin_x1y1z1 = (FEM_NOEUD*)(sommet_x1y1z1->get_lien_fem_maillage()->get(0));
  f << coin_x1y1z1->get_numero() << std::endl;
  TPL_MAP_ENTITE<MG_FACE*>::ITERATEUR it_face_plan;  
  f << "*NSET,NSET=xEQ0" << std::endl;
  for(MG_FACE* face=plan_yz_x0.get_premier(it_face_plan);face!=NULL;face=plan_yz_x0.get_suivant(it_face_plan))
  {
    TPL_LISTE_ENTITE<FEM_ELEMENT_MAILLAGE*> *lst_ele=face->get_lien_fem_maillage();
    long nb_ele=lst_ele->get_nb();
    for(long i=0;i<nb_ele;i++)
    {
      FEM_ELEMENT2* ele2 = (FEM_ELEMENT2*)lst_ele->get(i);
      for(int j=0;j<ele2->get_nb_fem_noeud();j++)
      {
        f << ele2->get_fem_noeud(j)->get_numero() << std::endl;
      }
    }
  }
  f << "*NSET,NSET=xEQ1" << std::endl;
  for(MG_FACE* face=plan_yz_x1.get_premier(it_face_plan);face!=NULL;face=plan_yz_x1.get_suivant(it_face_plan))
  {
    TPL_LISTE_ENTITE<FEM_ELEMENT_MAILLAGE*> *lst_ele=face->get_lien_fem_maillage();
    long nb_ele=lst_ele->get_nb();
    for(long i=0;i<nb_ele;i++)
    {
      FEM_ELEMENT2* ele2 = (FEM_ELEMENT2*)lst_ele->get(i);
      for(int j=0;j<ele2->get_nb_fem_noeud();j++)
      {
        f << ele2->get_fem_noeud(j)->get_numero() << std::endl;
      }
    }
  }
  f << "*NSET,NSET=yEQ0" << std::endl;
  for(MG_FACE* face=plan_xz_y0.get_premier(it_face_plan);face!=NULL;face=plan_xz_y0.get_suivant(it_face_plan))
  {
    TPL_LISTE_ENTITE<FEM_ELEMENT_MAILLAGE*> *lst_ele=face->get_lien_fem_maillage();
    long nb_ele=lst_ele->get_nb();
    for(long i=0;i<nb_ele;i++)
    {
      FEM_ELEMENT2* ele2 = (FEM_ELEMENT2*)lst_ele->get(i);
      for(int j=0;j<ele2->get_nb_fem_noeud();j++)
      {
        f << ele2->get_fem_noeud(j)->get_numero() << std::endl;
      }
    }
  }
  f << "*NSET,NSET=yEQ1" << std::endl;
  for(MG_FACE* face=plan_xz_y1.get_premier(it_face_plan);face!=NULL;face=plan_xz_y1.get_suivant(it_face_plan))
  {
    TPL_LISTE_ENTITE<FEM_ELEMENT_MAILLAGE*> *lst_ele=face->get_lien_fem_maillage();
    long nb_ele=lst_ele->get_nb();
    for(long i=0;i<nb_ele;i++)
    {
      FEM_ELEMENT2* ele2 = (FEM_ELEMENT2*)lst_ele->get(i);
      for(int j=0;j<ele2->get_nb_fem_noeud();j++)
      {
        f << ele2->get_fem_noeud(j)->get_numero() << std::endl;
      }
    }
  }
  f << "*NSET,NSET=zEQ0" << std::endl;
  for(MG_FACE* face=plan_xy_z0.get_premier(it_face_plan);face!=NULL;face=plan_xy_z0.get_suivant(it_face_plan))
  {
    TPL_LISTE_ENTITE<FEM_ELEMENT_MAILLAGE*> *lst_ele=face->get_lien_fem_maillage();
    long nb_ele=lst_ele->get_nb();
    for(long i=0;i<nb_ele;i++)
    {
      FEM_ELEMENT2* ele2 = (FEM_ELEMENT2*)lst_ele->get(i);
      for(int j=0;j<ele2->get_nb_fem_noeud();j++)
      {
        f << ele2->get_fem_noeud(j)->get_numero() << std::endl;
      }
    }
  }
  f << "*NSET,NSET=zEQ1" << std::endl;
  for(MG_FACE* face=plan_xy_z1.get_premier(it_face_plan);face!=NULL;face=plan_xy_z1.get_suivant(it_face_plan))
  {
    TPL_LISTE_ENTITE<FEM_ELEMENT_MAILLAGE*> *lst_ele=face->get_lien_fem_maillage();
    long nb_ele=lst_ele->get_nb();
    for(long i=0;i<nb_ele;i++)
    {
      FEM_ELEMENT2* ele2 = (FEM_ELEMENT2*)lst_ele->get(i);
      for(int j=0;j<ele2->get_nb_fem_noeud();j++)
      {
        f << ele2->get_fem_noeud(j)->get_numero() << std::endl;
      }
    }
  }
  f.close();
  sprintf(file,"%s/groupes_elements",dossier);
  f.open(file,std::ios::out);
  f.precision(16);
  f.setf(std::ios::showpoint);
  std::map<long,MG_CG_GROUPE_FORME*>::iterator it_groupe_forme;
  for(MG_CG_GROUPE_FORME* groupe_forme=m_mgcg_modele->get_premier_mgcg_groupe_forme(it_groupe_forme);groupe_forme!=NULL;groupe_forme=m_mgcg_modele->get_suivant_mgcg_groupe_forme(it_groupe_forme))
  {
    f << "*ELSET,ELSET=" << groupe_forme->get_nom() << std::endl;
    TPL_MAP_ENTITE<MG_VOLUME*> tpl_map_volume = groupe_forme->get_tpl_map_volume();
    TPL_MAP_ENTITE<MG_VOLUME*>::ITERATEUR it_volume;
    for(MG_VOLUME* volume=tpl_map_volume.get_premier(it_volume);volume!=NULL;volume=tpl_map_volume.get_suivant(it_volume))
    {
      TPL_LISTE_ENTITE<FEM_ELEMENT_MAILLAGE*> *lst_ele=volume->get_lien_fem_maillage();
      long nb_ele=lst_ele->get_nb();
      for(long i=0;i<nb_ele;i++)
      {
        FEM_ELEMENT3* ele3 = (FEM_ELEMENT3*)lst_ele->get(i);
        f << ele3->get_numero() << std::endl;
      }
    }
  }
  
  MG_CG_GROUPE_FORME* groupe_forme_particule=m_mgcg_modele->get_mgcg_groupe_forme((char*)"Particule");
  if(groupe_forme_particule!=NULL)
  {
    sprintf(file,"%s/particules",dossier);
    f.open(file,std::ios::out);
    f.precision(16);
    f.setf(std::ios::showpoint);
    std::ofstream f2;
    f2.open((char*)"infos_particules");
    f2.precision(16);
    f2.setf(std::ios::showpoint);
    f2 << "# centre_x centre_y centre_z rayon position_relative" << std::endl;
    std::ofstream f_bord;
    f_bord.open((char*)"particules_bord");
    f_bord.precision(16);
    f_bord.setf(std::ios::showpoint);
    std::ofstream f_interieur;
    f_interieur.open((char*)"particules_interieur");
    f_interieur.precision(16);
    f_interieur.setf(std::ios::showpoint);
    long p=1;
    std::map<long,MG_CG_FORME*>::iterator it_forme;
    for(MG_CG_FORME* forme=groupe_forme_particule->get_premiere_mgcg_forme(it_forme);forme!=NULL;forme=groupe_forme_particule->get_suivante_mgcg_forme(it_forme))
    {
      if(forme->get_type_forme()==MG_CG_FORME::TYPE_FORME::VOLUME)
      {
        f << "*ELSET,ELSET=P_" << p << std::endl;
        MG_CG_INFO_VCT_DOUBLE* centre = (MG_CG_INFO_VCT_DOUBLE*)forme->get_mgcg_info((char*)"CENTRE");
        MG_CG_INFO_DOUBLE* rayon = (MG_CG_INFO_DOUBLE*)forme->get_mgcg_info((char*)"RAYON");
        MG_CG_INFO_STRING* pos_rel = (MG_CG_INFO_STRING*)forme->get_mgcg_info((char*)"POSITION_RELATIVE");
        std::vector<double> vct_centre = centre->get_vct_valeur();
        f2 << p << " " 
           << vct_centre.at(0) << " " 
           << vct_centre.at(1) << " " 
           << vct_centre.at(2) << " "
           << rayon->get_valeur() << " "
           << pos_rel->get_valeur() << std::endl;   
        bool au_bord;
        if(pos_rel->get_valeur()=="AU_BORD") au_bord=true;
        else au_bord=false;
        MG_CG_FORME_VOLUME* forme_volume = (MG_CG_FORME_VOLUME*)forme;
        MG_VOLUME* volume = forme_volume->get_mg_volume();
        TPL_LISTE_ENTITE<FEM_ELEMENT_MAILLAGE*> *lst_ele=volume->get_lien_fem_maillage();
        long nb_ele=lst_ele->get_nb();
        if(au_bord) f_bord << "*ELSET,ELSET=P_" << p << std::endl;
        else f_interieur << "*ELSET,ELSET=P_" << p << std::endl;
        for(long i=0;i<nb_ele;i++)
        {
          FEM_ELEMENT3* ele3 = (FEM_ELEMENT3*)lst_ele->get(i);
          f << ele3->get_numero() << std::endl;
          if(au_bord)f_bord << ele3->get_numero() << std::endl;  
          else f_interieur << ele3->get_numero() << std::endl;  
        }
        p++;
      }
      else if(forme->get_type_forme()==MG_CG_FORME::TYPE_FORME::MULTI_VOLUME)
      {
        f << "*ELSET,ELSET=P_" << p << std::endl;
        MG_CG_INFO_VCT_DOUBLE* centre = (MG_CG_INFO_VCT_DOUBLE*)forme->get_mgcg_info((char*)"CENTRE");
        MG_CG_INFO_DOUBLE* rayon = (MG_CG_INFO_DOUBLE*)forme->get_mgcg_info((char*)"RAYON");
        MG_CG_INFO_STRING* pos_rel = (MG_CG_INFO_STRING*)forme->get_mgcg_info((char*)"POSITION_RELATIVE");
        std::vector<double> vct_centre = centre->get_vct_valeur();
        f2 << p << " " 
           << vct_centre.at(0) << " " 
           << vct_centre.at(1) << " " 
           << vct_centre.at(2) << " "
           << rayon->get_valeur() << " "
           << pos_rel->get_valeur() << std::endl;  
        bool au_bord;
        if(pos_rel->get_valeur()=="AU_BORD") au_bord=true;
        else au_bord=false;
        MG_CG_FORME_MULTI_VOLUME* forme_multi_volume = (MG_CG_FORME_MULTI_VOLUME*)forme;
        std::map<long,MG_VOLUME*>::iterator it_volume;
        for(MG_VOLUME* volume=forme_multi_volume->get_premier_mg_volume(it_volume);volume!=NULL;volume=forme_multi_volume->get_suivant_mg_volume(it_volume))
        {
          TPL_LISTE_ENTITE<FEM_ELEMENT_MAILLAGE*> *lst_ele=volume->get_lien_fem_maillage();
          long nb_ele=lst_ele->get_nb();
          if(au_bord) f_bord << "*ELSET,ELSET=P_" << p << std::endl;
          else f_interieur << "*ELSET,ELSET=P_" << p << std::endl;
          for(long i=0;i<nb_ele;i++)
          {
            FEM_ELEMENT3* ele3 = (FEM_ELEMENT3*)lst_ele->get(i);
            f << ele3->get_numero() << std::endl;
            if(au_bord)f_bord << ele3->get_numero() << std::endl;  
            else f_interieur << ele3->get_numero() << std::endl; 
          }
        }
        p++;
      }
    }
    f_bord.close();
    f_interieur.close();
    f2.close();
    f.close();
  }  
}


int MSTRUCT_VES::enregistrer(char* fichier_ves)
{
  m_ves_file->enregistrer(fichier_ves);
}

int MSTRUCT_VES::enregistrer(char *fichier_ves,char* fichier_magic)
{
  m_ves_file->change_nom_fichier_magic(fichier_magic);
  m_ves_file->enregistrer(fichier_ves);
  m_mg_gestionnaire->enregistrer(fichier_magic);
}

void MSTRUCT_VES::active_affichage(fonction_affiche* fonc)
{
  fonc_affiche = fonc;
  affichageactif = 1;
}

void MSTRUCT_VES::affiche(char* message)
{
  if(affichageactif==1) fonc_affiche(message);
}


Revision:	997
Committed:	Tue Dec 18 15:59:49 2018 UTC (6 years, 4 months ago) by couturad
File size:	93031 byte(s)
Log Message:	MICROSTRUCTURE: ajout d'un outil pour reduire le nombre de colonnes d'un histogramme