microstructure/src/mstruct_ver.cpp

#include "mstruct_ver.h"
#include "mstruct_ves_file.h"

MSTRUCT_VER::MSTRUCT_VER(void)
{

}

MSTRUCT_VER::~MSTRUCT_VER(void)
{

}

void MSTRUCT_VER::active_affichage(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,std::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)
    {
      delete map_analyse;
      delete ves_file;
      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");
    if(!Analyse_erosion)
    {
      char sys_mk_dossier[1000];
      char nom_fichier_resultat[1000];      
      sprintf(nom_fichier_resultat,"%s/liste_%s.txt",dossier_resultat,Identifiant.c_str());
      std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
      ofstrm.precision(16);
      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(i==1) analyse->exporter(ofstrm,i,true);
        else analyse->exporter(ofstrm,i,false);
        i++;
      }
      ofstrm.close();
    }
    else
    {
      for(long j=0;j<Nb_couche;j++)
      {
        char sys_mk_dossier[1000];
        char nom_fichier_resultat[1000];      
        sprintf(sys_mk_dossier,"mkdir -p %s/c_%li",dossier_resultat,j);
        system(sys_mk_dossier);
        sprintf(nom_fichier_resultat,"%s/c_%li/liste_%s.txt",dossier_resultat,j,Identifiant.c_str());
        std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
        ofstrm.precision(16);
        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_EROSION *analyse_erosion = (MSTRUCT_ANALYSE_EROSION*)ves_file->get_analyse(Identifiant);
          if(i==1) analyse_erosion->get_analyse(j)->exporter(ofstrm,i,true);
          else analyse_erosion->get_analyse(j)->exporter(ofstrm,i,false);
          i++;    
        }
        ofstrm.close();
      }
    }    
  }
  return OK;
}


