microstructure/src/mstruct_ver.cpp

#include "mstruct_ver.h"
#include "mstruct_ves_file.h"
using namespace MICROSTRUCTURE;

MSTRUCT_VER::MSTRUCT_VER(void)
{

}

MSTRUCT_VER::~MSTRUCT_VER(void)
{

}

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

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

int MSTRUCT_VER::exporter_analyse(char* fichier_liste_ves,
                                  std::vector< OT_PARAMETRES* >& vector_params_analyse,
                                  char* dossier_resultat)
{
  char message[5000];
  std::map<long,MSTRUCT_VES_FILE*> map_ves_file;  
  std::ifstream f;
  f.open(fichier_liste_ves,ios::in);
  char ligne[1000];
  f.getline(ligne,1000);
  long i=0;
  while(!f.eof())
  {
    char fichier_ves[1000];
    sscanf(ligne,"%s",fichier_ves);
    if(strlen(fichier_ves)==0) continue;
    std::map<std::string,MSTRUCT_ANALYSE*>* map_analyse = new std::map<std::string,MSTRUCT_ANALYSE*>;
    MSTRUCT_VES_FILE *ves_file=new MSTRUCT_VES_FILE;
    if(ves_file->ouvrir(fichier_ves)==FAIL) return FAIL;
    map_ves_file.insert(std::pair<long,MSTRUCT_VES_FILE*>(i,ves_file));
    i++;
    f.getline(ligne,1000);
  }
  f.close();
  long nb_ves = map_ves_file.size();
  sprintf(message,"NB_VES : %li",nb_ves); affiche(message);
  std::vector<OT_PARAMETRES*>::iterator it;
  for(it=vector_params_analyse.begin();it!=vector_params_analyse.end();it++)
  {
    
    OT_PARAMETRES* param = *it;
    int Type_analyse = (int)param->get_valeur((char*)"Type_analyse");
    std::string Identifiant = param->get_nom((char*)"Identifiant"); 
    sprintf(message,"-> %s",Identifiant.c_str()); affiche(message);
    char nom_fichier_resultat[500];
    sprintf(nom_fichier_resultat,"%s%s.txt",dossier_resultat,Identifiant.c_str());
    ofstream ofstrm(nom_fichier_resultat,ios::out);
    ofstrm.precision(16);
    std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
    i=1;
    for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
    {
      MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
      MSTRUCT_ANALYSE* analyse = ves_file->get_analyse(Identifiant);
      if(analyse==NULL)
      {
        std::cerr << "*** MSTRUCT_VER::exporter_analyse : Erreur ***" << std::endl;
        return FAIL;
      }
      analyse->exporter(ofstrm,i);
      i++;
    }
  }
  std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
  for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
  {
    delete it_ves_file->second;
  }
}


