microstructure/src/main.cpp

//------------------------------------------------------------
//------------------------------------------------------------
//  MAGiC
//  Jean Christophe Cuilli�re et Vincent FRANCOIS
//  D�partement de G�nie M�canique - UQTR
//------------------------------------------------------------
//  Le projet MAGIC est un projet de recherche du d�partement
//  de g�nie m�canique de l'Universit� du Qu�bec �
//  Trois Rivi�res
//  Les librairies ne peuvent �tre utilis�es sans l'accord
//  des auteurs (contact : francois@uqtr.ca)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       main.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 � 11H25
//------------------------------------------------------------
//------------------------------------------------------------


#include "gestionversion.h"
#include "magic_application.h"
#include "mstruct_ves.h"
#include "mstruct_ver.h"
#include "mstruct_parametres.h"
#include "mg_gestionnaire.h"
#include "mg_file.h"
#include "fct_taille_fem_solution.h"
#include "mstruct_ves_file.h"
#include "mstruct_generateur_polycristaux.h"
#ifdef ALL_OCC
#include "occ_import.h"
#endif
//---------------------------------------------------------------------------


int main(int argc,char **argv)
{
std::vector<MAGIC_PARAMETRE_APPLICATION> lst;
// p_in(1) -in
// p_out(2) -out
MAGIC_PARAMETRE_APPLICATION p3(3,(char*)"-ves_in",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier VES d'entree");
MAGIC_PARAMETRE_APPLICATION p4(4,(char*)"-ves_out",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier VES de sortie");
MAGIC_PARAMETRE_APPLICATION p5(5,(char*)"-carte",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Carte de taille FEM solution");
MAGIC_PARAMETRE_APPLICATION p6(6,(char*)"-dossier",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Dossier de resultat");
MAGIC_PARAMETRE_APPLICATION p7(7,(char*)"-param",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier de parametres");
MAGIC_PARAMETRE_APPLICATION p8(8,(char*)"-lstparam",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier listant plusieurs fichiers de parametres");
MAGIC_PARAMETRE_APPLICATION p9(9,(char*)"-paramaster",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier de parametre aster");
MAGIC_PARAMETRE_APPLICATION p10(10,(char*)"-type_generateur",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Type de generateur : [0] RSA, [1] DCR");
MAGIC_PARAMETRE_APPLICATION p11(11,(char*)"-type_inclusion",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Type d'inclusion : [0] Sphere, [1] Cylindre");
MAGIC_PARAMETRE_APPLICATION p12(12,(char*)"-type_maillage",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Type de maillage : [0] lineaire, [1] quadratique, [2] lineaire et quadratique");
MAGIC_PARAMETRE_APPLICATION p13(13,(char*)"-type_etude",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Type d'etude : [0] mecanique, [1] thermique, [2] mecanique et thermique");
MAGIC_PARAMETRE_APPLICATION p14(14,(char*)"-nb_couche_erosion",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Nombre de couche d'erosion (defaut = 0)");
MAGIC_PARAMETRE_APPLICATION p15(15,(char*)"-epaisseur_couche_erosion",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Epaisseur d'une couche d'erosion (defaut = 0.02)");
MAGIC_PARAMETRE_APPLICATION p16(16,(char*)"-ves_sph",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier VES chargement spherique");
MAGIC_PARAMETRE_APPLICATION p17(17,(char*)"-ves_dev",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier VES chargement deviatorique");
MAGIC_PARAMETRE_APPLICATION p18(18,(char*)"-lstves",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Liste de VES");
MAGIC_PARAMETRE_APPLICATION p19(19,(char*)"-eps",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Distance max entre la triangulation et la géométrie");
MAGIC_PARAMETRE_APPLICATION p20(20,(char*)"-creeparam",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Creer une structure de parametres");
MAGIC_PARAMETRE_APPLICATION p21(21,(char*)"-gen_geo",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Generer la geometrie");
MAGIC_PARAMETRE_APPLICATION p22(22,(char*)"-gen_mat",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Generer les materiaux");
MAGIC_PARAMETRE_APPLICATION p23(23,(char*)"-gen_carte",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Generer la carte de taille");
MAGIC_PARAMETRE_APPLICATION p24(24,(char*)"-gen_mg_maill",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Generer le MG maillage");
MAGIC_PARAMETRE_APPLICATION p25(25,(char*)"-gen_fem_maill",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Generer le FEM maillage");
MAGIC_PARAMETRE_APPLICATION p26(26,(char*)"-gen_etude",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Generer l'etude");
MAGIC_PARAMETRE_APPLICATION p27(27,(char*)"-gen_calcul",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Lancer la resolution numerique");
MAGIC_PARAMETRE_APPLICATION p28(28,(char*)"-gen_post_traitement",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Generer le post-traitement des resultats");
MAGIC_PARAMETRE_APPLICATION p29(29,(char*)"-cumuler_post_traitement",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Cumuler les post-traitement d'une liste de VES");
MAGIC_PARAMETRE_APPLICATION p30(30,(char*)"-affiche_contenu",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Affiche le contenu d'un fichier VES");
MAGIC_PARAMETRE_APPLICATION p31(31,(char*)"-export_tristl",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Exportation de la triangulation STL de la microstructure");
MAGIC_PARAMETRE_APPLICATION p32(32,(char*)"-export_maill_abaqus",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Exportation du maillage au format ABAQUS");
MAGIC_PARAMETRE_APPLICATION p33(33,(char*)"-creeparampoly",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Création d'un fichier de paramétres");
MAGIC_PARAMETRE_APPLICATION p34(34,(char*)"-polycristaux",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"génération d'un polycristal");
MAGIC_PARAMETRE_APPLICATION p35(35,(char*)"-ves_lambda_x",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier VES lambda x");
MAGIC_PARAMETRE_APPLICATION p36(36,(char*)"-ves_lambda_y",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier VES lambda y");
MAGIC_PARAMETRE_APPLICATION p37(37,(char*)"-ves_lambda_z",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier VES lambda z");
MAGIC_PARAMETRE_APPLICATION p38(38,(char*)"-compress_histo",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Compresser un fichier histogramme (.txt) selon une largeur de colonne");
MAGIC_PARAMETRE_APPLICATION p39(39,(char*)"-largeur",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Largeur de colonne");
MAGIC_PARAMETRE_APPLICATION p40(40,(char*)"-exportpoint",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Exportation des points qui ont généré les cristaux");

p20.ajouter_dependance(10);p20.ajouter_dependance(11);p20.ajouter_dependance(12);p20.ajouter_dependance(13);p20.ajouter_dependance(14);p20.ajouter_dependance(15);
p21.ajouter_dependance(4);p21.ajouter_dependance(7);p21.ajouter_dependance(8);
p22.ajouter_dependance(3);p22.ajouter_dependance(4);p22.ajouter_dependance(7);p22.ajouter_dependance(8);
p23.ajouter_dependance(3);p23.ajouter_dependance(4);p23.ajouter_dependance(7);
p24.ajouter_dependance(3);p24.ajouter_dependance(4);p24.ajouter_dependance(7);p24.ajouter_dependance(5);
p25.ajouter_dependance(3);p25.ajouter_dependance(4);p25.ajouter_dependance(7);
p26.ajouter_dependance(3);p26.ajouter_dependance(4);p26.ajouter_dependance(7);
p27.ajouter_dependance(3);p27.ajouter_dependance(4);p27.ajouter_dependance(7);p27.ajouter_dependance(9);
p28.ajouter_dependance(3);p28.ajouter_dependance(4);p28.ajouter_dependance(7);p28.ajouter_dependance(8);p28.ajouter_dependance(16);p28.ajouter_dependance(17);p28.ajouter_dependance(35);p28.ajouter_dependance(36);p28.ajouter_dependance(37);
p29.ajouter_dependance(7);p29.ajouter_dependance(8);p29.ajouter_dependance(6);
p30.ajouter_dependance(3);
p31.ajouter_dependance(3);p31.ajouter_dependance(2);p31.ajouter_dependance(19);
p32.ajouter_dependance(3);p32.ajouter_dependance(6);
p34.ajouter_dependance(1);p34.ajouter_dependance(2);p34.ajouter_dependance(7);p34.ajouter_dependance(33);p34.ajouter_dependance(40);
p38.ajouter_dependance(1);p38.ajouter_dependance(2);p38.ajouter_dependance(39);

lst.push_back(p3);
lst.push_back(p4);
lst.push_back(p5);
lst.push_back(p6);
lst.push_back(p7);
lst.push_back(p8);
lst.push_back(p9);
lst.push_back(p10);
lst.push_back(p11);
lst.push_back(p12);
lst.push_back(p13);
lst.push_back(p14);
lst.push_back(p15);
lst.push_back(p16);
lst.push_back(p17);
lst.push_back(p18);
lst.push_back(p19);
lst.push_back(p20);
lst.push_back(p21);
lst.push_back(p22);
lst.push_back(p23);
lst.push_back(p24);
lst.push_back(p25);
lst.push_back(p26);
lst.push_back(p27);
lst.push_back(p28);
lst.push_back(p29);
lst.push_back(p30);
lst.push_back(p31);
lst.push_back(p32);
lst.push_back(p33);
lst.push_back(p34);
lst.push_back(p35);
lst.push_back(p36);
lst.push_back(p37);
lst.push_back(p38);
lst.push_back(p39);
lst.push_back(p40);

MAGIC_APPLICATION app((char*)"Homogeneisation d'une microstructure",argc,argv,lst,true,true);
if(app.get_erreur()==true) return 0;

if(app.get_action()==20)
{
  app.affiche((char*)"***********************************************");
  app.affiche((char*)"***   Creation des fichiers de parametres   ***");
  app.affiche((char*)"***********************************************");
  int type_generateur;
  int type_inclusion;
  int type_maillage;
  int type_etude;
  int nb_couche;
  double epaisseur_couche;
  app.recupere_parametre_int(10,type_generateur,(char*)"Type de generateur manquant");
  app.recupere_parametre_int(11,type_inclusion,(char*)"Type d'inclusion manquant");
  app.recupere_parametre_int(12,type_maillage,(char*)"Type de maillage manquant");
  app.recupere_parametre_int(13,type_etude,(char*)"Type d'etude manquant");
  app.recupere_parametre_double_avec_defaut(15,epaisseur_couche,0.02);
  app.recupere_parametre_int_avec_defaut(14,nb_couche,0);
  if (app.get_erreur()==true) return 0;
  bool maillage_lin=false;
  bool maillage_quad=false;
  if(type_maillage==0) maillage_lin=true;
  else if(type_maillage==1) maillage_quad=true;
  else {maillage_lin=true;maillage_quad=true;}
  bool etude_mecanique=false;
  bool etude_thermique=false;
  if(type_etude==0) etude_mecanique=true;
  else if(type_etude==1) etude_thermique=true;
  else if(type_etude==2){etude_mecanique=true;etude_thermique=true;}
  PARAMETRES::generer_fichier_parametres(etude_mecanique,etude_thermique,type_generateur,type_inclusion,maillage_lin,maillage_quad,nb_couche,epaisseur_couche,app.affiche);  
  PARAMETRES::generer_script_ves(etude_mecanique,etude_thermique,type_inclusion,maillage_lin,maillage_quad,app.affiche);
  PARAMETRES::generer_script_post_traitement(etude_mecanique,etude_thermique,type_inclusion,maillage_lin,maillage_quad,epaisseur_couche,app.affiche);
}


if(app.get_action()==21)
{
  app.affiche((char*)"**************************************");
  app.affiche((char*)"***   Generation de la geometrie   ***");
  app.affiche((char*)"**************************************");
  char fichier_ves_out[500];
  char fichier_param[500];
  char fichier_lstparam[500];
  app.recupere_parametre_string(4,fichier_ves_out,(char*)"Fichier VES de sortie manquant");
  app.recupere_parametre_string_avec_defaut(7,fichier_param,(char*)"");
  app.recupere_parametre_string_avec_defaut(8,fichier_lstparam,(char*)"");  
  if (app.get_erreur()==true) return 0;
  std::string str_fichier_ves_out = fichier_ves_out;
  size_t found = str_fichier_ves_out.rfind((char*)".");
  std::string str_fichier_magic_out = str_fichier_ves_out.substr(0,found);
  str_fichier_magic_out.append((char*)".magic");
  if(strlen(fichier_param)>0 && strlen(fichier_lstparam)>0)
  {
    app.affiche_erreur((char*)"Une seule valeur pour -param OU -lstparam doit etre fournie");
    return 0;
  }
  if(strlen(fichier_param)>0)
  {
    std::vector<OT_PARAMETRES*> vector_param_geometrie;
    OT_PARAMETRES* param_geometrie = new OT_PARAMETRES;    
    char message[5000];
    if(PARAMETRES::importer_fichier_parametres(fichier_param,param_geometrie)==FAIL)
    {
      std::sprintf(message,"ERREUR lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
      app.affiche(message);
      return 1;
    }
    std::sprintf(message,"Lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
    app.affiche(message);
    vector_param_geometrie.push_back(param_geometrie);
    MSTRUCT_VES ves;
    ves.active_affichage(app.affiche);
    if(ves.generer_geometrie(vector_param_geometrie)==FAIL)
    {
      delete param_geometrie;
      return 1;
    }
    ves.enregistrer(fichier_ves_out,(char*)str_fichier_magic_out.c_str());
    delete param_geometrie;
  }
  else if(strlen(fichier_lstparam)>0)
  {
    std::vector<OT_PARAMETRES*> vector_param_geometrie;
    char message[5000];
    if(PARAMETRES::importer_fichier_liste_parametres(fichier_lstparam,vector_param_geometrie)==FAIL)
    {
      std::sprintf(message,"ERREUR lecture du fichier de liste de parametres : \033[38;5;46m%s\033[1;33m",fichier_lstparam);
      app.affiche(message);
      return 1;
    }    
    std::sprintf(message,"Lecture du fichier de liste de parametres : \033[38;5;46m%s\033[1;33m",fichier_lstparam);
    app.affiche(message);
    MSTRUCT_VES ves;
    ves.active_affichage(app.affiche);
    if(ves.generer_geometrie(vector_param_geometrie)==FAIL)
    {
      std::vector<OT_PARAMETRES*>::iterator it_vector;
      for(it_vector=vector_param_geometrie.begin();it_vector!=vector_param_geometrie.end();it_vector++)
      {
        delete *it_vector;
      }
      return 1;
    }
    ves.enregistrer(fichier_ves_out,(char*)str_fichier_magic_out.c_str());
    std::vector<OT_PARAMETRES*>::iterator it_vector;
    for(it_vector=vector_param_geometrie.begin();it_vector!=vector_param_geometrie.end();it_vector++)
    {
      delete *it_vector;
    }
  }
  char message[5000];
  std::sprintf(message,"Fichier VES de sortie : \033[38;5;46m%s\033[1;33m",fichier_ves_out);
  app.affiche(message);
  std::sprintf(message,"Fichier MAGIC de sortie : \033[38;5;46m%s\033[1;33m",str_fichier_magic_out.c_str());
  app.affiche(message);
}

if(app.get_action()==22)
{
  app.affiche((char*)"************************************");
  app.affiche((char*)"***   Generation des materiaux   ***");
  app.affiche((char*)"************************************");
  char fichier_ves_in[500];
  char fichier_ves_out[500];
  char fichier_param[500];
  char fichier_lstparam[500];
  app.recupere_parametre_string(3,fichier_ves_in,(char*)"Fichier VES de entrant manquant");
  app.recupere_parametre_string(4,fichier_ves_out,(char*)"Fichier VES de sortie manquant");
  app.recupere_parametre_string_avec_defaut(7,fichier_param,(char*)"");
  app.recupere_parametre_string_avec_defaut(8,fichier_lstparam,(char*)""); 
  if (app.get_erreur()==true) return 0;
  char message[5000];
  std::sprintf(message,"Fichier VES d'entree : \033[38;5;46m%s\033[1;33m",fichier_ves_in);
  app.affiche(message);
  std::string str_fichier_ves_out = fichier_ves_out;
  size_t found = str_fichier_ves_out.rfind((char*)".");
  std::string str_fichier_magic_out = str_fichier_ves_out.substr(0,found);
  str_fichier_magic_out.append((char*)".magic");
  if(strlen(fichier_param)>0 && strlen(fichier_lstparam)>0)
  {
    app.affiche_erreur((char*)"Une seule valeur pour -param OU -lstparam doit etre fournie");
    return 0;
  }
  if(strlen(fichier_param)>0)
  {
    std::vector<OT_PARAMETRES*> vector_param_materiau;
    OT_PARAMETRES* param_materiau = new OT_PARAMETRES;
    char message[5000];
    if(PARAMETRES::importer_fichier_parametres(fichier_param,param_materiau)==FAIL)
    {
      std::sprintf(message,"ERREUR lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
      app.affiche(message);
      return 1;
    }    
    std::sprintf(message,"Lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
    app.affiche(message);
    vector_param_materiau.push_back(param_materiau);
    MSTRUCT_VES ves(fichier_ves_in);
    ves.active_affichage(app.affiche);
    ves.generer_materiau(vector_param_materiau);
    ves.enregistrer(fichier_ves_out,(char*)str_fichier_magic_out.c_str());
    delete param_materiau;
  }
  else if(strlen(fichier_lstparam)>0)
  {
    std::vector<OT_PARAMETRES*> vector_param_materiau;
    char message[5000];
    if(PARAMETRES::importer_fichier_liste_parametres(fichier_lstparam,vector_param_materiau)==FAIL)
    {
      std::sprintf(message,"ERREUR lecture du fichier de liste de parametres : \033[38;5;46m%s\033[1;33m",fichier_lstparam);
      app.affiche(message);
      return 1;
    }    
    std::sprintf(message,"Lecture du fichier de liste de parametres : \033[38;5;46m%s\033[1;33m",fichier_lstparam);
    app.affiche(message);
    MSTRUCT_VES ves(fichier_ves_in);
    ves.active_affichage(app.affiche);
    ves.generer_materiau(vector_param_materiau);
    ves.enregistrer(fichier_ves_out,(char*)str_fichier_magic_out.c_str());
    std::vector<OT_PARAMETRES*>::iterator it_vector;
    for(it_vector=vector_param_materiau.begin();it_vector!=vector_param_materiau.end();it_vector++)
    {
      delete *it_vector;
    }
  }
  std::sprintf(message,"Fichier VES de sortie : \033[38;5;46m%s\033[1;33m",fichier_ves_out);
  app.affiche(message);
  std::sprintf(message,"Fichier MAGIC de sortie : \033[38;5;46m%s\033[1;33m",str_fichier_magic_out.c_str());
  app.affiche(message);
}

if(app.get_action()==23)
{
  app.affiche((char*)"********************************************");
  app.affiche((char*)"***   Generation de la carte de taille   ***");
  app.affiche((char*)"********************************************");
  char fichier_ves_in[500];
  char fichier_param[500];
  char fichier_ves_out[500];
  app.recupere_parametre_string(3,fichier_ves_in,(char*)"Fichier VES de entrant manquant");
  app.recupere_parametre_string(4,fichier_ves_out,(char*)"Fichier VES de sortie manquant");
  app.recupere_parametre_string(7,fichier_param,(char*)"Fichier de parametre manquant");
  if (app.get_erreur()==true) return 0; 
  char message[5000];
  std::sprintf(message,"Fichier VES d'entree : \033[38;5;46m%s\033[1;33m",fichier_ves_in);
  app.affiche(message);
  OT_PARAMETRES* param_carte = new OT_PARAMETRES;
  if(PARAMETRES::importer_fichier_parametres(fichier_param,param_carte)==FAIL)
  {
    std::sprintf(message,"ERREUR lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
    app.affiche(message);
    return 1;
  }
  std::sprintf(message,"Lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
  app.affiche(message);
  MSTRUCT_VES ves(fichier_ves_in);
  ves.active_affichage(app.affiche);
  ves.generer_carte(param_carte);
  ves.enregistrer(fichier_ves_out);
  delete param_carte;
  std::sprintf(message,"Fichier VES de sortie : \033[38;5;46m%s\033[1;33m",fichier_ves_out);
  app.affiche(message);
}

if(app.get_action()==24)
{
  app.affiche((char*)"**********************************");
  app.affiche((char*)"***   Generation du maillage   ***");
  app.affiche((char*)"**********************************");
  char fichier_ves_in[500];
  char fichier_ves_out[500];
  char fichier_param[500];
  char fichier_carte[500];
  app.recupere_parametre_string(3,fichier_ves_in,(char*)"Fichier VES de entrant manquant");
  app.recupere_parametre_string(4,fichier_ves_out,(char*)"Fichier VES de sortie manquant");
  app.recupere_parametre_string(5,fichier_carte,(char*)"Fichier de carte de taille manquant");
  app.recupere_parametre_string(7,fichier_param,(char*)"Fichier de parametre manquant");  
  if (app.get_erreur()==true) return 0;
  char message[5000];
  std::sprintf(message,"Fichier VES d'entree : \033[38;5;46m%s\033[1;33m",fichier_ves_in);
  app.affiche(message);
  std::sprintf(message,"Fichier CARTE d'entree : \033[38;5;46m%s\033[1;33m",fichier_carte);
  app.affiche(message);
  std::string str_fichier_ves_out = fichier_ves_out;
  size_t found = str_fichier_ves_out.rfind((char*)".");
  std::string str_fichier_magic_out = str_fichier_ves_out.substr(0,found);
  str_fichier_magic_out.append((char*)".magic");
  OT_PARAMETRES* param_maillage = new OT_PARAMETRES;
  if(PARAMETRES::importer_fichier_parametres(fichier_param,param_maillage)==FAIL)
  {
    std::sprintf(message,"ERREUR lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
    app.affiche(message);
    delete param_maillage;
    return 1;
  }
  std::sprintf(message,"Lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
  app.affiche(message);
  MSTRUCT_VES ves(fichier_ves_in);
  ves.active_affichage(app.affiche);
  FCT_TAILLE_FEM_SOLUTION *carte=new FCT_TAILLE_FEM_SOLUTION(fichier_carte);
  if(ves.generer_maillage(param_maillage,carte)==FAIL)
  {
    std::sprintf(message,"ERREUR generation du maillage : \033[38;5;46m%s\033[1;33m",fichier_param);
    app.affiche(message);
    delete param_maillage;
    return 1;
  }
  ves.enregistrer(fichier_ves_out,(char*)str_fichier_magic_out.c_str());
  delete param_maillage;
  delete carte;
  std::sprintf(message,"Fichier VES de sortie : \033[38;5;46m%s\033[1;33m",fichier_ves_out);
  app.affiche(message);
  std::sprintf(message,"Fichier MAGIC de sortie : \033[38;5;46m%s\033[1;33m",str_fichier_magic_out.c_str());
  app.affiche(message);
}

if(app.get_action()==25)
{
  app.affiche((char*)"**************************************");
  app.affiche((char*)"***   Generation du FEM maillage   ***");
  app.affiche((char*)"**************************************");
  char fichier_ves_in[500];
  char fichier_ves_out[500];
  char fichier_param[500];
  app.recupere_parametre_string(3,fichier_ves_in,(char*)"Fichier VES de entrant manquant");
  app.recupere_parametre_string(4,fichier_ves_out,(char*)"Fichier VES de sortie manquant");
  app.recupere_parametre_string(7,fichier_param,(char*)"Fichier de parametre manquant");
  if (app.get_erreur()==true) return 0;
  char message[5000];
  std::sprintf(message,"Fichier VES d'entree : \033[38;5;46m%s\033[1;33m",fichier_ves_in);
  app.affiche(message);
  std::string str_fichier_ves_out = fichier_ves_out;
  size_t found = str_fichier_ves_out.rfind((char*)".");
  std::string str_fichier_magic_out = str_fichier_ves_out.substr(0,found);
  str_fichier_magic_out.append((char*)".magic");
  OT_PARAMETRES* param_maillage = new OT_PARAMETRES;
  if(PARAMETRES::importer_fichier_parametres(fichier_param,param_maillage)==FAIL)
  {
    std::sprintf(message,"ERREUR lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
    app.affiche(message);
    delete param_maillage;
    return 1;
  }
  std::sprintf(message,"Lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
  app.affiche(message);
  MSTRUCT_VES ves(fichier_ves_in);
  ves.active_affichage(app.affiche);
  if(ves.generer_fem_maillage(param_maillage)==FAIL)
  {
    std::sprintf(message,"ERREUR generation fem maillage : \033[38;5;46m%s\033[1;33m",fichier_param);
    app.affiche(message);
    delete param_maillage;
    return 1;
  }
  ves.enregistrer(fichier_ves_out,(char*)str_fichier_magic_out.c_str());
  delete param_maillage;
  std::sprintf(message,"Fichier VES de sortie : \033[38;5;46m%s\033[1;33m",fichier_ves_out);
  app.affiche(message);
  std::sprintf(message,"Fichier MAGIC de sortie : \033[38;5;46m%s\033[1;33m",str_fichier_magic_out.c_str());
  app.affiche(message);
}

if(app.get_action()==26)
{
  app.affiche((char*)"*********************************");
  app.affiche((char*)"***   Generation de l'etude   ***");
  app.affiche((char*)"*********************************");
  char fichier_ves_in[500];
  char fichier_ves_out[500];
  char fichier_param[500];
  app.recupere_parametre_string(3,fichier_ves_in,(char*)"Fichier VES de entrant manquant");
  app.recupere_parametre_string(4,fichier_ves_out,(char*)"Fichier VES de sortie manquant");
  app.recupere_parametre_string(7,fichier_param,(char*)"Fichier de parametre manquant");
  if (app.get_erreur()==true) return 0;
  char message[5000];
  std::sprintf(message,"Fichier VES d'entree : \033[38;5;46m%s\033[1;33m",fichier_ves_in);
  app.affiche(message);
  std::string str_fichier_ves_out = fichier_ves_out;
  size_t found = str_fichier_ves_out.rfind((char*)".");
  std::string str_fichier_magic_out = str_fichier_ves_out.substr(0,found);
  str_fichier_magic_out.append((char*)".magic");
  OT_PARAMETRES* param_etude = new OT_PARAMETRES;
  if(PARAMETRES::importer_fichier_parametres(fichier_param,param_etude)==FAIL)
  {
    std::sprintf(message,"ERREUR lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
    app.affiche(message);
    return 1;
  }
  std::sprintf(message,"Lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
  app.affiche(message);
  MSTRUCT_VES ves(fichier_ves_in);
  ves.active_affichage(app.affiche);
  ves.generer_etude(param_etude);
  ves.enregistrer(fichier_ves_out,(char*)str_fichier_magic_out.c_str());
  delete param_etude; 
  std::sprintf(message,"Fichier VES de sortie : \033[38;5;46m%s\033[1;33m",fichier_ves_out);
  app.affiche(message);
  std::sprintf(message,"Fichier MAGIC de sortie : \033[38;5;46m%s\033[1;33m",str_fichier_magic_out.c_str());
  app.affiche(message);
}

if(app.get_action()==27)
{
  app.affiche((char*)"********************************");
  app.affiche((char*)"***   Generation du Calcul   ***");
  app.affiche((char*)"********************************");
  char fichier_ves_in[500];
  char fichier_ves_out[500];
  char fichier_param[500];
  char fichier_param_aster[500];
  app.recupere_parametre_string(3,fichier_ves_in,(char*)"Fichier VES de entrant manquant");
  app.recupere_parametre_string(4,fichier_ves_out,(char*)"Fichier VES de sortie manquant");
  app.recupere_parametre_string(7,fichier_param,(char*)"Fichier de parametre manquant");
  app.recupere_parametre_string(9,fichier_param_aster,(char*)"Fichier de parametre aster manquant");
  if (app.get_erreur()==true) return 0;
  char message[5000];
  std::sprintf(message,"Fichier VES d'entree : \033[38;5;46m%s\033[1;33m",fichier_ves_in);
  app.affiche(message);
  std::string str_fichier_ves_out = fichier_ves_out;
  size_t found = str_fichier_ves_out.rfind((char*)".");
  std::string str_fichier_magic_out = str_fichier_ves_out.substr(0,found);
  std::string nom_etude = "aster_" + str_fichier_magic_out;
  str_fichier_magic_out.append((char*)".magic");
  OT_PARAMETRES* param_etude = new OT_PARAMETRES;  
  if(PARAMETRES::importer_fichier_parametres(fichier_param,param_etude)==FAIL)
  {
    std::sprintf(message,"ERREUR lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
    app.affiche(message);
    return 1;
  }
  std::sprintf(message,"Lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
  app.affiche(message);
  MSTRUCT_VES ves(fichier_ves_in);
  ves.active_affichage(app.affiche);
  ves.generer_calcul(param_etude,fichier_param_aster,nom_etude);
  ves.enregistrer(fichier_ves_out,(char*)str_fichier_magic_out.c_str());
  delete param_etude; 
  std::sprintf(message,"Fichier VES de sortie : \033[38;5;46m%s\033[1;33m",fichier_ves_out);
  app.affiche(message);
  std::sprintf(message,"Fichier MAGIC de sortie : \033[38;5;46m%s\033[1;33m",str_fichier_magic_out.c_str());
  app.affiche(message);
}

if(app.get_action()==28)
{
  app.affiche((char*)"*******************************************************");
  app.affiche((char*)"***   Generation du port-traitement des resultats   ***");
  app.affiche((char*)"*******************************************************");
  char fichier_ves_in[500];
  char fichier_ves_out[500];
  char fichier_param[500];
  char fichier_lstparam[500];
  char fichier_ves_sph[500];
  char fichier_ves_dev[500];
  char fichier_ves_lambda_x[500];
  char fichier_ves_lambda_y[500];
  char fichier_ves_lambda_z[500];
  app.recupere_parametre_string_avec_defaut(3,fichier_ves_in,(char*)"");
  app.recupere_parametre_string(4,fichier_ves_out,(char*)"Fichier VES de sortie manquant");
  app.recupere_parametre_string_avec_defaut(7,fichier_param,(char*)"");
  app.recupere_parametre_string_avec_defaut(8,fichier_lstparam,(char*)"");
  app.recupere_parametre_string_avec_defaut(16,fichier_ves_sph,(char*)"");
  app.recupere_parametre_string_avec_defaut(17,fichier_ves_dev,(char*)"");  
  app.recupere_parametre_string_avec_defaut(35,fichier_ves_lambda_x,(char*)"");
  app.recupere_parametre_string_avec_defaut(36,fichier_ves_lambda_y,(char*)"");
  app.recupere_parametre_string_avec_defaut(37,fichier_ves_lambda_z,(char*)"");
  if (app.get_erreur()==true) return 0;
  char message[5000];
  std::sprintf(message,"Fichier VES d'entree : \033[38;5;46m%s\033[1;33m",fichier_ves_in);
  app.affiche(message);
  if(strlen(fichier_param)>0 && strlen(fichier_lstparam)>0)
  {
    app.affiche_erreur((char*)"Une seule valeur pour -param OU -lstparam doit etre fournie");
    return 0;
  }
  if((strlen(fichier_ves_sph)>0 && strlen(fichier_ves_dev)==0) || (strlen(fichier_ves_sph)==0 && strlen(fichier_ves_dev)>0))
  {
    app.affiche_erreur((char*)"-ves_sph ET -ves_dev, OU rien");
    return 0;
  }
  if(strlen(fichier_param)>0)
  {
    std::vector<OT_PARAMETRES*> vector_param_analyse;
    OT_PARAMETRES* param_analyse = new OT_PARAMETRES;
    char message[5000];
    if(PARAMETRES::importer_fichier_parametres(fichier_param,param_analyse)==FAIL)
    {
      std::sprintf(message,"ERREUR lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
      app.affiche(message);
      return 1;
    }
    std::sprintf(message,"Lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
    app.affiche(message);
    vector_param_analyse.push_back(param_analyse);
    if(strlen(fichier_ves_lambda_x)>0 && strlen(fichier_ves_lambda_y)>0 && strlen(fichier_ves_lambda_z)>0)
    {
      MSTRUCT_VES_FILE ves_lambda_x;
      ves_lambda_x.ouvrir(fichier_ves_lambda_x);
      MSTRUCT_VES_FILE ves_lambda_y;
      ves_lambda_y.ouvrir(fichier_ves_lambda_y);
      MSTRUCT_VES_FILE ves_lambda_z;
      ves_lambda_z.ouvrir(fichier_ves_lambda_z);
      MSTRUCT_VES ves;
      ves.active_affichage(app.affiche);
      ves.generer_post_traitement(vector_param_analyse,&ves_lambda_x,&ves_lambda_y,&ves_lambda_z);
      ves.enregistrer(fichier_ves_out);
    }
    else if(strlen(fichier_ves_sph)>0 && strlen(fichier_ves_dev)>0)
    {
      MSTRUCT_VES_FILE ves_sph;
      ves_sph.ouvrir(fichier_ves_sph);
      MSTRUCT_VES_FILE ves_dev;
      ves_dev.ouvrir(fichier_ves_dev);
      MSTRUCT_VES ves;
      ves.active_affichage(app.affiche);
      ves.generer_post_traitement(vector_param_analyse,&ves_sph,&ves_dev);
      ves.enregistrer(fichier_ves_out);
    }
    else 
    {
      MSTRUCT_VES ves(fichier_ves_in);
      ves.active_affichage(app.affiche);
      ves.generer_post_traitement(vector_param_analyse);
      ves.enregistrer(fichier_ves_out);
    }    
    delete param_analyse;
  }
  else if(strlen(fichier_lstparam)>0)
  {
    std::vector<OT_PARAMETRES*> vector_param_analyse;
    char message[5000];
    if(PARAMETRES::importer_fichier_liste_parametres(fichier_lstparam,vector_param_analyse)==FAIL)
    {
      std::sprintf(message,"ERREUR lecture du fichier de liste de parametres : \033[38;5;46m%s\033[1;33m",fichier_lstparam);
      app.affiche(message);
      return 1;
    }    
    std::sprintf(message,"Lecture du fichier de liste de parametres : \033[38;5;46m%s\033[1;33m",fichier_lstparam);
    app.affiche(message);
    if(strlen(fichier_ves_lambda_x)>0 && strlen(fichier_ves_lambda_y)>0 && strlen(fichier_ves_lambda_z)>0)
    {
      MSTRUCT_VES_FILE ves_lambda_x;
      ves_lambda_x.ouvrir(fichier_ves_lambda_x);
      MSTRUCT_VES_FILE ves_lambda_y;
      ves_lambda_y.ouvrir(fichier_ves_lambda_y);
      MSTRUCT_VES_FILE ves_lambda_z;
      ves_lambda_z.ouvrir(fichier_ves_lambda_z);
      MSTRUCT_VES ves;
      ves.active_affichage(app.affiche);
      ves.generer_post_traitement(vector_param_analyse,&ves_lambda_x,&ves_lambda_y,&ves_lambda_z);
      ves.enregistrer(fichier_ves_out);
    }
    else if(strlen(fichier_ves_sph)>0 && strlen(fichier_ves_dev)>0)
    {
      MSTRUCT_VES_FILE ves_sph;
      ves_sph.ouvrir(fichier_ves_sph);
      MSTRUCT_VES_FILE ves_dev;
      ves_dev.ouvrir(fichier_ves_dev);
      MSTRUCT_VES ves;
      ves.active_affichage(app.affiche);
      ves.generer_post_traitement(vector_param_analyse,&ves_sph,&ves_dev);
      ves.enregistrer(fichier_ves_out);
    }
    else 
    {
      MSTRUCT_VES ves(fichier_ves_in);
      ves.active_affichage(app.affiche);
      ves.generer_post_traitement(vector_param_analyse);
      ves.enregistrer(fichier_ves_out);
    } 
    std::vector<OT_PARAMETRES*>::iterator it_vector;
    for(it_vector=vector_param_analyse.begin();it_vector!=vector_param_analyse.end();it_vector++)
    {
      delete *it_vector;
    }
  }
  std::sprintf(message,"Fichier VES de sortie : \033[38;5;46m%s\033[1;33m",fichier_ves_out);
  app.affiche(message);
}

if(app.get_action()==29)
{
  app.affiche((char*)"**************************************");
  app.affiche((char*)"***   Cumule des post-traitement   ***");
  app.affiche((char*)"**************************************");
  char fichier_param[500];
  char fichier_lstparam[500];
  char fichier_lst_ves[500];
  char dossier_resultat[500];
  app.recupere_parametre_string_avec_defaut(7,fichier_param,(char*)"");
  app.recupere_parametre_string_avec_defaut(8,fichier_lstparam,(char*)"");
  app.recupere_parametre_string(18,fichier_lst_ves,(char*)"Liste de VES");
  app.recupere_parametre_string_avec_defaut(6,dossier_resultat,(char*)"");
  if (app.get_erreur()==true) return 0;
  char message[5000];
  std::sprintf(message,"Liste de fichier VES : \033[38;5;46m%s\033[1;33m",fichier_lst_ves);
  app.affiche(message);
  std::sprintf(message,"Dossier de resultat : \033[38;5;46m%s\033[1;33m",dossier_resultat);
  app.affiche(message);
  if(strlen(fichier_param)>0 && strlen(fichier_lstparam)>0)
  {
    app.affiche_erreur((char*)"Une seule valeur pour -param OU -lstparam doit etre fournie");
    return 0;
  }
  if(strlen(fichier_param)>0)
  {
    std::vector<OT_PARAMETRES*> vector_param;
    OT_PARAMETRES* param = new OT_PARAMETRES;
    char message[5000];
    if(PARAMETRES::importer_fichier_parametres(fichier_param,param)==FAIL)
    {
      std::sprintf(message,"ERREUR lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
      app.affiche(message);
      return 1;
    }
    std::sprintf(message,"Lecture du fichier de parametre : \033[38;5;46m%s\033[1;33m",fichier_param);
    app.affiche(message);
    vector_param.push_back(param);
    MSTRUCT_VER ver;
    ver.active_affichage(app.affiche);
    ver.cumuler_post_traitement(fichier_lst_ves,vector_param,dossier_resultat,true);
    delete param;
  }
  else if(strlen(fichier_lstparam)>0)
  {
    std::vector<OT_PARAMETRES*> vector_param;
    char message[5000];
    if(PARAMETRES::importer_fichier_liste_parametres(fichier_lstparam,vector_param)==FAIL)
    {
      std::sprintf(message,"ERREUR lecture du fichier de liste de parametres : \033[38;5;46m%s\033[1;33m",fichier_lstparam);
      app.affiche(message);
      return 1;
    }    
    std::sprintf(message,"Lecture du fichier de liste de parametres : \033[38;5;46m%s\033[1;33m",fichier_lstparam);
    app.affiche(message);
    MSTRUCT_VER ver;
    ver.active_affichage(app.affiche);
    ver.cumuler_post_traitement(fichier_lst_ves,vector_param,dossier_resultat,true);
    std::vector<OT_PARAMETRES*>::iterator it_vector;
    for(it_vector=vector_param.begin();it_vector!=vector_param.end();it_vector++)
    {
      delete *it_vector;
    }
  }
}

if(app.get_action()==30)
{
  app.affiche((char*)"***************************");
  app.affiche((char*)"***   AFFICHE CONTENU   ***");
  app.affiche((char*)"***************************");
  char fichier_ves_in[500];
  app.recupere_parametre_string(3,fichier_ves_in,(char*)"Fichier VES de entrant manquant");
  if (app.get_erreur()==true) return 0;
  MSTRUCT_VES_FILE ves_file;
  ves_file.ouvrir(fichier_ves_in);
  ves_file.affiche_contenu(app.affiche);
}

if(app.get_action()==31)
{
#ifdef ALL_OCC
  app.affiche((char*)"********************************************************************");
  app.affiche((char*)"***   Exportation de la triangulation STL de la microstructure   ***");
  app.affiche((char*)"********************************************************************");
  char fichier_ves_in[500];
  char fichier_magic_out[500];
  double eps;
  app.recupere_parametre_string(3,fichier_ves_in,(char*)"Fichier VES de entrant manquant");
  app.recupere_parametre_string(2,fichier_magic_out,(char*)"Fichier MAGIC de sortie manquant");
  app.recupere_parametre_double_avec_defaut(19,eps,0.001);
  if (app.get_erreur()==true) return 0;
  MSTRUCT_VES ves(fichier_ves_in);
  MG_GESTIONNAIRE* gest = ves.get_mg_gestionnaire();
  MG_GEOMETRIE* mggeo = ves.get_mg_geometrie();
  OCC_IMPORT occ_import;
  MG_MAILLAGE* tristl = occ_import.importer_triangulation_V2017(*gest,mggeo,eps);
  gest->enregistrer(fichier_magic_out);
#endif
}

if(app.get_action()==32)
{
  app.affiche((char*)"***********************************************");
  app.affiche((char*)"***   EXPORT DU MAILLAGE AU FORMAT ABAQUS   ***");
  app.affiche((char*)"***********************************************");
  char fichier_ves_in[500];
  char dossier[500];
  app.recupere_parametre_string(3,fichier_ves_in,(char*)"Fichier VES de entrant manquant");
  app.recupere_parametre_string(6,dossier,(char*)"Dossier de resultats");
  if (app.get_erreur()==true) return 0;
  MSTRUCT_VES ves(fichier_ves_in);
  ves.exporter_maillage_abaqus(dossier);
}

if(app.get_action()==34)
{
  app.affiche((char*)"***********************************************");
  app.affiche((char*)"***   GENERATION D'UN POLYCRISTAL           ***");
  app.affiche((char*)"***********************************************");
  char fichier_magic[1000];
  char fichier_param[1000];
  bool creeparam;
  app.recupere_parametre_bool_avec_defaut(33,creeparam,false);
  bool exportpoint;
  app.recupere_parametre_bool_avec_defaut(40,exportpoint,false);
  if (app.get_erreur()==true) return 0;
  if (creeparam)
  {
    app.recupere_parametre_string(7,fichier_param,(char*)"Fichier de parametre manquant");
    if (app.get_erreur()==true) return 0;
    MSTRUCT_GENERATEUR_POLYCRISTAUX gen;
    gen.active_affichage(app.affiche);
    gen.cree_param(fichier_param,argv[0]);
  }
  else if (exportpoint)
  {
    app.affiche((char*)"\nExportation des points de germe des cristaux");
    char fichier_export[1000];
    app.recupere_parametre_string(1,fichier_magic,(char*)"Fichier d'entrée manquant");
    app.recupere_parametre_string(2,fichier_export,(char*)"Fichier de sortie manquant");
    if (app.get_erreur()==true) return 0;
    MSTRUCT_GENERATEUR_POLYCRISTAUX gen(fichier_magic,fichier_export);
   
  }
  else
  {
    app.recupere_parametre_string(7,fichier_param,(char*)"Fichier de parametre manquant");
    app.recupere_parametre_string(2,fichier_magic,(char*)"Fichier de sortie manquant");
    if (app.get_erreur()==true) return 0;
    MSTRUCT_GENERATEUR_POLYCRISTAUX gen(fichier_param);
    gen.active_affichage(app.affiche);
    gen.genere(fichier_magic);
  }      
}


if(app.get_action()==38)
{
  app.affiche((char*)"**********************************");
  app.affiche((char*)"***   COMPRESSER HISTOGRAMME   ***");
  app.affiche((char*)"**********************************");
  char fichier_in[1000];
  char fichier_out[1000];
  double largeur;
  app.recupere_parametre_string(1,fichier_in,(char*)"Fichier (.txt) in manquant");
  app.recupere_parametre_string(2,fichier_out,(char*)"Fichier (.txt) out manquant");
  app.recupere_parametre_double(39,largeur,(char*)"Largeur de colonne manquante");
  if (app.get_erreur()==true) return 0;
  std::ifstream ifs;
  OT_HISTOGRAMME histo_in;
  char message[5000];
  std::sprintf(message,"Lecture du fichier in : \033[38;5;46m%s\033[1;33m",fichier_in);
  app.affiche(message);
  histo_in.ouvrir_txt(fichier_in);
  std::sprintf(message,"Histogramme in : largeur colonne = %lf, %li colonnes",histo_in.get_largeur_colonne(),histo_in.get_nb_colonne());
  app.affiche(message);
  OT_HISTOGRAMME histo_out(largeur,histo_in);
  std::sprintf(message,"Histogramme out : largeur colonne = %lf, %li colonnes",histo_out.get_largeur_colonne(),histo_out.get_nb_colonne());
  app.affiche(message);
  std::sprintf(message,"Ecriture du fichier out : \033[38;5;46m%s\033[1;33m",fichier_out);
  app.affiche(message);
  std::ofstream of_histo(fichier_out,std::ios::out|std::ios::trunc);
  histo_out.exporter(of_histo);
}


app.affiche((char*)"Fin");
return 0;
}


#pragma package(smart_init)
Revision:	1027
Committed:	Thu Jun 27 15:30:41 2019 UTC (5 years, 10 months ago) by francois
File size:	40800 byte(s)
Log Message:	amelioration des scripts pour l'étude des polycristaux.