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 p1(3,(char*)"-ves_in",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier VES d'entree");
MAGIC_PARAMETRE_APPLICATION p2(4,(char*)"-ves_out",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier VES de sortie");
MAGIC_PARAMETRE_APPLICATION p3(5,(char*)"-param",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier de parametres");
MAGIC_PARAMETRE_APPLICATION p4(6,(char*)"-lstparam",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier listant plusieurs fichiers de parametres");
MAGIC_PARAMETRE_APPLICATION p5(7,(char*)"-gen_geo",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Generer la geometrie");
MAGIC_PARAMETRE_APPLICATION p6(8,(char*)"-gen_mat",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Generer les materiaux");
MAGIC_PARAMETRE_APPLICATION p7(9,(char*)"-gen_carte",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Generer la carte de taille");
MAGIC_PARAMETRE_APPLICATION p8(10,(char*)"-gen_mg_maill",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Generer le MG maillage");
MAGIC_PARAMETRE_APPLICATION p9(11,(char*)"-gen_fem_maill",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Generer le FEM maillage");
MAGIC_PARAMETRE_APPLICATION p10(12,(char*)"-gen_etude",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Generer l'etude");
MAGIC_PARAMETRE_APPLICATION p11(13,(char*)"-gen_analyse",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Generer l'analyse des resultats");
MAGIC_PARAMETRE_APPLICATION p12(14,(char*)"-carte",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Carte de taille FEM solution");
MAGIC_PARAMETRE_APPLICATION p13(15,(char*)"-calcul",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Lancer la resolution numerique");
MAGIC_PARAMETRE_APPLICATION p14(16,(char*)"-creeparam",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Creer une structure de parametres");
MAGIC_PARAMETRE_APPLICATION p15(17,(char*)"-tristl",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Importation de la triangulation STL de la microstructure");
MAGIC_PARAMETRE_APPLICATION p16(18,(char*)"-eps",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Distance max entre la triangulation et la géométrie");
MAGIC_PARAMETRE_APPLICATION p17(19,(char*)"-paramaster",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier de parametre aster");
MAGIC_PARAMETRE_APPLICATION p18(20,(char*)"-dossier",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Dossier de resultat");
MAGIC_PARAMETRE_APPLICATION p19(21,(char*)"-cumuler_analyses",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Cumuler les analyses d'une liste de VES");
MAGIC_PARAMETRE_APPLICATION p20(22,(char*)"-lstves",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Liste de VES");
MAGIC_PARAMETRE_APPLICATION p21(23,(char*)"-affiche_contenu",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Affiche le contenu d'un fichier VES");
MAGIC_PARAMETRE_APPLICATION p22(24,(char*)"-incrementale",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Cumuler les analyses de facon incrementale");
MAGIC_PARAMETRE_APPLICATION p23(25,(char*)"-avec_histogramme",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Generer les histogrammes");
MAGIC_PARAMETRE_APPLICATION p24(26,(char*)"-exporter_modules_meca",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Exporter les modules mecaniques d'une liste de VES");
MAGIC_PARAMETRE_APPLICATION p25(27,(char*)"-lstves_spherique",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Liste de VES de type chargement spherique");
MAGIC_PARAMETRE_APPLICATION p26(28,(char*)"-lstves_deviatorique",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Liste de VES de type chargement deviatorique");
MAGIC_PARAMETRE_APPLICATION p27(29,(char*)"-type_etude",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Type d'etude : [0] mecanique, [1] thermique");
MAGIC_PARAMETRE_APPLICATION p28(30,(char*)"-export_maill_abaqus",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Exportation du maillage au format ABAQUS");
MAGIC_PARAMETRE_APPLICATION p29(31,(char*)"-exporter_analyses",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Exportation des analyses");
MAGIC_PARAMETRE_APPLICATION p30(32,(char*)"-polycristaux",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"génération d'un polycristal");
MAGIC_PARAMETRE_APPLICATION p31(33,(char*)"-creeparampoly",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Création d'un fichier de paramétres");
MAGIC_PARAMETRE_APPLICATION p32(34,(char*)"-type_inclusion",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Type d'inclusion : [0] Sphere, [1] Cylindre, [2] Ellipsoide, [3] Boite");
MAGIC_PARAMETRE_APPLICATION p33(35,(char*)"-type_maillage",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Type de maillage : [0] lineaire, [1] quadratique, [2] lineaire et quadratique");
MAGIC_PARAMETRE_APPLICATION p34(36,(char*)"-cumuler_modules_meca",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Cumuler les modules mecaniques d'une liste de VES");
MAGIC_PARAMETRE_APPLICATION p35(37,(char*)"-type_generateur",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Type de generateur : [0] RSA, [1] DCR");
p5.ajouter_dependance(4);p5.ajouter_dependance(5);p5.ajouter_dependance(6);
p6.ajouter_dependance(3);p6.ajouter_dependance(4);p6.ajouter_dependance(5);p6.ajouter_dependance(6);
p7.ajouter_dependance(3);p7.ajouter_dependance(4);p7.ajouter_dependance(5);
p8.ajouter_dependance(3);p8.ajouter_dependance(4);p8.ajouter_dependance(5);p8.ajouter_dependance(14);
p9.ajouter_dependance(3);p9.ajouter_dependance(4);p9.ajouter_dependance(5);
p10.ajouter_dependance(3);p10.ajouter_dependance(4);p10.ajouter_dependance(5);
p11.ajouter_dependance(3);p11.ajouter_dependance(4);p11.ajouter_dependance(5);p11.ajouter_dependance(6);
p13.ajouter_dependance(3);p13.ajouter_dependance(4);p13.ajouter_dependance(5);p13.ajouter_dependance(19);
p14.ajouter_dependance(29);p14.ajouter_dependance(37);p14.ajouter_dependance(34);p14.ajouter_dependance(35);
p15.ajouter_dependance(3);p15.ajouter_dependance(18);p15.ajouter_dependance(4);
p19.ajouter_dependance(22);p19.ajouter_dependance(5);p19.ajouter_dependance(6);p19.ajouter_dependance(20);p19.ajouter_dependance(25); 
p21.ajouter_dependance(3);
p24.ajouter_dependance(5);p24.ajouter_dependance(6);p24.ajouter_dependance(20);p24.ajouter_dependance(27);p24.ajouter_dependance(28);
p28.ajouter_dependance(3);
p29.ajouter_dependance(22);p29.ajouter_dependance(5);p29.ajouter_dependance(6);p29.ajouter_dependance(20);
p30.ajouter_dependance(2);p30.ajouter_dependance(5);p30.ajouter_dependance(33);
p34.ajouter_dependance(5);p34.ajouter_dependance(6);p34.ajouter_dependance(20);p34.ajouter_dependance(25);p34.ajouter_dependance(27);p34.ajouter_dependance(28);

lst.push_back(p1);
lst.push_back(p2);
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);


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()==7)
{
  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(5,fichier_param,(char*)"");
  app.recupere_parametre_string_avec_defaut(6,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;
    PARAMETRES::importer_fichier_parametres(fichier_param,param_geometrie);
    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;
    PARAMETRES::importer_fichier_liste_parametres(fichier_lstparam,vector_param_geometrie);
    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;
    }
  }
}

if(app.get_action()==8)
{
  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(5,fichier_param,(char*)"");
  app.recupere_parametre_string_avec_defaut(6,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_materiau;
    OT_PARAMETRES* param_materiau = new OT_PARAMETRES;
    PARAMETRES::importer_fichier_parametres(fichier_param,param_materiau);
    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;
    PARAMETRES::importer_fichier_liste_parametres(fichier_lstparam,vector_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());
    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;
    }
  }
}

if(app.get_action()==9)
{
  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(5,fichier_param,(char*)"Fichier de parametre manquant");
  if (app.get_erreur()==true) return 0; 
  OT_PARAMETRES* param_carte = new OT_PARAMETRES;
  PARAMETRES::importer_fichier_parametres(fichier_param,param_carte);
  MSTRUCT_VES ves(fichier_ves_in);
  ves.active_affichage(app.affiche);
  ves.generer_carte(param_carte);
  ves.enregistrer(fichier_ves_out);
  delete param_carte;
}

if(app.get_action()==10)
{
  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_param,(char*)"Fichier de parametre manquant");
  app.recupere_parametre_string(14,fichier_carte,(char*)"Fichier de carte de taille manquant");
  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");
  OT_PARAMETRES* param_maillage = new OT_PARAMETRES;
  PARAMETRES::importer_fichier_parametres(fichier_param,param_maillage);
  MSTRUCT_VES ves(fichier_ves_in);
  ves.active_affichage(app.affiche);
  FCT_TAILLE_FEM_SOLUTION *carte=new FCT_TAILLE_FEM_SOLUTION(fichier_carte);
  ves.generer_maillage(param_maillage,carte);
  ves.enregistrer(fichier_ves_out,(char*)str_fichier_magic_out.c_str());
  delete param_maillage;
  delete carte;
}

if(app.get_action()==11)
{
  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(5,fichier_param,(char*)"Fichier de parametre manquant");
  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");
  OT_PARAMETRES* param_maillage = new OT_PARAMETRES;
  PARAMETRES::importer_fichier_parametres(fichier_param,param_maillage);
  MSTRUCT_VES ves(fichier_ves_in);
  ves.active_affichage(app.affiche);
  ves.generer_fem_maillage(param_maillage);
  ves.enregistrer(fichier_ves_out,(char*)str_fichier_magic_out.c_str());
  delete param_maillage; 
}


if(app.get_action()==12)
{
  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(5,fichier_param,(char*)"Fichier de parametre manquant");
  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");
  OT_PARAMETRES* param_etude = new OT_PARAMETRES;
  PARAMETRES::importer_fichier_parametres(fichier_param,param_etude);
  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; 
}

if(app.get_action()==13)
{
  app.affiche((char*)"*************************************************");
  app.affiche((char*)"***   Generation de l'analyse des resultats   ***");
  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(5,fichier_param,(char*)"");
  app.recupere_parametre_string_avec_defaut(6,fichier_lstparam,(char*)""); 
  if (app.get_erreur()==true) return 0;
  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_analyse;
    OT_PARAMETRES* param_analyse = new OT_PARAMETRES;
    PARAMETRES::importer_fichier_parametres(fichier_param,param_analyse);
    vector_param_analyse.push_back(param_analyse);
    MSTRUCT_VES ves(fichier_ves_in);
    ves.active_affichage(app.affiche);
    ves.generer_analyse(vector_param_analyse);
    ves.enregistrer(fichier_ves_out);
    delete param_analyse;
  }
  else if(strlen(fichier_lstparam)>0)
  {
    std::vector<OT_PARAMETRES*> vector_param_analyse;
    PARAMETRES::importer_fichier_liste_parametres(fichier_lstparam,vector_param_analyse);
    MSTRUCT_VES ves(fichier_ves_in);
    ves.active_affichage(app.affiche);
    ves.generer_analyse(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;
    }
  }
}

if(app.get_action()==15)
{
  app.affiche((char*)"******************");
  app.affiche((char*)"***   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(5,fichier_param,(char*)"Fichier de parametre manquant");
  app.recupere_parametre_string(19,fichier_param_aster,(char*)"Fichier de parametre aster manquant");
  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");
  OT_PARAMETRES* param_etude = new OT_PARAMETRES;  
  PARAMETRES::importer_fichier_parametres(fichier_param,param_etude);
  MSTRUCT_VES ves(fichier_ves_in);
  ves.active_affichage(app.affiche);
  ves.generer_calcul(param_etude,fichier_param_aster);
  ves.enregistrer(fichier_ves_out,(char*)str_fichier_magic_out.c_str());
  delete param_etude; 
}

if(app.get_action()==16)
{
  app.affiche((char*)"***********************************************");
  app.affiche((char*)"***   Creation des fichiers de parametres   ***");
  app.affiche((char*)"***********************************************");
  int type_etude;
  int type_generateur;
  int type_inclusion;
  int type_maillage;
  app.recupere_parametre_int(29,type_etude,(char*)"Type d'etude manquant");
  app.recupere_parametre_int(37,type_generateur,(char*)"Type de generateur manquant");
  app.recupere_parametre_int(34,type_inclusion,(char*)"Type d'inclusion manquant");
  app.recupere_parametre_int(35,type_maillage,(char*)"Type de maillage manquant");
  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);  
  PARAMETRES::generer_script_ves(type_etude,type_inclusion,maillage_lin,maillage_quad);
  PARAMETRES::generer_script_post_process(type_etude,type_inclusion,maillage_lin,maillage_quad);
}

if(app.get_action()==17)
{
#ifdef ALL_OCC
  app.affiche((char*)"********************************************************************");
  app.affiche((char*)"***   Importation de la triangulation STL de la microstructure   ***");
  app.affiche((char*)"********************************************************************");
  char fichier_ves_in[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");
  double eps;
  app.recupere_parametre_double_avec_defaut(18,eps,0.1);
  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");
  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);
  ves.enregistrer(fichier_ves_out,(char*)str_fichier_magic_out.c_str());
#endif
}

if(app.get_action()==21)
{
  app.affiche((char*)"******************************");
  app.affiche((char*)"***   Cumul des analyses   ***");
  app.affiche((char*)"******************************");
  char fichier_lst_ves[500];
  char fichier_param[500];
  char fichier_lstparam[500];
  char dossier_resultat[500];
  bool avec_histogramme;
  app.recupere_parametre_string(22,fichier_lst_ves,(char*)"Fichier de liste de VES");
  app.recupere_parametre_string_avec_defaut(5,fichier_param,(char*)"");
  app.recupere_parametre_string_avec_defaut(6,fichier_lstparam,(char*)"");
  app.recupere_parametre_string_avec_defaut(20,dossier_resultat,(char*)"");
  app.recupere_parametre_bool_avec_defaut(25,avec_histogramme,false);
  if (app.get_erreur()==true) return 0;
  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;
    PARAMETRES::importer_fichier_parametres(fichier_param,param);
    vector_param.push_back(param);
    MSTRUCT_VER ver;
    ver.active_affichage(app.affiche);
    ver.cumuler_analyse(fichier_lst_ves,vector_param,dossier_resultat,avec_histogramme);
    delete param;
  }
  else if(strlen(fichier_lstparam)>0)
  {
    std::vector<OT_PARAMETRES*> vector_param;
    PARAMETRES::importer_fichier_liste_parametres(fichier_lstparam,vector_param);
    MSTRUCT_VER ver;
    ver.active_affichage(app.affiche);
    ver.cumuler_analyse(fichier_lst_ves,vector_param,dossier_resultat,avec_histogramme);
    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()==23)
{
  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()==26)
{
  app.affiche((char*)"*******************************************");
  app.affiche((char*)"***   Exporter des modules mecaniques   ***");
  app.affiche((char*)"*******************************************");
  char fichier_lst_ves_sph[500];
  char fichier_lst_ves_dev[500];
  char fichier_param[500];
  char fichier_lstparam[500];
  char dossier_resultat[500];
  app.recupere_parametre_string(27,fichier_lst_ves_sph,(char*)"Liste de VES de type chargement spherique");
  app.recupere_parametre_string(28,fichier_lst_ves_dev,(char*)"Liste de VES de type chargement deviatorique");
  app.recupere_parametre_string_avec_defaut(5,fichier_param,(char*)"");
  app.recupere_parametre_string_avec_defaut(6,fichier_lstparam,(char*)"");
  app.recupere_parametre_string_avec_defaut(20,dossier_resultat,(char*)"");
  if (app.get_erreur()==true) return 0;
  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;
    PARAMETRES::importer_fichier_parametres(fichier_param,param);
    vector_param.push_back(param);
    MSTRUCT_VER ver;
    ver.active_affichage(app.affiche);
    ver.exporter_modules_mecaniques(fichier_lst_ves_sph,fichier_lst_ves_dev,vector_param,dossier_resultat);
    delete param;
  }
  else if(strlen(fichier_lstparam)>0)
  {
    std::vector<OT_PARAMETRES*> vector_param;
    PARAMETRES::importer_fichier_liste_parametres(fichier_lstparam,vector_param);
    MSTRUCT_VER ver;
    ver.active_affichage(app.affiche);
    ver.exporter_modules_mecaniques(fichier_lst_ves_sph,fichier_lst_ves_dev,vector_param,dossier_resultat);
    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*)"***   EXPORT DU MAILLAGE AU FORMAT ABAQUS   ***");
  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 ves(fichier_ves_in);
  ves.exporter_maillage_abaqus();
}

if(app.get_action()==31)
{
  app.affiche((char*)"************************************");
  app.affiche((char*)"***   Exportation des analyses   ***");
  app.affiche((char*)"************************************");
  char fichier_lst_ves[500];
  char fichier_param[500];
  char fichier_lstparam[500];
  char dossier_resultat[500];

  app.recupere_parametre_string(22,fichier_lst_ves,(char*)"Fichier de liste de VES");
  app.recupere_parametre_string_avec_defaut(5,fichier_param,(char*)"");
  app.recupere_parametre_string_avec_defaut(6,fichier_lstparam,(char*)"");
  app.recupere_parametre_string_avec_defaut(20,dossier_resultat,(char*)"");

  if (app.get_erreur()==true) return 0;
  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;
    PARAMETRES::importer_fichier_parametres(fichier_param,param);
    vector_param.push_back(param);
    MSTRUCT_VER ver;
    ver.active_affichage(app.affiche);
    ver.exporter_analyse(fichier_lst_ves,vector_param,dossier_resultat);
    delete param;
  }
  else if(strlen(fichier_lstparam)>0)
  {
    std::vector<OT_PARAMETRES*> vector_param;
    PARAMETRES::importer_fichier_liste_parametres(fichier_lstparam,vector_param);
    MSTRUCT_VER ver;
    ver.active_affichage(app.affiche);
    ver.exporter_analyse(fichier_lst_ves,vector_param,dossier_resultat);
    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()==32)
{
  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(5,fichier_param,(char*)"Fichier de parametre manquant");
  bool creeparam;
  app.recupere_parametre_bool_avec_defaut(33,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);
    }
      
}

if(app.get_action()==36)
{
  app.affiche((char*)"******************************************");
  app.affiche((char*)"***   Cumuler des modules mecaniques   ***");
  app.affiche((char*)"******************************************");
  char fichier_lst_ves_sph[500];
  char fichier_lst_ves_dev[500];
  char fichier_param[500];
  char fichier_lstparam[500];
  char dossier_resultat[500];
  bool avec_histogramme;
  app.recupere_parametre_string(27,fichier_lst_ves_sph,(char*)"Liste de VES de type chargement spherique");
  app.recupere_parametre_string(28,fichier_lst_ves_dev,(char*)"Liste de VES de type chargement deviatorique");
  app.recupere_parametre_string_avec_defaut(5,fichier_param,(char*)"");
  app.recupere_parametre_string_avec_defaut(6,fichier_lstparam,(char*)"");
  app.recupere_parametre_string_avec_defaut(20,dossier_resultat,(char*)"");
  app.recupere_parametre_bool_avec_defaut(25,avec_histogramme,false);
  if (app.get_erreur()==true) return 0;
  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;
    PARAMETRES::importer_fichier_parametres(fichier_param,param);
    vector_param.push_back(param);
    MSTRUCT_VER ver;
    ver.active_affichage(app.affiche);
    ver.cumuler_modules_mecaniques(fichier_lst_ves_sph,fichier_lst_ves_dev,vector_param,dossier_resultat,avec_histogramme);
    delete param;
  }
  else if(strlen(fichier_lstparam)>0)
  {
    std::vector<OT_PARAMETRES*> vector_param;
    PARAMETRES::importer_fichier_liste_parametres(fichier_lstparam,vector_param);
    MSTRUCT_VER ver;
    ver.active_affichage(app.affiche);
    ver.cumuler_modules_mecaniques(fichier_lst_ves_sph,fichier_lst_ves_dev,vector_param,dossier_resultat,avec_histogramme);
    std::vector<OT_PARAMETRES*>::iterator it_vector;
    for(it_vector=vector_param.begin();it_vector!=vector_param.end();it_vector++)
    {
      delete *it_vector;
    }
  }
}

app.affiche((char*)"Fin");

return 0;
}


#pragma package(smart_init)
Revision:	961
Committed:	Thu Aug 16 15:47:40 2018 UTC (6 years, 8 months ago) by couturad
File size:	33264 byte(s)
Log Message:	Correction bugs MICROSTRUCTURE