int MSTRUCT_VER::cumuler_analyse(char* fichier_liste_ves,
                                 std::vector< OT_PARAMETRES* >& vector_params_analyse,
                                 char* dossier_resultat,
                                 bool resultats_incrementaux,
                                 bool avec_histogramme)
{
  
  char message[5000];
  std::map<long,MSTRUCT_VES_FILE*> map_ves_file;  
  std::ifstream f;
  f.open(fichier_liste_ves,ios::in);
  char ligne[1000];
  f.getline(ligne,1000);
  long i=0;
  while(!f.eof())
  {
    char fichier_ves[1000];
    sscanf(ligne,"%s",fichier_ves);
    if(strlen(fichier_ves)==0) continue;
    std::map<std::string,MSTRUCT_ANALYSE*>* map_analyse = new std::map<std::string,MSTRUCT_ANALYSE*>;
    MSTRUCT_VES_FILE *ves_file=new MSTRUCT_VES_FILE;
    if(ves_file->ouvrir(fichier_ves)==FAIL) return FAIL;
    map_ves_file.insert(std::pair<long,MSTRUCT_VES_FILE*>(i,ves_file));
    i++;
    f.getline(ligne,1000);
  }
  f.close();
  long nb_ves = map_ves_file.size();
  sprintf(message,"NB_VES : %li",nb_ves); affiche(message);
  std::vector<OT_PARAMETRES*>::iterator it;
  for(it=vector_params_analyse.begin();it!=vector_params_analyse.end();it++)
  {
    
    OT_PARAMETRES* param = *it;
    int Type_analyse = (int)param->get_valeur((char*)"Type_analyse");
    std::string Identifiant = param->get_nom((char*)"Identifiant"); 
    sprintf(message,"-> %s",Identifiant.c_str()); affiche(message);
    int Analyse_erosion = (int)param->get_valeur((char*)"Analyse_erosion");
    long Nb_couche = (long)param->get_valeur((char*)"Nb_couche");
    char nom_fichier_resultat[500];
    sprintf(nom_fichier_resultat,"%s%s.txt",dossier_resultat,Identifiant.c_str());
    ofstream ofstrm(nom_fichier_resultat,ios::out);
    ofstrm.precision(16);
    if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CHAMP)
    {
      if(!Analyse_erosion)
      {
        std::vector<MSTRUCT_ANALYSE_CHAMP*> vector_analyse;
        std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
        i=1;
        for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
        {
          MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
          MSTRUCT_ANALYSE* analyse = ves_file->get_analyse(Identifiant);
          if(analyse==NULL)
          {
            std::cerr << "*** MSTRUCT_VER::cumuler_analyse : Erreur ***" << std::endl;
            return FAIL;
          }
          vector_analyse.push_back((MSTRUCT_ANALYSE_CHAMP*)analyse);
          if(resultats_incrementaux)
          {
            MSTRUCT_ANALYSE_CHAMP analyse_champ(vector_analyse);
            analyse_champ.exporter(ofstrm,i,avec_histogramme,dossier_resultat);
          }
          i++;
        }
        if(!resultats_incrementaux)
        {
          MSTRUCT_ANALYSE_CHAMP analyse_champ(vector_analyse);
          analyse_champ.exporter(ofstrm,1,avec_histogramme,dossier_resultat);
        }      
      }
      else
      {
        for(i=0;i<Nb_couche;i++)
        {
          std::vector<MSTRUCT_ANALYSE_CHAMP*> vector_analyse;
          std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
          for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
          {
            MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
            MSTRUCT_ANALYSE_EROSION *analyse_erosion = (MSTRUCT_ANALYSE_EROSION*)ves_file->get_analyse(Identifiant);
            vector_analyse.push_back((MSTRUCT_ANALYSE_CHAMP*)analyse_erosion->get_analyse(i));
          }
          MSTRUCT_ANALYSE_CHAMP analyse_champ(vector_analyse);
          analyse_champ.exporter(ofstrm,i+1,avec_histogramme,dossier_resultat);
        }
      }
    }
    else if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::ORIENTATION)
    {
      if(!Analyse_erosion)
      {
        std::vector<MSTRUCT_ANALYSE_ORIENTATION*> vector_analyse;
        std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
        i=1;
        for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
        {
          MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
          MSTRUCT_ANALYSE* analyse = ves_file->get_analyse(Identifiant);
          if(analyse==NULL)
          {
            std::cerr << "*** MSTRUCT_VER::cumuler_analyse : Erreur ***" << std::endl;
            return FAIL;
          }
          vector_analyse.push_back((MSTRUCT_ANALYSE_ORIENTATION*)analyse);
          if(resultats_incrementaux)
          {
            MSTRUCT_ANALYSE_ORIENTATION analyse_orientation(vector_analyse);
            analyse_orientation.exporter(ofstrm,i,avec_histogramme,dossier_resultat);
          }
          i++;
        }
        if(!resultats_incrementaux)
        {
          MSTRUCT_ANALYSE_ORIENTATION analyse_orientation(vector_analyse);
          analyse_orientation.exporter(ofstrm,1,avec_histogramme,dossier_resultat);
        }
      }
      else
      {
        for(i=0;i<Nb_couche;i++)
        {
          std::vector<MSTRUCT_ANALYSE_ORIENTATION*> vector_analyse;
          std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
          for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
          {
            MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
            MSTRUCT_ANALYSE_EROSION *analyse_erosion = (MSTRUCT_ANALYSE_EROSION*)ves_file->get_analyse(Identifiant);
            vector_analyse.push_back((MSTRUCT_ANALYSE_ORIENTATION*)analyse_erosion->get_analyse(i));
          }
          MSTRUCT_ANALYSE_ORIENTATION analyse_orientation(vector_analyse);
          analyse_orientation.exporter(ofstrm,i+1,avec_histogramme,dossier_resultat);
        }
      }
    }
    else if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::ORIENTATION_PONDEREE)
    {
      if(!Analyse_erosion)
      {
        std::vector<MSTRUCT_ANALYSE_ORIENTATION*> vector_analyse;
        std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
        i=1;
        for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
        {
          MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
          MSTRUCT_ANALYSE* analyse = ves_file->get_analyse(Identifiant);
          if(analyse==NULL)
          {
            std::cerr << "*** MSTRUCT_VER::cumuler_analyse : Erreur ***" << std::endl;
            return FAIL;
          }
          vector_analyse.push_back((MSTRUCT_ANALYSE_ORIENTATION_PONDEREE*)analyse);
          if(resultats_incrementaux)
          {
            MSTRUCT_ANALYSE_ORIENTATION_PONDEREE analyse_orientation(vector_analyse);
            analyse_orientation.exporter(ofstrm,i,avec_histogramme,dossier_resultat);
          }
          i++;
        }
        if(!resultats_incrementaux)
        {
          MSTRUCT_ANALYSE_ORIENTATION_PONDEREE analyse_orientation(vector_analyse);
          analyse_orientation.exporter(ofstrm,1,avec_histogramme,dossier_resultat);
        }
      }
      else
      {
        for(i=0;i<Nb_couche;i++)
        {
          std::vector<MSTRUCT_ANALYSE_ORIENTATION*> vector_analyse;
          std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
          for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
          {
            MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
            MSTRUCT_ANALYSE_EROSION *analyse_erosion = (MSTRUCT_ANALYSE_EROSION*)ves_file->get_analyse(Identifiant);
            vector_analyse.push_back((MSTRUCT_ANALYSE_ORIENTATION_PONDEREE*)analyse_erosion->get_analyse(i));
          }
          MSTRUCT_ANALYSE_ORIENTATION_PONDEREE analyse_orientation(vector_analyse);
          analyse_orientation.exporter(ofstrm,i+1,avec_histogramme,dossier_resultat);
        }
      }
    }
    else if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CAO)
    {
      if(!Analyse_erosion)
      {
        std::vector<MSTRUCT_ANALYSE_CAO*> vector_analyse;
        std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
        i=1;
        for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
        {
          MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
          MSTRUCT_ANALYSE* analyse = ves_file->get_analyse(Identifiant);
          if(analyse==NULL)
          {
            std::cerr << "*** MSTRUCT_VER::cumuler_analyse : Erreur ***" << std::endl;
            return FAIL;
          }
          vector_analyse.push_back((MSTRUCT_ANALYSE_CAO*)analyse);
          if(resultats_incrementaux)
          {
            MSTRUCT_ANALYSE_CAO analyse_cao(vector_analyse);
            analyse_cao.exporter(ofstrm,i,avec_histogramme,dossier_resultat);
          }
          i++;
        }
        if(!resultats_incrementaux)
        {
          MSTRUCT_ANALYSE_CAO analyse_orientation(vector_analyse);
          analyse_orientation.exporter(ofstrm,1,avec_histogramme,dossier_resultat);
        }
      }
      else
      {
        for(i=0;i<Nb_couche;i++)
        {
          std::vector<MSTRUCT_ANALYSE_CAO*> vector_analyse;
          std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
          for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
          {
            MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
            MSTRUCT_ANALYSE_EROSION *analyse_erosion = (MSTRUCT_ANALYSE_EROSION*)ves_file->get_analyse(Identifiant);
            vector_analyse.push_back((MSTRUCT_ANALYSE_CAO*)analyse_erosion->get_analyse(i));
          }
          MSTRUCT_ANALYSE_CAO analyse_cao(vector_analyse);
          analyse_cao.exporter(ofstrm,i+1,avec_histogramme,dossier_resultat);
        }
      }
    }
    else if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_MG)
    {
      if(!Analyse_erosion)
      {
        std::vector<MSTRUCT_ANALYSE_MG_MAILLAGE*> vector_analyse;
        std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
        i=1;
        for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
        {
          MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
          MSTRUCT_ANALYSE* analyse = ves_file->get_analyse(Identifiant);
          if(analyse==NULL)
          {
            std::cerr << "*** MSTRUCT_VER::cumuler_analyse : Erreur ***" << std::endl;
            return FAIL;
          }
          vector_analyse.push_back((MSTRUCT_ANALYSE_MG_MAILLAGE*)analyse);
          if(resultats_incrementaux)
          {
            MSTRUCT_ANALYSE_MG_MAILLAGE analyse_mg_maillage(vector_analyse);
            analyse_mg_maillage.exporter(ofstrm,i,avec_histogramme,dossier_resultat);
          }
          i++;
        }
        if(!resultats_incrementaux)
        {
          MSTRUCT_ANALYSE_MG_MAILLAGE analyse_mg_maillage(vector_analyse);
          analyse_mg_maillage.exporter(ofstrm,1,avec_histogramme,dossier_resultat);
        }
      }
      else
      {
        for(i=0;i<Nb_couche;i++)
        {
          std::vector<MSTRUCT_ANALYSE_MG_MAILLAGE*> vector_analyse;
          std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
          for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
          {
            MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
            MSTRUCT_ANALYSE_EROSION *analyse_erosion = (MSTRUCT_ANALYSE_EROSION*)ves_file->get_analyse(Identifiant);
            vector_analyse.push_back((MSTRUCT_ANALYSE_MG_MAILLAGE*)analyse_erosion->get_analyse(i));
          }
          MSTRUCT_ANALYSE_MG_MAILLAGE analyse_mg_maill(vector_analyse);
          analyse_mg_maill.exporter(ofstrm,i+1,avec_histogramme,dossier_resultat);
        }
      }
    }
    else if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_FEM)
    {
      if(!Analyse_erosion)
      {
        std::vector<MSTRUCT_ANALYSE_FEM_MAILLAGE*> vector_analyse;
        std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
        i=1;
        for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
        {
          MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
          MSTRUCT_ANALYSE* analyse = ves_file->get_analyse(Identifiant);
          if(analyse==NULL)
          {
            std::cerr << "*** MSTRUCT_VER::cumuler_analyse : Erreur ***" << std::endl;
            return FAIL;
          }
          vector_analyse.push_back((MSTRUCT_ANALYSE_FEM_MAILLAGE*)analyse);
          if(resultats_incrementaux)
          {
            MSTRUCT_ANALYSE_FEM_MAILLAGE analyse_fem_maillage(vector_analyse);
            analyse_fem_maillage.exporter(ofstrm,i,avec_histogramme,dossier_resultat);
          }
          i++;
        }
        if(!resultats_incrementaux)
        {
          MSTRUCT_ANALYSE_FEM_MAILLAGE analyse_fem_maillage(vector_analyse);
          analyse_fem_maillage.exporter(ofstrm,1,avec_histogramme,dossier_resultat);
        }
      }
      else
      {
        for(i=0;i<Nb_couche;i++)
        {
          std::vector<MSTRUCT_ANALYSE_FEM_MAILLAGE*> vector_analyse;
          std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
          for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
          {
            MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
            MSTRUCT_ANALYSE_EROSION *analyse_erosion = (MSTRUCT_ANALYSE_EROSION*)ves_file->get_analyse(Identifiant);
            vector_analyse.push_back((MSTRUCT_ANALYSE_FEM_MAILLAGE*)analyse_erosion->get_analyse(i));
          }
          MSTRUCT_ANALYSE_FEM_MAILLAGE analyse_fem_maill(vector_analyse);
          analyse_fem_maill.exporter(ofstrm,i+1,avec_histogramme,dossier_resultat);
        }       
      }
    }
  }
  std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
  for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
  {
    delete it_ves_file->second;
  }
  return OK;
}

