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, [2] Ellipsoide, [3] Boite");
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");
MAGIC_PARAMETRE_APPLICATION p14(14,(char*)"-nb_couche",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Nombre de couche d'erosion (defaut = 0)");
MAGIC_PARAMETRE_APPLICATION p15(15,(char*)"-epaisseur_couche",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");

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);
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);

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);

MAGIC_APPLICATION app((char*)"Homogéinisation 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_int_avec_defaut(14,nb_couche,0);
  app.recupere_parametre_double_avec_defaut(15,epaisseur_couche,0.02);
  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;}
  PARAMETRES::generer_fichier_parametres(type_etude,type_generateur,type_inclusion,maillage_lin,maillage_quad,nb_couche,epaisseur_couche,app.affiche);  
  PARAMETRES::generer_script_ves(type_etude,type_inclusion,maillage_lin,maillage_quad,app.affiche);
  PARAMETRES::generer_script_post_traitement(type_etude,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];
  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*)"");
  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_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_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()==33)
{
  app.affiche((char*)"***********************************************");
  app.affiche((char*)"***   GENERATION D'UN POLYCRISTAL           ***");
  app.affiche((char*)"***********************************************");
  char fichier_magic[1000];
  char fichier_param[1000];
  app.recupere_parametre_string(7,fichier_param,(char*)"Fichier de parametre manquant");
  bool creeparam;
  app.recupere_parametre_bool_avec_defaut(20,creeparam,false);
  if (app.get_erreur()==true) return 0;
  if (creeparam)
  {
    MSTRUCT_GENERATEUR_POLYCRISTAUX gen;
    gen.active_affichage(app.affiche);
    gen.cree_param(fichier_param);
  }
  else 
  {
    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);
  }      
}

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


#pragma package(smart_init)
Revision:	968
Committed:	Sun Sep 16 15:27:49 2018 UTC (6 years, 7 months ago) by couturad
File size:	35715 byte(s)
Log Message:	Ajout d'une condition de sortie et d'un renvoi d'erreur pour le mailleur FEM. Subdivision des fichiers mstruct_analyse.h/.cpp en sous fichiers pour une meilleure lisibilite. Ajout d'une analyse des modules d'elasticite. Ajout d'une analyse de l'energie. Reconfiguration du main de microstructure.exe (suppression d'actions obsolètes). Reconfiguration des fichiers generer_nb_ves, post_process.