int MSTRUCT_VER::cumuler_analyse(char* fichier_liste_ves,
                                 std::vector< OT_PARAMETRES* >& vector_params_analyse,
                                 char* dossier_resultat,
                                 bool avec_histogramme)
{
  char message[5000];
  std::map<long,MSTRUCT_VES_FILE*> map_ves_file;  
  std::ifstream f;
  f.open(fichier_liste_ves,std::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");
    if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CHAMP)
    {
      if(!Analyse_erosion)
      {
        char nom_fichier_resultat[1000];        
        sprintf(nom_fichier_resultat,"%s/cumul_%s.txt",dossier_resultat,Identifiant.c_str());
        std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
        ofstrm.precision(16);
        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* analyse = ves_file->get_analyse(Identifiant);
          vector_analyse.push_back((MSTRUCT_ANALYSE_CHAMP*)analyse);
        }
        MSTRUCT_ANALYSE_CHAMP analyse_champ(vector_analyse);
        analyse_champ.exporter(ofstrm,nb_ves,true,avec_histogramme,dossier_resultat);
        ofstrm.close();
      }
      else
      {
        for(long j=0;j<Nb_couche;j++)
        {
          char nom_fichier_resultat[1000];
          char sys_mk_dossier[1000];
          char prefix_histo[1000];
          sprintf(sys_mk_dossier,"mkdir -p %s/c_%li",dossier_resultat,j);
          system(sys_mk_dossier);
          sprintf(nom_fichier_resultat,"%s/c_%li/cumul_%s.txt",dossier_resultat,j,Identifiant.c_str());
          sprintf(prefix_histo,"%s/c_%li/",dossier_resultat,j);
          std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
          ofstrm.precision(16);
          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(j));
          }
          MSTRUCT_ANALYSE_CHAMP analyse_champ(vector_analyse);
          analyse_champ.exporter(ofstrm,nb_ves,true,avec_histogramme,prefix_histo);
          ofstrm.close();
        }
      }
    }
    else if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::ORIENTATION)
    {
      if(!Analyse_erosion)
      {
        char nom_fichier_resultat[1000];
        sprintf(nom_fichier_resultat,"%s/cumul_%s.txt",dossier_resultat,Identifiant.c_str());
        std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
        ofstrm.precision(16);
        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* analyse = ves_file->get_analyse(Identifiant);
          vector_analyse.push_back((MSTRUCT_ANALYSE_ORIENTATION*)analyse);
        }
        MSTRUCT_ANALYSE_ORIENTATION analyse_orientation(vector_analyse);
        analyse_orientation.exporter(ofstrm,nb_ves,true,avec_histogramme,dossier_resultat);
        ofstrm.close();
      }
      else
      {
        for(long j=0;j<Nb_couche;j++)
        {
          char nom_fichier_resultat[1000];
          char sys_mk_dossier[1000];
          char prefix_histo[1000];
          sprintf(sys_mk_dossier,"mkdir -p %s/c_%li",dossier_resultat,j);
          system(sys_mk_dossier);
          sprintf(nom_fichier_resultat,"%s/c_%li/cumul_%s.txt",dossier_resultat,j,Identifiant.c_str());
          sprintf(prefix_histo,"%s/c_%li/",dossier_resultat,j);
          std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
          ofstrm.precision(16);
          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(j));
          }
          MSTRUCT_ANALYSE_ORIENTATION analyse_orientation(vector_analyse);
          analyse_orientation.exporter(ofstrm,nb_ves,true,avec_histogramme,prefix_histo);
          ofstrm.close();
        }
      }
    }
    else if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::ORIENTATION_PONDEREE)
    {
      if(!Analyse_erosion)
      {
        char nom_fichier_resultat[1000];
        sprintf(nom_fichier_resultat,"%s/cumul_%s.txt",dossier_resultat,Identifiant.c_str());
        std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
        ofstrm.precision(16);
        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* analyse = ves_file->get_analyse(Identifiant);
          vector_analyse.push_back((MSTRUCT_ANALYSE_ORIENTATION_PONDEREE*)analyse);
        }
        MSTRUCT_ANALYSE_ORIENTATION_PONDEREE analyse_orientation_ponderee(vector_analyse);
        analyse_orientation_ponderee.exporter(ofstrm,nb_ves,true,avec_histogramme,dossier_resultat);
        ofstrm.close();
      }
      else
      {
        for(long j=0;j<Nb_couche;j++)
        {
          char nom_fichier_resultat[1000];
          char sys_mk_dossier[1000];
          char prefix_histo[1000];
          sprintf(sys_mk_dossier,"mkdir -p %s/c_%li",dossier_resultat,j);
          system(sys_mk_dossier);
          sprintf(nom_fichier_resultat,"%s/c_%li/cumul_%s.txt",dossier_resultat,j,Identifiant.c_str());
          sprintf(prefix_histo,"%s/c_%li/",dossier_resultat,j);
          std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
          ofstrm.precision(16);
          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(j));
          }
          MSTRUCT_ANALYSE_ORIENTATION_PONDEREE analyse_orientation_ponderee(vector_analyse);
          analyse_orientation_ponderee.exporter(ofstrm,nb_ves,true,avec_histogramme,prefix_histo);
          ofstrm.close();
        }
      }
    }
    else if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CAO)
    {
      if(!Analyse_erosion)
      {
        char nom_fichier_resultat[1000];
        sprintf(nom_fichier_resultat,"%s/cumul_%s.txt",dossier_resultat,Identifiant.c_str());
        std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
        ofstrm.precision(16);
        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* analyse = ves_file->get_analyse(Identifiant);
          vector_analyse.push_back((MSTRUCT_ANALYSE_CAO*)analyse);
        }
        MSTRUCT_ANALYSE_CAO analyse_cao(vector_analyse);
        analyse_cao.exporter(ofstrm,nb_ves,true,avec_histogramme,dossier_resultat);
        ofstrm.close();
      }
      else
      {
        for(long j=0;j<Nb_couche;j++)
        {
          char nom_fichier_resultat[1000];
          char sys_mk_dossier[1000];
          char prefix_histo[1000];
          sprintf(sys_mk_dossier,"mkdir -p %s/c_%li",dossier_resultat,j);
          system(sys_mk_dossier);
          sprintf(nom_fichier_resultat,"%s/c_%li/cumul_%s.txt",dossier_resultat,j,Identifiant.c_str());
          sprintf(prefix_histo,"%s/c_%li/",dossier_resultat,j);
          std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
          ofstrm.precision(16);
          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(j));
          }
          MSTRUCT_ANALYSE_CAO analyse_cao(vector_analyse);
          analyse_cao.exporter(ofstrm,nb_ves,true,avec_histogramme,prefix_histo);
          ofstrm.close();
        }
      }
    }
    else if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_MG)
    {
      if(!Analyse_erosion)
      {
        char nom_fichier_resultat[1000];
        sprintf(nom_fichier_resultat,"%s/cumul_%s.txt",dossier_resultat,Identifiant.c_str());
        std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
        ofstrm.precision(16);
        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* analyse = ves_file->get_analyse(Identifiant);
          vector_analyse.push_back((MSTRUCT_ANALYSE_MG_MAILLAGE*)analyse);
        }
        MSTRUCT_ANALYSE_MG_MAILLAGE analyse_maillage_mg(vector_analyse);
        analyse_maillage_mg.exporter(ofstrm,nb_ves,true,avec_histogramme,dossier_resultat);
        ofstrm.close();
      }
      else
      {
        for(long j=0;j<Nb_couche;j++)
        {
          char nom_fichier_resultat[1000];
          char sys_mk_dossier[1000];
          char prefix_histo[1000];
          sprintf(sys_mk_dossier,"mkdir -p %s/c_%li",dossier_resultat,j);
          system(sys_mk_dossier);
          sprintf(nom_fichier_resultat,"%s/c_%li/cumul_%s.txt",dossier_resultat,j,Identifiant.c_str());
          sprintf(prefix_histo,"%s/c_%li/",dossier_resultat,j);
          std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
          ofstrm.precision(16);
          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(j));
          }
          MSTRUCT_ANALYSE_MG_MAILLAGE analyse_maillage_mg(vector_analyse);
          analyse_maillage_mg.exporter(ofstrm,nb_ves,true,avec_histogramme,prefix_histo);
          ofstrm.close();
        }
      }
    }
    else if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_FEM)
    {
      if(!Analyse_erosion)
      {
        char nom_fichier_resultat[1000];
        sprintf(nom_fichier_resultat,"%s/cumul_%s.txt",dossier_resultat,Identifiant.c_str());
        std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
        ofstrm.precision(16);
        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* analyse = ves_file->get_analyse(Identifiant);
          vector_analyse.push_back((MSTRUCT_ANALYSE_FEM_MAILLAGE*)analyse);
        }
        MSTRUCT_ANALYSE_FEM_MAILLAGE analyse_maillage_fem(vector_analyse);
        analyse_maillage_fem.exporter(ofstrm,nb_ves,true,avec_histogramme,dossier_resultat);
        ofstrm.close();
      }
      else
      {
        for(long j=0;j<Nb_couche;j++)
        {
          char nom_fichier_resultat[1000];
          char sys_mk_dossier[1000];
          char prefix_histo[1000];
          sprintf(sys_mk_dossier,"mkdir -p %s/c_%li",dossier_resultat,j);
          system(sys_mk_dossier);
          sprintf(nom_fichier_resultat,"%s/c_%li/cumul_%s.txt",dossier_resultat,j,Identifiant.c_str());
          sprintf(prefix_histo,"%s/c_%li/",dossier_resultat,j);
          std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
          ofstrm.precision(16);
          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(j));
          }
          MSTRUCT_ANALYSE_FEM_MAILLAGE analyse_maillage_fem(vector_analyse);
          analyse_maillage_fem.exporter(ofstrm,nb_ves,true,avec_histogramme,prefix_histo);
          ofstrm.close();
        }
      }
    }
  }
  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::exporter_modules_mecaniques(char* fichier_liste_ves_spherique,
                                             char* fichier_liste_ves_deviatorique,
                                             std::vector< OT_PARAMETRES* >& vector_params_ver,
                                             char* dossier_resultat)
{
  char message[5000];
  std::map<long,MSTRUCT_VES_FILE*> map_ves_file_spherique;  
  std::ifstream f;
  f.open(fichier_liste_ves_spherique,std::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,std::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");
    if(Analyse_erosion)
    {
      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_dev->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();
      char sys_mk_dossier[1000];
      char sous_dossier[1000];
      char nom_fichier_resultat[1000];
      for(long j=0;j<nb_couche;j++)
      {
        sprintf(ligne,"\033[1A\033[K-> Couche #%li",j);
        affiche(ligne);
        sprintf(sys_mk_dossier,"mkdir -p %s/c_%li",dossier_resultat,j);
        system(sys_mk_dossier);
        sprintf(sous_dossier,"%s/c_%li",dossier_resultat,j);
        sprintf(nom_fichier_resultat,"%s/c_%li/liste_modules_meca_%s_%s.txt",dossier_resultat,j,Identifiant_epsilon.c_str(),Identifiant_sigma.c_str());
        std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
        ofstrm.precision(16);
        it_ves_sph=map_ves_file_spherique.begin();
        it_ves_dev=map_ves_file_deviatorique.begin();
        std::vector<MSTRUCT_ANALYSE_MODULES_MECA*> vector_analyse;
        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;
          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);
          if(i==1) analyse_meca->exporter(ofstrm,i,true);
          else analyse_meca->exporter(ofstrm,i,false);
          delete analyse_meca;    
          i++;
        }
        ofstrm.close();
      }
      sprintf(ligne,"\033[1A\033[K");
      affiche(ligne);
    }
    else
    {
      char nom_fichier_resultat[1000];
      char sys_mk_dossier[1000];
      sprintf(nom_fichier_resultat,"%s/liste_modules_meca_%s_%s.txt",dossier_resultat,Identifiant_epsilon.c_str(),Identifiant_sigma.c_str());   
      std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
      ofstrm.precision(16);
      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_analyse;
      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(i==1) analyse_meca->exporter(ofstrm,i,true);
        else analyse_meca->exporter(ofstrm,i,false);
        delete analyse_meca;
        ofstrm.close();
        i++;
      }
    }    
  }
}