int MSTRUCT_VER::calculer_modules_mecaniques(char* fichier_liste_ves_spherique,
                                             char* fichier_liste_ves_deviatorique,
                                             std::vector< OT_PARAMETRES* >& vector_params_ver,
                                             char* dossier_resultat,
                                             bool cumuler,
                                             bool resultats_incrementaux,
                                             bool avec_histogramme)
{
  char message[5000];
  std::map<long,MSTRUCT_VES_FILE*> map_ves_file_spherique;  
  std::ifstream f;
  f.open(fichier_liste_ves_spherique,ios::in);
  char ligne[1000];
  f.getline(ligne,1000);
  long i=0;
  while(!f.eof())
  {
    char fichier_ves[1000];
    sscanf(ligne,"%s",fichier_ves);
    if(strlen(fichier_ves)==0) continue;
    std::map<std::string,MSTRUCT_ANALYSE*>* map_analyse = new std::map<std::string,MSTRUCT_ANALYSE*>;
    MSTRUCT_VES_FILE *ves_file=new MSTRUCT_VES_FILE;
    if(ves_file->ouvrir(fichier_ves)==FAIL) return FAIL;
    map_ves_file_spherique.insert(std::pair<long,MSTRUCT_VES_FILE*>(i,ves_file));
    i++;
    f.getline(ligne,1000);
  }
  f.close();
  std::map<long,MSTRUCT_VES_FILE*> map_ves_file_deviatorique;  
  f.open(fichier_liste_ves_deviatorique,ios::in);
  f.getline(ligne,1000);
  i=0;
  while(!f.eof())
  {
    char fichier_ves[1000];
    sscanf(ligne,"%s",fichier_ves);
    if(strlen(fichier_ves)==0) continue;
    std::map<std::string,MSTRUCT_ANALYSE*>* map_analyse = new std::map<std::string,MSTRUCT_ANALYSE*>;
    MSTRUCT_VES_FILE *ves_file=new MSTRUCT_VES_FILE;
    if(ves_file->ouvrir(fichier_ves)==FAIL) return FAIL;
    map_ves_file_deviatorique.insert(std::pair<long,MSTRUCT_VES_FILE*>(i,ves_file));
    i++;
    f.getline(ligne,1000);
  }
  f.close();
  if(map_ves_file_spherique.size()!=map_ves_file_deviatorique.size())
  {
    std::cerr << "*** MSTRUCT_VER::calculer_module_young : Liste non identique ***" << std::endl;
    return FAIL;
  }
  long nb_ves = map_ves_file_spherique.size();
  sprintf(message,"NB_VES : %li",nb_ves); affiche(message);  
  std::vector<OT_PARAMETRES*>::iterator it;
  for(it=vector_params_ver.begin();it!=vector_params_ver.end();it++)
  {
    OT_PARAMETRES *param = *it;    
    std::string Identifiant_epsilon = param->get_nom((char*)"Identifiant_epsilon"); 
    std::string Identifiant_sigma = param->get_nom((char*)"Identifiant_sigma");
    char ligne[1000];
    sprintf(ligne,"-> %s_%s",Identifiant_epsilon.c_str(),Identifiant_sigma.c_str());
    affiche(ligne);
    double Largeur_colonne_distribution_module_Kapp = param->get_valeur((char*)"Largeur_colonne_distribution_module_Kapp");
    double Largeur_colonne_distribution_module_Gapp = param->get_valeur((char*)"Largeur_colonne_distribution_module_Gapp");
    double Largeur_colonne_distribution_module_Eapp = param->get_valeur((char*)"Largeur_colonne_distribution_module_Eapp");
    double Largeur_colonne_distribution_module_Nuapp = param->get_valeur((char*)"Largeur_colonne_distribution_module_Nuapp");
    int Analyse_erosion = (int)param->get_valeur((char*)"Analyse_erosion");
    char nom_fichier_resultat[500];
    sprintf(nom_fichier_resultat,"%sModules_meca_%s_%s.txt",dossier_resultat,Identifiant_epsilon.c_str(),Identifiant_sigma.c_str());
    ofstream ofstrm(nom_fichier_resultat,ios::out);
    ofstrm.precision(16);
    if(Analyse_erosion)
    {
      cumuler=true;
      resultats_incrementaux=false;
      avec_histogramme=false;
      std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_sph=map_ves_file_spherique.begin();
      std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_dev=map_ves_file_deviatorique.begin();
      MSTRUCT_VES_FILE* file_sph=it_ves_sph->second;
      MSTRUCT_VES_FILE* file_dev=it_ves_sph->second;
      MSTRUCT_ANALYSE_EROSION* analyse_erosion_epsilon_sph = (MSTRUCT_ANALYSE_EROSION*)file_sph->get_analyse(Identifiant_epsilon);
      MSTRUCT_ANALYSE_EROSION* analyse_erosion_sigma_sph = (MSTRUCT_ANALYSE_EROSION*)file_sph->get_analyse(Identifiant_sigma);
      MSTRUCT_ANALYSE_EROSION* analyse_erosion_epsilon_dev = (MSTRUCT_ANALYSE_EROSION*)file_dev->get_analyse(Identifiant_epsilon);
      MSTRUCT_ANALYSE_EROSION* analyse_erosion_sigma_dev = (MSTRUCT_ANALYSE_EROSION*)file_dev->get_analyse(Identifiant_sigma);
      long nb_couche=analyse_erosion_epsilon_sph->get_nb_couche();
      double epaisseur_couche = analyse_erosion_epsilon_sph->get_epaisseur_couche();
      for(long j=0;j<nb_couche;j++)
      {
        sprintf(ligne,"\033[1A\033[K-> Couche #%li",j);
        affiche(ligne);
        it_ves_sph=map_ves_file_spherique.begin();
        it_ves_dev=map_ves_file_deviatorique.begin();
        std::vector<MSTRUCT_ANALYSE_MODULES_MECA*> vector_module_meca;
        for(;it_ves_sph!=map_ves_file_spherique.end();it_ves_sph++,it_ves_dev++)
        {
          file_sph=it_ves_sph->second;
          file_dev=it_ves_dev->second;
          analyse_erosion_epsilon_sph = (MSTRUCT_ANALYSE_EROSION*)file_sph->get_analyse(Identifiant_epsilon);
          analyse_erosion_sigma_sph = (MSTRUCT_ANALYSE_EROSION*)file_sph->get_analyse(Identifiant_sigma);
          analyse_erosion_epsilon_dev = (MSTRUCT_ANALYSE_EROSION*)file_dev->get_analyse(Identifiant_epsilon);
          analyse_erosion_sigma_dev = (MSTRUCT_ANALYSE_EROSION*)file_dev->get_analyse(Identifiant_sigma);
          MSTRUCT_ANALYSE_CHAMP* epsilon_sph=(MSTRUCT_ANALYSE_CHAMP*)analyse_erosion_epsilon_sph->get_analyse(j);
          MSTRUCT_ANALYSE_CHAMP* sigma_sph=(MSTRUCT_ANALYSE_CHAMP*)analyse_erosion_sigma_sph->get_analyse(j);
          MSTRUCT_ANALYSE_CHAMP* epsilon_dev=(MSTRUCT_ANALYSE_CHAMP*)analyse_erosion_epsilon_dev->get_analyse(j);
          MSTRUCT_ANALYSE_CHAMP* sigma_dev=(MSTRUCT_ANALYSE_CHAMP*)analyse_erosion_sigma_dev->get_analyse(j);
          MSTRUCT_ANALYSE_MODULES_MECA* analyse_meca = new MSTRUCT_ANALYSE_MODULES_MECA(epsilon_sph,
                                                                                        sigma_sph,
                                                                                        epsilon_dev,
                                                                                        sigma_dev,
                                                                                        Largeur_colonne_distribution_module_Kapp,
                                                                                        Largeur_colonne_distribution_module_Gapp,
                                                                                        Largeur_colonne_distribution_module_Eapp,
                                                                                        Largeur_colonne_distribution_module_Nuapp);
          vector_module_meca.push_back(analyse_meca);
        }
        MSTRUCT_ANALYSE_MODULES_MECA analyse_meca_glob(vector_module_meca);
        analyse_meca_glob.exporter(ofstrm,j+1,false);
        std::vector<MSTRUCT_ANALYSE_MODULES_MECA*>::iterator it_vector_meca;
        for(it_vector_meca=vector_module_meca.begin();it_vector_meca!=vector_module_meca.end();it_vector_meca++) delete *it_vector_meca;
      }
      sprintf(ligne,"\033[1A\033[K");
      affiche(ligne);
//       ofstrm.close();
    }
    else
    {
      std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_sph=map_ves_file_spherique.begin();
      std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_dev=map_ves_file_deviatorique.begin();
      MSTRUCT_VES_FILE* file_sph;
      MSTRUCT_VES_FILE* file_dev;
      std::vector<MSTRUCT_ANALYSE_MODULES_MECA*> vector_module_meca;
      i=1;
      for(;it_ves_sph!=map_ves_file_spherique.end();it_ves_sph++,it_ves_dev++)
      {
        file_sph=it_ves_sph->second;
        file_dev=it_ves_dev->second;
        MSTRUCT_ANALYSE_CHAMP* epsilon_sph=(MSTRUCT_ANALYSE_CHAMP*)file_sph->get_analyse(Identifiant_epsilon);
        MSTRUCT_ANALYSE_CHAMP* sigma_sph=(MSTRUCT_ANALYSE_CHAMP*)file_sph->get_analyse(Identifiant_sigma);
        MSTRUCT_ANALYSE_CHAMP* epsilon_dev=(MSTRUCT_ANALYSE_CHAMP*)file_dev->get_analyse(Identifiant_epsilon);
        MSTRUCT_ANALYSE_CHAMP* sigma_dev=(MSTRUCT_ANALYSE_CHAMP*)file_dev->get_analyse(Identifiant_sigma);
        MSTRUCT_ANALYSE_MODULES_MECA* analyse_meca = new MSTRUCT_ANALYSE_MODULES_MECA(epsilon_sph,
                                                                                      sigma_sph,
                                                                                      epsilon_dev,
                                                                                      sigma_dev,
                                                                                      Largeur_colonne_distribution_module_Kapp,
                                                                                      Largeur_colonne_distribution_module_Gapp,
                                                                                      Largeur_colonne_distribution_module_Eapp,
                                                                                      Largeur_colonne_distribution_module_Nuapp);
        
        if(!cumuler)
        {
          analyse_meca->exporter(ofstrm,i,false);
          delete analyse_meca;
        }
        else
        {
          vector_module_meca.push_back(analyse_meca);
          if(resultats_incrementaux)
          {
            MSTRUCT_ANALYSE_MODULES_MECA analyse_meca_glob(vector_module_meca);
            analyse_meca_glob.exporter(ofstrm,i,false);
          }
        }
        i++;
      }
      if(cumuler)
      {
        MSTRUCT_ANALYSE_MODULES_MECA analyse_meca_glob(vector_module_meca);
        analyse_meca_glob.exporter(ofstrm,i,avec_histogramme,dossier_resultat);
        std::vector<MSTRUCT_ANALYSE_MODULES_MECA*>::iterator it_vector_meca;
        for(it_vector_meca=vector_module_meca.begin();it_vector_meca!=vector_module_meca.end();it_vector_meca++) delete *it_vector_meca;
      }
    } 
    ofstrm.close();
  }
}


Revision:	938
Committed:	Wed Jun 6 13:04:19 2018 UTC (6 years, 11 months ago) by couturad
File size:	22915 byte(s)
Log Message:	MICROSTRUCTURE : Ajout du tenseur d'orientation pondere par le volume des particules