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);
    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)
    {
      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 if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::ORIENTATION)
    {
      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 if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CAO)
    {
      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 if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_MG)
    {
      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 if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_FEM)
    {
      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);
      }
    }
  }
  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");
    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++)
      {
        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,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;
      }     
      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=0;
      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);
          }
        }
      }
      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;
      }
    }    
  }
}


Revision:	930
Committed:	Tue May 15 15:50:32 2018 UTC (7 years ago) by couturad
File size:	17260 byte(s)
Log Message:	Mise a jour des fonctionnalites de MICROSTRUCTURE
#	User	Rev	Content
1	couturad	919	#include "mstruct_ver.h"
2	couturad	926	#include "mstruct_ves_file.h"
3	couturad	919	using namespace MICROSTRUCTURE;
4
5	couturad	926	MSTRUCT_VER::MSTRUCT_VER(void)
6	couturad	919	{
7
8			}
9
10	couturad	926	MSTRUCT_VER::~MSTRUCT_VER(void)
11	couturad	919	{
12
13			}
14
15	couturad	926	void MSTRUCT_VER::active_affichage(MICROSTRUCTURE::fonction_affiche* fonc)
16	couturad	919	{
17			fonc_affiche = fonc;
18			affichageactif = 1;
19			}
20
21	couturad	926	void MSTRUCT_VER::affiche(char* message)
22	couturad	919	{
23			if(affichageactif==1) fonc_affiche(message);
24			}
25
26	couturad	927	int MSTRUCT_VER::exporter_analyse(char* fichier_liste_ves,
27			std::vector< OT_PARAMETRES* >& vector_params_analyse,
28			char* dossier_resultat)
29			{
30			char message[5000];
31			std::map<long,MSTRUCT_VES_FILE*> map_ves_file;
32			std::ifstream f;
33			f.open(fichier_liste_ves,ios::in);
34			char ligne[1000];
35			f.getline(ligne,1000);
36			long i=0;
37			while(!f.eof())
38			{
39			char fichier_ves[1000];
40			sscanf(ligne,"%s",fichier_ves);
41			if(strlen(fichier_ves)==0) continue;
42			std::map<std::string,MSTRUCT_ANALYSE> map_analyse = new std::map<std::string,MSTRUCT_ANALYSE*>;
43			MSTRUCT_VES_FILE *ves_file=new MSTRUCT_VES_FILE;
44			if(ves_file->ouvrir(fichier_ves)==FAIL) return FAIL;
45			map_ves_file.insert(std::pair<long,MSTRUCT_VES_FILE*>(i,ves_file));
46			i++;
47			f.getline(ligne,1000);
48			}
49			f.close();
50			long nb_ves = map_ves_file.size();
51			sprintf(message,"NB_VES : %li",nb_ves); affiche(message);
52			std::vector<OT_PARAMETRES*>::iterator it;
53			for(it=vector_params_analyse.begin();it!=vector_params_analyse.end();it++)
54			{
55
56			OT_PARAMETRES* param = *it;
57			int Type_analyse = (int)param->get_valeur((char*)"Type_analyse");
58			std::string Identifiant = param->get_nom((char*)"Identifiant");
59			sprintf(message,"-> %s",Identifiant.c_str()); affiche(message);
60			char nom_fichier_resultat[500];
61			sprintf(nom_fichier_resultat,"%s%s.txt",dossier_resultat,Identifiant.c_str());
62			ofstream ofstrm(nom_fichier_resultat,ios::out);
63			ofstrm.precision(16);
64			std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
65			i=1;
66			for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
67			{
68			MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
69			MSTRUCT_ANALYSE* analyse = ves_file->get_analyse(Identifiant);
70			if(analyse==NULL)
71			{
72			std::cerr << "* MSTRUCT_VER::exporter_analyse : Erreur *" << std::endl;
73			return FAIL;
74			}
75			analyse->exporter(ofstrm,i);
76			i++;
77			}
78			}
79			std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
80			for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
81			{
82			delete it_ves_file->second;
83			}
84			}
85
86
87	couturad	926	int MSTRUCT_VER::cumuler_analyse(char* fichier_liste_ves,
88			std::vector< OT_PARAMETRES* >& vector_params_analyse,
89			char* dossier_resultat,
90			bool resultats_incrementaux,
91			bool avec_histogramme)
92	couturad	919	{
93	couturad	927
94	couturad	926	char message[5000];
95			std::map<long,MSTRUCT_VES_FILE*> map_ves_file;
96	couturad	919	std::ifstream f;
97			f.open(fichier_liste_ves,ios::in);
98			char ligne[1000];
99			f.getline(ligne,1000);
100	couturad	926	long i=0;
101	couturad	919	while(!f.eof())
102			{
103			char fichier_ves[1000];
104			sscanf(ligne,"%s",fichier_ves);
105			if(strlen(fichier_ves)==0) continue;
106	couturad	926	std::map<std::string,MSTRUCT_ANALYSE> map_analyse = new std::map<std::string,MSTRUCT_ANALYSE*>;
107			MSTRUCT_VES_FILE *ves_file=new MSTRUCT_VES_FILE;
108			if(ves_file->ouvrir(fichier_ves)==FAIL) return FAIL;
109			map_ves_file.insert(std::pair<long,MSTRUCT_VES_FILE*>(i,ves_file));
110			i++;
111	couturad	919	f.getline(ligne,1000);
112			}
113			f.close();
114	couturad	926	long nb_ves = map_ves_file.size();
115			sprintf(message,"NB_VES : %li",nb_ves); affiche(message);
116			std::vector<OT_PARAMETRES*>::iterator it;
117			for(it=vector_params_analyse.begin();it!=vector_params_analyse.end();it++)
118	couturad	919	{
119	couturad	926
120			OT_PARAMETRES* param = *it;
121			int Type_analyse = (int)param->get_valeur((char*)"Type_analyse");
122			std::string Identifiant = param->get_nom((char*)"Identifiant");
123			sprintf(message,"-> %s",Identifiant.c_str()); affiche(message);
124			char nom_fichier_resultat[500];
125			sprintf(nom_fichier_resultat,"%s%s.txt",dossier_resultat,Identifiant.c_str());
126			ofstream ofstrm(nom_fichier_resultat,ios::out);
127			ofstrm.precision(16);
128			if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CHAMP)
129	couturad	919	{
130	couturad	926	std::vector<MSTRUCT_ANALYSE_CHAMP*> vector_analyse;
131			std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
132			i=1;
133			for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
134			{
135			MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
136			MSTRUCT_ANALYSE* analyse = ves_file->get_analyse(Identifiant);
137			if(analyse==NULL)
138			{
139			std::cerr << "* MSTRUCT_VER::cumuler_analyse : Erreur *" << std::endl;
140			return FAIL;
141			}
142			vector_analyse.push_back((MSTRUCT_ANALYSE_CHAMP*)analyse);
143			if(resultats_incrementaux)
144			{
145			MSTRUCT_ANALYSE_CHAMP analyse_champ(vector_analyse);
146			analyse_champ.exporter(ofstrm,i,avec_histogramme,dossier_resultat);
147			}
148			i++;
149			}
150			if(!resultats_incrementaux)
151			{
152			MSTRUCT_ANALYSE_CHAMP analyse_champ(vector_analyse);
153	couturad	927	analyse_champ.exporter(ofstrm,1,avec_histogramme,dossier_resultat);
154	couturad	926	}
155	couturad	919	}
156	couturad	926	else if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::ORIENTATION)
157	couturad	919	{
158	couturad	926	std::vector<MSTRUCT_ANALYSE_ORIENTATION*> vector_analyse;
159			std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
160			i=1;
161			for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
162			{
163			MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
164			MSTRUCT_ANALYSE* analyse = ves_file->get_analyse(Identifiant);
165			if(analyse==NULL)
166			{
167			std::cerr << "* MSTRUCT_VER::cumuler_analyse : Erreur *" << std::endl;
168			return FAIL;
169			}
170			vector_analyse.push_back((MSTRUCT_ANALYSE_ORIENTATION*)analyse);
171			if(resultats_incrementaux)
172			{
173			MSTRUCT_ANALYSE_ORIENTATION analyse_orientation(vector_analyse);
174			analyse_orientation.exporter(ofstrm,i,avec_histogramme,dossier_resultat);
175			}
176			i++;
177			}
178			if(!resultats_incrementaux)
179			{
180			MSTRUCT_ANALYSE_ORIENTATION analyse_orientation(vector_analyse);
181	couturad	927	analyse_orientation.exporter(ofstrm,1,avec_histogramme,dossier_resultat);
182	couturad	926	}
183	couturad	919	}
184	couturad	926	else if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::CAO)
185	couturad	919	{
186	couturad	926	std::vector<MSTRUCT_ANALYSE_CAO*> vector_analyse;
187			std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
188			i=1;
189			for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
190			{
191			MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
192			MSTRUCT_ANALYSE* analyse = ves_file->get_analyse(Identifiant);
193			if(analyse==NULL)
194			{
195			std::cerr << "* MSTRUCT_VER::cumuler_analyse : Erreur *" << std::endl;
196			return FAIL;
197			}
198			vector_analyse.push_back((MSTRUCT_ANALYSE_CAO*)analyse);
199			if(resultats_incrementaux)
200			{
201			MSTRUCT_ANALYSE_CAO analyse_cao(vector_analyse);
202			analyse_cao.exporter(ofstrm,i,avec_histogramme,dossier_resultat);
203			}
204			i++;
205			}
206			if(!resultats_incrementaux)
207			{
208			MSTRUCT_ANALYSE_CAO analyse_orientation(vector_analyse);
209	couturad	927	analyse_orientation.exporter(ofstrm,1,avec_histogramme,dossier_resultat);
210	couturad	926	}
211	couturad	919	}
212	couturad	926	else if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_MG)
213	couturad	919	{
214	couturad	926	std::vector<MSTRUCT_ANALYSE_MG_MAILLAGE*> vector_analyse;
215			std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
216			i=1;
217			for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
218			{
219			MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
220			MSTRUCT_ANALYSE* analyse = ves_file->get_analyse(Identifiant);
221			if(analyse==NULL)
222			{
223			std::cerr << "* MSTRUCT_VER::cumuler_analyse : Erreur *" << std::endl;
224			return FAIL;
225			}
226			vector_analyse.push_back((MSTRUCT_ANALYSE_MG_MAILLAGE*)analyse);
227			if(resultats_incrementaux)
228			{
229			MSTRUCT_ANALYSE_MG_MAILLAGE analyse_mg_maillage(vector_analyse);
230			analyse_mg_maillage.exporter(ofstrm,i,avec_histogramme,dossier_resultat);
231			}
232			i++;
233			}
234			if(!resultats_incrementaux)
235			{
236			MSTRUCT_ANALYSE_MG_MAILLAGE analyse_mg_maillage(vector_analyse);
237	couturad	927	analyse_mg_maillage.exporter(ofstrm,1,avec_histogramme,dossier_resultat);
238	couturad	926	}
239	couturad	919	}
240	couturad	926	else if(Type_analyse==MSTRUCT_ANALYSE::TYPE_ANALYSE::MAILLAGE_FEM)
241	couturad	919	{
242	couturad	926	std::vector<MSTRUCT_ANALYSE_FEM_MAILLAGE*> vector_analyse;
243			std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
244			i=1;
245			for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
246			{
247			MSTRUCT_VES_FILE *ves_file=it_ves_file->second;
248			MSTRUCT_ANALYSE* analyse = ves_file->get_analyse(Identifiant);
249			if(analyse==NULL)
250			{
251			std::cerr << "* MSTRUCT_VER::cumuler_analyse : Erreur *" << std::endl;
252			return FAIL;
253			}
254			vector_analyse.push_back((MSTRUCT_ANALYSE_FEM_MAILLAGE*)analyse);
255			if(resultats_incrementaux)
256			{
257			MSTRUCT_ANALYSE_FEM_MAILLAGE analyse_fem_maillage(vector_analyse);
258			analyse_fem_maillage.exporter(ofstrm,i,avec_histogramme,dossier_resultat);
259			}
260			i++;
261			}
262			if(!resultats_incrementaux)
263			{
264			MSTRUCT_ANALYSE_FEM_MAILLAGE analyse_fem_maillage(vector_analyse);
265	couturad	927	analyse_fem_maillage.exporter(ofstrm,1,avec_histogramme,dossier_resultat);
266	couturad	926	}
267	couturad	919	}
268			}
269	couturad	926	std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_file;
270			for(it_ves_file=map_ves_file.begin();it_ves_file!=map_ves_file.end();it_ves_file++)
271	couturad	919	{
272	couturad	926	delete it_ves_file->second;
273	couturad	919	}
274			return OK;
275			}
276
277	couturad	926	int MSTRUCT_VER::calculer_modules_mecaniques(char* fichier_liste_ves_spherique,
278			char* fichier_liste_ves_deviatorique,
279	couturad	930	std::vector< OT_PARAMETRES* >& vector_params_ver,
280	couturad	926	char* dossier_resultat,
281	couturad	927	bool cumuler,
282	couturad	926	bool resultats_incrementaux,
283			bool avec_histogramme)
284	couturad	919	{
285	couturad	926	char message[5000];
286			std::map<long,MSTRUCT_VES_FILE*> map_ves_file_spherique;
287			std::ifstream f;
288			f.open(fichier_liste_ves_spherique,ios::in);
289			char ligne[1000];
290			f.getline(ligne,1000);
291			long i=0;
292			while(!f.eof())
293	couturad	919	{
294	couturad	926	char fichier_ves[1000];
295			sscanf(ligne,"%s",fichier_ves);
296			if(strlen(fichier_ves)==0) continue;
297			std::map<std::string,MSTRUCT_ANALYSE> map_analyse = new std::map<std::string,MSTRUCT_ANALYSE*>;
298			MSTRUCT_VES_FILE *ves_file=new MSTRUCT_VES_FILE;
299			if(ves_file->ouvrir(fichier_ves)==FAIL) return FAIL;
300			map_ves_file_spherique.insert(std::pair<long,MSTRUCT_VES_FILE*>(i,ves_file));
301			i++;
302			f.getline(ligne,1000);
303	couturad	919	}
304	couturad	926	f.close();
305			std::map<long,MSTRUCT_VES_FILE*> map_ves_file_deviatorique;
306			f.open(fichier_liste_ves_deviatorique,ios::in);
307			f.getline(ligne,1000);
308			i=0;
309			while(!f.eof())
310	couturad	919	{
311	couturad	926	char fichier_ves[1000];
312			sscanf(ligne,"%s",fichier_ves);
313			if(strlen(fichier_ves)==0) continue;
314			std::map<std::string,MSTRUCT_ANALYSE> map_analyse = new std::map<std::string,MSTRUCT_ANALYSE*>;
315			MSTRUCT_VES_FILE *ves_file=new MSTRUCT_VES_FILE;
316			if(ves_file->ouvrir(fichier_ves)==FAIL) return FAIL;
317			map_ves_file_deviatorique.insert(std::pair<long,MSTRUCT_VES_FILE*>(i,ves_file));
318			i++;
319			f.getline(ligne,1000);
320	couturad	919	}
321	couturad	926	f.close();
322			if(map_ves_file_spherique.size()!=map_ves_file_deviatorique.size())
323	couturad	919	{
324	couturad	926	std::cerr << "* MSTRUCT_VER::calculer_module_young : Liste non identique *" << std::endl;
325	couturad	919	return FAIL;
326			}
327	couturad	926	long nb_ves = map_ves_file_spherique.size();
328			sprintf(message,"NB_VES : %li",nb_ves); affiche(message);
329			std::vector<OT_PARAMETRES*>::iterator it;
330			for(it=vector_params_ver.begin();it!=vector_params_ver.end();it++)
331	couturad	919	{
332	couturad	930	OT_PARAMETRES param = it;
333	couturad	926	std::string Identifiant_epsilon = param->get_nom((char*)"Identifiant_epsilon");
334			std::string Identifiant_sigma = param->get_nom((char*)"Identifiant_sigma");
335	couturad	927	double Largeur_colonne_distribution_module_Kapp = param->get_valeur((char*)"Largeur_colonne_distribution_module_Kapp");
336			double Largeur_colonne_distribution_module_Gapp = param->get_valeur((char*)"Largeur_colonne_distribution_module_Gapp");
337			double Largeur_colonne_distribution_module_Eapp = param->get_valeur((char*)"Largeur_colonne_distribution_module_Eapp");
338			double Largeur_colonne_distribution_module_Nuapp = param->get_valeur((char*)"Largeur_colonne_distribution_module_Nuapp");
339	couturad	930	int Analyse_erosion = (int)param->get_valeur((char*)"Analyse_erosion");
340	couturad	926	char nom_fichier_resultat[500];
341	couturad	927	sprintf(nom_fichier_resultat,"%sModules_meca_%s_%s.txt",dossier_resultat,Identifiant_epsilon.c_str(),Identifiant_sigma.c_str());
342	couturad	926	ofstream ofstrm(nom_fichier_resultat,ios::out);
343	couturad	930	ofstrm.precision(16);
344			if(Analyse_erosion)
345	couturad	919	{
346	couturad	930	cumuler=true;
347			resultats_incrementaux=false;
348			avec_histogramme=false;
349			std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_sph=map_ves_file_spherique.begin();
350			std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_dev=map_ves_file_deviatorique.begin();
351			MSTRUCT_VES_FILE* file_sph=it_ves_sph->second;
352			MSTRUCT_VES_FILE* file_dev=it_ves_sph->second;
353			MSTRUCT_ANALYSE_EROSION* analyse_erosion_epsilon_sph = (MSTRUCT_ANALYSE_EROSION*)file_sph->get_analyse(Identifiant_epsilon);
354			MSTRUCT_ANALYSE_EROSION* analyse_erosion_sigma_sph = (MSTRUCT_ANALYSE_EROSION*)file_sph->get_analyse(Identifiant_sigma);
355			MSTRUCT_ANALYSE_EROSION* analyse_erosion_epsilon_dev = (MSTRUCT_ANALYSE_EROSION*)file_dev->get_analyse(Identifiant_epsilon);
356			MSTRUCT_ANALYSE_EROSION* analyse_erosion_sigma_dev = (MSTRUCT_ANALYSE_EROSION*)file_dev->get_analyse(Identifiant_sigma);
357			long nb_couche=analyse_erosion_epsilon_sph->get_nb_couche();
358			double epaisseur_couche = analyse_erosion_epsilon_sph->get_epaisseur_couche();
359			for(long j=0;j<nb_couche;j++)
360	couturad	926	{
361	couturad	930	it_ves_sph=map_ves_file_spherique.begin();
362			it_ves_dev=map_ves_file_deviatorique.begin();
363			std::vector<MSTRUCT_ANALYSE_MODULES_MECA*> vector_module_meca;
364			for(;it_ves_sph!=map_ves_file_spherique.end();it_ves_sph++,it_ves_dev++)
365	couturad	926	{
366	couturad	930	file_sph=it_ves_sph->second;
367			file_dev=it_ves_dev->second;
368			analyse_erosion_epsilon_sph = (MSTRUCT_ANALYSE_EROSION*)file_sph->get_analyse(Identifiant_epsilon);
369			analyse_erosion_sigma_sph = (MSTRUCT_ANALYSE_EROSION*)file_sph->get_analyse(Identifiant_sigma);
370			analyse_erosion_epsilon_dev = (MSTRUCT_ANALYSE_EROSION*)file_dev->get_analyse(Identifiant_epsilon);
371			analyse_erosion_sigma_dev = (MSTRUCT_ANALYSE_EROSION*)file_dev->get_analyse(Identifiant_sigma);
372			MSTRUCT_ANALYSE_CHAMP* epsilon_sph=(MSTRUCT_ANALYSE_CHAMP*)analyse_erosion_epsilon_sph->get_analyse(j);
373			MSTRUCT_ANALYSE_CHAMP* sigma_sph=(MSTRUCT_ANALYSE_CHAMP*)analyse_erosion_sigma_sph->get_analyse(j);
374			MSTRUCT_ANALYSE_CHAMP* epsilon_dev=(MSTRUCT_ANALYSE_CHAMP*)analyse_erosion_epsilon_dev->get_analyse(j);
375			MSTRUCT_ANALYSE_CHAMP* sigma_dev=(MSTRUCT_ANALYSE_CHAMP*)analyse_erosion_sigma_dev->get_analyse(j);
376			MSTRUCT_ANALYSE_MODULES_MECA* analyse_meca = new MSTRUCT_ANALYSE_MODULES_MECA(epsilon_sph,
377			sigma_sph,
378			epsilon_dev,
379			sigma_dev,
380			Largeur_colonne_distribution_module_Kapp,
381			Largeur_colonne_distribution_module_Gapp,
382			Largeur_colonne_distribution_module_Eapp,
383			Largeur_colonne_distribution_module_Nuapp);
384			vector_module_meca.push_back(analyse_meca);
385	couturad	926	}
386	couturad	930	MSTRUCT_ANALYSE_MODULES_MECA analyse_meca_glob(vector_module_meca);
387			analyse_meca_glob.exporter(ofstrm,j,false);
388			std::vector<MSTRUCT_ANALYSE_MODULES_MECA*>::iterator it_vector_meca;
389			for(it_vector_meca=vector_module_meca.begin();it_vector_meca!=vector_module_meca.end();it_vector_meca++) delete *it_vector_meca;
390			}
391			ofstrm.close();
392	couturad	919	}
393	couturad	930	else
394	couturad	926	{
395	couturad	930	std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_sph=map_ves_file_spherique.begin();
396			std::map<long,MSTRUCT_VES_FILE*>::iterator it_ves_dev=map_ves_file_deviatorique.begin();
397			MSTRUCT_VES_FILE* file_sph;
398			MSTRUCT_VES_FILE* file_dev;
399			std::vector<MSTRUCT_ANALYSE_MODULES_MECA*> vector_module_meca;
400			i=0;
401			for(;it_ves_sph!=map_ves_file_spherique.end();it_ves_sph++,it_ves_dev++)
402			{
403			file_sph=it_ves_sph->second;
404			file_dev=it_ves_dev->second;
405			MSTRUCT_ANALYSE_CHAMP* epsilon_sph=(MSTRUCT_ANALYSE_CHAMP*)file_sph->get_analyse(Identifiant_epsilon);
406			MSTRUCT_ANALYSE_CHAMP* sigma_sph=(MSTRUCT_ANALYSE_CHAMP*)file_sph->get_analyse(Identifiant_sigma);
407			MSTRUCT_ANALYSE_CHAMP* epsilon_dev=(MSTRUCT_ANALYSE_CHAMP*)file_dev->get_analyse(Identifiant_epsilon);
408			MSTRUCT_ANALYSE_CHAMP* sigma_dev=(MSTRUCT_ANALYSE_CHAMP*)file_dev->get_analyse(Identifiant_sigma);
409			MSTRUCT_ANALYSE_MODULES_MECA* analyse_meca = new MSTRUCT_ANALYSE_MODULES_MECA(epsilon_sph,
410			sigma_sph,
411			epsilon_dev,
412			sigma_dev,
413			Largeur_colonne_distribution_module_Kapp,
414			Largeur_colonne_distribution_module_Gapp,
415			Largeur_colonne_distribution_module_Eapp,
416			Largeur_colonne_distribution_module_Nuapp);
417
418			if(!cumuler)
419	couturad	926	{
420	couturad	930	analyse_meca->exporter(ofstrm,i,false);
421			delete analyse_meca;
422	couturad	926	}
423	couturad	930	else
424	couturad	926	{
425	couturad	930	vector_module_meca.push_back(analyse_meca);
426			if(resultats_incrementaux)
427			{
428			MSTRUCT_ANALYSE_MODULES_MECA analyse_meca_glob(vector_module_meca);
429			analyse_meca_glob.exporter(ofstrm,i,false);
430			}
431	couturad	926	}
432	couturad	930	}
433			if(cumuler)
434			{
435			MSTRUCT_ANALYSE_MODULES_MECA analyse_meca_glob(vector_module_meca);
436			analyse_meca_glob.exporter(ofstrm,i,avec_histogramme,dossier_resultat);
437			std::vector<MSTRUCT_ANALYSE_MODULES_MECA*>::iterator it_vector_meca;
438			for(it_vector_meca=vector_module_meca.begin();it_vector_meca!=vector_module_meca.end();it_vector_meca++) delete *it_vector_meca;
439			}
440	couturad	926	}
441	couturad	930	}
442	couturad	919	}
443
444
445
446
447
448	couturad	926
449
450
451
452
453
454
455
456
457
458
459
460
461