int MSTRUCT_VER::cumuler_modules_mecaniques(char* fichier_liste_ves_spherique,
                                            char* fichier_liste_ves_deviatorique,
                                            std::vector< OT_PARAMETRES* >& vector_params_ver,
                                            char* dossier_resultat,
                                            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,std::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,std::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");
    if(Analyse_erosion)
    {
      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_dev->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();
      char sys_mk_dossier[1000];
      char sous_dossier[1000];
      char nom_fichier_resultat[1000];
      for(long j=0;j<nb_couche;j++)
      {
        sprintf(ligne,"\033[1A\033[K-> Couche #%li",j);
        affiche(ligne);
        sprintf(sys_mk_dossier,"mkdir -p %s/c_%li",dossier_resultat,j);
        system(sys_mk_dossier);
        sprintf(sous_dossier,"%s/c_%li/",dossier_resultat,j);
        sprintf(nom_fichier_resultat,"%s/c_%li/cumul_modules_meca_%s_%s.txt",dossier_resultat,j,Identifiant_epsilon.c_str(),Identifiant_sigma.c_str());
        std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
        ofstrm.precision(16);
        it_ves_sph=map_ves_file_spherique.begin();
        it_ves_dev=map_ves_file_deviatorique.begin();
        std::vector<MSTRUCT_ANALYSE_MODULES_MECA*> vector_analyse;
        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_analyse.push_back(analyse_meca);  
        }
        
        MSTRUCT_ANALYSE_MODULES_MECA analyse_meca_globale(vector_analyse);
        analyse_meca_globale.exporter(ofstrm,nb_ves,true,avec_histogramme,sous_dossier);
        ofstrm.close();
        for(std::vector<MSTRUCT_ANALYSE_MODULES_MECA*>::iterator it_vct_analyse=vector_analyse.begin();it_vct_analyse!=vector_analyse.end();it_vct_analyse++) delete *it_vct_analyse;   
      }
      sprintf(ligne,"\033[1A\033[K");
      affiche(ligne);
    }
    else
    {
      char nom_fichier_resultat[1000];
      sprintf(nom_fichier_resultat,"%s/cumul_modules_meca_%s_%s.txt",dossier_resultat,Identifiant_epsilon.c_str(),Identifiant_sigma.c_str());
      std::ofstream ofstrm(nom_fichier_resultat,std::ios::out);
      ofstrm.precision(16);
      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_analyse;
      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);
        vector_analyse.push_back(analyse_meca);
      }
      MSTRUCT_ANALYSE_MODULES_MECA analyse_meca_globale(vector_analyse);
      analyse_meca_globale.exporter(ofstrm,nb_ves,true,avec_histogramme,dossier_resultat);
      ofstrm.close();
      for(std::vector<MSTRUCT_ANALYSE_MODULES_MECA*>::iterator it_vct_analyse=vector_analyse.begin();it_vct_analyse!=vector_analyse.end();it_vct_analyse++) delete *it_vct_analyse;
    }    
  }
}


Revision:	958
Committed:	Tue Aug 14 20:12:44 2018 UTC (6 years, 9 months ago) by couturad
File size:	33468 byte(s)
Log Message:	Correction des bugs detectes par Cppcheck