microstructure/src/ve_ves.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)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       mg_ves.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 � 11H23
//------------------------------------------------------------
//------------------------------------------------------------

#include "ve_ves.h"
#include "ve_definition.h"
#include "gestionversion.h"
#include "mg_gestionnaire.h"
#include "mg_arbre.h"
#include "mg_assemblage.h"
#include "mg_primitive.h"
#include "mg_primitive_boite.h"
#include "mg_primitive_sphere.h"
#include "mg_primitive_cylindre.h"
#include "mg_primitive_cone.h"
#include "mg_primitive_tore.h"
#include "mg_primitive_complexe.h"
#include "mg_operateur_boolean.h"
#include "mg_operateur_boolean_difference.h"
#include "mg_operateur_boolean_intersection.h"
#include "mg_operateur_boolean_union.h"
#include "mg_sommet_noeud.h"
#include "fct_taille.h"
#include "fct_generateur_frontiere.h"
#include "fct_generateur_constante.h"
#include "fct_generateur_fichier.h"
#include "fct_taille_fem_solution_generateur_constant.h"
#include "fct_taille_fem_solution_generateur_echantillon_frontiere.h"
#include "fct_taille_fem_solution_generateur_fichier.h"
#include "mailleur.h"
#include "mailleur0d.h"
#include "mailleur1d.h"
#include "mailleur2d.h"
#include "mailleur3d.h"
#include "tpl_map_entite.h"
#include "ot_mathematique.h"
#include "fem_maillage.h"
#include "mgaster.h"
#include "mg_export.h"
#include "sphere_grille.h"
#include <string.h>
#include <map>
#include <random>
#include <stdio.h>
#include <iostream>
#include <chrono>

VE_VES::VE_VES()
{    
  gest = new MG_GESTIONNAIRE;
  arbre = new MG_ARBRE("Arbre");
  assemblage = new MG_ASSEMBLAGE("Assemblage");  
  param_ver = new OT_PARAMETRES();
  gest->ajouter_mg_arbre(arbre);
  arbre->ajouter_mg_assemblage(assemblage);
  ini_param_VER(param_ver);
  dim_VES[0] = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_VER_Dim_longueur_x]);
  dim_VES[1] = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_VER_Dim_longueur_y]);
  dim_VES[2] = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_VER_Dim_longueur_z]);
}

VE_VES::VE_VES(VE_VES& mdd)
{

}

VE_VES::~VE_VES()
{
  delete assemblage;
  delete param_ver;
  delete gest;  
}

int VE_VES::construire(void)
{
  int type_ver = (int)param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_VER_Type]);
  switch(type_ver)
  {
    case VE_TYPE_VER::HOMOGENE:
    {
      generer_VES_homogene();
      break;
    }
    case VE_TYPE_VER::UNE_INCLUSION:
    {
      generer_VES_une_inclusion();
      break;
    }
    case VE_TYPE_VER::ALEATOIRE:
    {
      generer_VES_aleatoire();
      break;
    }
  }
  evaluer_geometrie();
  creer_carte();
  creer_mg_maillage();
  appliquer_conditions_limites(param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_VER_CL_CHARGEMENT_type]));
  appliquer_materiaux();
  creer_fem_maillage();
  calcul_aster();
  homogeneisation();
  char nom_fichier_magic[1000];
  sprintf(nom_fichier_magic,"%s",param_ver->get_nom(VE_PARAM_CHAR[VE_PARAM::VE_IO_nom_fichier_MAGiC]).c_str());
  gest->enregistrer(nom_fichier_magic);
  return 0;
}

MG_GESTIONNAIRE* VE_VES::get_gestionnaire(void)
{
  return gest;
}

MG_ARBRE* VE_VES::get_arbre(void)
{
  return arbre;
}

MG_ASSEMBLAGE* VE_VES::get_assemblage(void)
{
  return assemblage;
}

void VE_VES::active_affichage(fonction_affiche* fonc)
{
  fonc_affiche = fonc;
  affichageactif = 1;
}

void VE_VES::affiche(char* message)
{
  if(affichageactif==1) fonc_affiche(message);
}

void VE_VES::lire_param_VES(char* fichier)
{
  param_ver->lire(fichier);
  dim_VES[0] = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_VER_Dim_longueur_x]);
  dim_VES[1] = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_VER_Dim_longueur_y]);
  dim_VES[2] = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_VER_Dim_longueur_z]);
}

void VE_VES::ecrire_param_VES(char* fichier)
{
  param_ver->enregistrer(fichier);
}

int VE_VES::generer_VES_homogene(void)
{
  affiche((char*)"Generation VER Homogene :\n");
  MG_PRIMITIVE_BOITE *cube = new MG_PRIMITIVE_BOITE(0,0,0,dim_VES[0],dim_VES[1],dim_VES[2]);
  arbre->ajouter_mg_primitive(cube);
  cube->construit();
  assemblage->ajouter_mg_primitive(cube);
  return 0;
}

int VE_VES::generer_VES_une_inclusion(void)
{
  affiche((char*)"Generation VER Une Inclusion :\n");
  MG_PRIMITIVE_BOITE *cube = new MG_PRIMITIVE_BOITE(0,0,0,dim_VES[0],dim_VES[1],dim_VES[2]);
  arbre->ajouter_mg_primitive(cube);
  cube->construit();
  
  MG_PRIMITIVE *matrice;
  MG_PRIMITIVE *inclusion;
  MG_PRIMITIVE *inclusion_outil;
  
  
  int type_inclusion = (int)param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Type_INCLUSION]);
  switch(type_inclusion)
  {
    case VE_TYPE_INCLUSION::BOITE:
    {
      double xmin,ymin,zmin,xmax,ymax,zmax;
      double longueur_x,longueur_y,longueur_z;      
      longueur_x = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Dim_mu_longueur_x]);
      longueur_y = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Dim_mu_longueur_y]);
      longueur_z = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Dim_mu_longueur_z]);
      xmin = dim_VES[0]/2.-(longueur_x/2.);
      ymin = dim_VES[1]/2.-(longueur_y/2.);
      zmin = dim_VES[2]/2.-(longueur_z/2.);
      xmax = dim_VES[0]/2.+(longueur_x/2.);
      ymax = dim_VES[1]/2.+(longueur_y/2.);
      zmax = dim_VES[2]/2.+(longueur_z/2.);      
      inclusion = new MG_PRIMITIVE_BOITE(xmin,ymin,zmin,xmax,ymax,zmax);
      inclusion_outil = new MG_PRIMITIVE_BOITE(xmin,ymin,zmin,xmax,ymax,zmax);
      break;
    }
    case VE_TYPE_INCLUSION::SPHERE:
    {
      double rayon;
      rayon = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Dim_mu_rayon]);
      inclusion = new MG_PRIMITIVE_SPHERE(dim_VES[0]/2.,dim_VES[1]/2.,dim_VES[2]/2.,rayon);
      inclusion_outil = new MG_PRIMITIVE_SPHERE(dim_VES[0]/2.,dim_VES[1]/2.,dim_VES[2]/2.,rayon);
      break;
    }
    case VE_TYPE_INCLUSION::CYLINDRE:
    {
      break;
    }    
  }
  arbre->ajouter_mg_primitive(inclusion_outil);
  arbre->ajouter_mg_primitive(inclusion);
  inclusion_outil->construit();
  inclusion->construit();
  MG_OPERATEUR_BOOLEAN_DIFFERENCE *op_difference=new MG_OPERATEUR_BOOLEAN_DIFFERENCE(MAGIC::SEMANTIQUECSG::SOUSTRACTION,cube,inclusion_outil);
  matrice=op_difference->construit();
  arbre->ajouter_mg_operateur_boolean(op_difference);
  arbre->ajouter_mg_primitive(matrice);
  assemblage->ajouter_mg_primitive(inclusion);
  assemblage->ajouter_mg_primitive(matrice);
  return 0;
}

int VE_VES::generer_VES_aleatoire(void)
{

 return 0;  
}

int VE_VES::evaluer_geometrie(void)
{
  char nom_fichier[1000];
  sprintf(nom_fichier,"%s",param_ver->get_nom(VE_PARAM_CHAR[VE_PARAM::VE_IO_nom_fichier_STEP_BREP]).c_str());
  bool export_STEP, avec_fusion,import_STL;
  export_STEP = (int)param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_IO_Bool_export_STEP]);
  avec_fusion = (int)param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_IO_Bool_fusion]);
  import_STL = (int)param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_IO_Bool_import_STL]);
  double precision,eps;
  precision = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_Dim_precision]);
  eps = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_IO_STL_eps]);
  arbre->evaluer_geometrie(assemblage,nom_fichier,avec_fusion,export_STEP,import_STL,precision,eps);
  return 0;
}

int VE_VES::creer_mg_maillage(void)
{
  affiche((char*)"Maillage du VER :");
  MG_GEOMETRIE *geo = gest->get_mg_geometrie(0);
  MG_MAILLAGE *maillage = new MG_MAILLAGE(geo);
  gest->ajouter_mg_maillage(maillage);
  MAILLEUR0D m0d(maillage,geo);
  affiche((char*)"     Maillage 0D :");
  m0d.maille();
  MAILLEUR1D m1d(maillage,geo,metrique);
  affiche((char*)"     Maillage 1D :");
  //m1d.active_affichage(fonc_affiche);
  m1d.maille();
  MAILLEUR2D m2d(maillage,geo,metrique);
  affiche((char*)"     Maillage 2D :");
  //m2d.active_affichage(fonc_affiche);
  m2d.maille();
  MAILLEUR3D m3d(maillage,geo,metrique,false);
  affiche((char*)"     Maillage 3D :");
  m3d.active_affichage(fonc_affiche);
  m3d.maille();
  return 0;
}

int VE_VES::creer_carte(void)
{
  int type_carte = (int)param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_CARTE_Type]);
  switch(type_carte)
  {
    case VE_TYPE_CARTE::CONSTANTE:
    {
      affiche((char*)"Generation de carte de taille constante V1");
      double ecart_nodal = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_CARTE_Dim_ecart_nodal]);
      double fechantillonnage = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_CARTE_Dim_fechantillonnage]);
      double festimation = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_CARTE_Dim_festimation]);
      FCT_GENERATEUR_CONSTANTE *carte = new FCT_GENERATEUR_CONSTANTE(*gest,ecart_nodal);
      affiche((char*)"Construction de la carte");
      carte->construit(fechantillonnage,festimation);
      affiche((char*)"Enregistrement de la carte");
      char nom_fichier[1000];
      sprintf(nom_fichier,"%s",param_ver->get_nom(VE_PARAM_CHAR[VE_PARAM::VE_IO_nom_fichier_CARTE]).c_str());
      carte->enregistrer(nom_fichier);
      metrique = carte;
      affiche((char*)"Fin");
      break;
    }
  }
  return 0;
}

int VE_VES::appliquer_conditions_limites_plan(TPL_MAP_ENTITE< MG_FACE* >* plan, char* condition, double valeur,bool topo_sous_jacente)
{
  TPL_MAP_ENTITE<MG_FACE*>::ITERATEUR it_face_plan;
  for(MG_FACE *face = plan->get_premier(it_face_plan);face!=NULL;face=plan->get_suivant(it_face_plan))
  {   
    face->ajouter_ccf(condition,valeur);
    if(topo_sous_jacente==true)
    {
      TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> map_topo;
      face->get_topologie_sousjacente(&map_topo);
      TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*>::ITERATEUR it_topo;
      for(MG_ELEMENT_TOPOLOGIQUE *topo=map_topo.get_premier(it_topo);topo!=NULL;topo=map_topo.get_suivant(it_topo))
      {
        topo->ajouter_ccf(condition,valeur);
      }
    }
  }
}

int VE_VES::appliquer_conditions_limites_plan(TPL_MAP_ENTITE< MG_FACE* >* plan, char* condition, std::string formule,std::vector<std::string> &listvariable,bool topo_sous_jacente)
{
  TPL_MAP_ENTITE<MG_FACE*>::ITERATEUR it_face_plan;
  for(MG_FACE *face = plan->get_premier(it_face_plan);face!=NULL;face=plan->get_suivant(it_face_plan))
  {   
    face->ajouter_ccf(condition,formule,listvariable);
    if(topo_sous_jacente==true)
    {
      TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> map_topo;
      face->get_topologie_sousjacente(&map_topo);
      TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*>::ITERATEUR it_topo;    
      for(MG_ELEMENT_TOPOLOGIQUE *topo=map_topo.get_premier(it_topo);topo!=NULL;topo=map_topo.get_suivant(it_topo))
      {
        topo->ajouter_ccf(condition,formule,listvariable);
      }
    }
  }
}

int VE_VES::appliquer_conditions_limites(int type_chargement)
{
  TPL_MAP_ENTITE<MG_FACE*> plan_xy_z0;
  TPL_MAP_ENTITE<MG_FACE*> plan_xy_z1;
  TPL_MAP_ENTITE<MG_FACE*> plan_yz_x0;
  TPL_MAP_ENTITE<MG_FACE*> plan_yz_x1;
  TPL_MAP_ENTITE<MG_FACE*> plan_xz_y0;
  TPL_MAP_ENTITE<MG_FACE*> plan_xz_y1;
  MG_SOMMET* sommet_origine;
  MG_SOMMET* sommet_x1y0z0;
  MG_SOMMET* sommet_x0y1z0;
  MG_SOMMET* sommet_x0y0z1;
  double eps = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_Dim_precision]);
  
  MG_GEOMETRIE *geo = gest->get_mg_geometrie(0); 
  std::map<unsigned long,MG_FACE*,std::less<unsigned long>>::iterator it_face;
  for(MG_FACE *face = geo->get_premier_face(it_face);face!=NULL;face=geo->get_suivant_face(it_face))
  {
    TPL_SET<MG_ELEMENT_MAILLAGE*> *liste_element_maillage = face->get_lien_maillage();
    MG_TRIANGLE *tri = (MG_TRIANGLE*)liste_element_maillage->get(0);
    MG_NOEUD *nd[3];
    nd[0] = tri->get_noeud1();
    nd[1] = tri->get_noeud2();
    nd[2] = tri->get_noeud3();      
    
    if(OPERATEUR::egal(nd[0]->get_z(),0,eps) && OPERATEUR::egal(nd[1]->get_z(),0,eps) && OPERATEUR::egal(nd[2]->get_z(),0,eps))
    {
      plan_xy_z0.ajouter(face);
    }
    else if(OPERATEUR::egal(nd[0]->get_z(),dim_VES[2],eps) && OPERATEUR::egal(nd[1]->get_z(),dim_VES[2],eps) && OPERATEUR::egal(nd[2]->get_z(),dim_VES[2],eps))
    {
      plan_xy_z1.ajouter(face);
    }
    else if(OPERATEUR::egal(nd[0]->get_x(),0,eps) && OPERATEUR::egal(nd[1]->get_x(),0,eps) && OPERATEUR::egal(nd[2]->get_x(),0,eps))
    {
      plan_yz_x0.ajouter(face);
    }
    else if(OPERATEUR::egal(nd[0]->get_x(),dim_VES[0],eps) && OPERATEUR::egal(nd[1]->get_x(),dim_VES[0],eps) && OPERATEUR::egal(nd[2]->get_x(),dim_VES[0],eps))
    {
      plan_yz_x1.ajouter(face);
    }
    else if(OPERATEUR::egal(nd[0]->get_y(),0,eps) && OPERATEUR::egal(nd[1]->get_y(),0,eps) && OPERATEUR::egal(nd[2]->get_y(),0,eps))
    {
      plan_xz_y0.ajouter(face);
    }
    else if(OPERATEUR::egal(nd[0]->get_y(),dim_VES[1],eps) && OPERATEUR::egal(nd[1]->get_y(),dim_VES[1],eps) && OPERATEUR::egal(nd[2]->get_y(),dim_VES[1],eps))
    {
      plan_xz_y1.ajouter(face);
    }    
  }
  
  std::map<unsigned long,MG_SOMMET*,std::less<unsigned long>>::iterator it_sommet;
  for(MG_SOMMET* som=geo->get_premier_sommet(it_sommet);som!=NULL;som=geo->get_suivant_sommet(it_sommet))
  {
    TPL_SET<MG_ELEMENT_MAILLAGE*> *liste_element_maillage = som->get_lien_maillage();
    MG_NOEUD* nd = (MG_NOEUD*)liste_element_maillage->get(0);
    if(OPERATEUR::egal(nd->get_x(),0,eps) && OPERATEUR::egal(nd->get_y(),0,eps) && OPERATEUR::egal(nd->get_z(),0,eps))
    {
      sommet_origine=som;      
    }
    else if(OPERATEUR::egal(nd->get_x(),dim_VES[0],eps) && OPERATEUR::egal(nd->get_y(),0,eps) && OPERATEUR::egal(nd->get_z(),0,eps))
    {
      sommet_x1y0z0=som;      
    }
    else if(OPERATEUR::egal(nd->get_x(),0,eps) && OPERATEUR::egal(nd->get_y(),dim_VES[1],eps) && OPERATEUR::egal(nd->get_z(),0,eps))
    {
      sommet_x0y1z0=som;      
    }
    else if(OPERATEUR::egal(nd->get_x(),0,eps) && OPERATEUR::egal(nd->get_y(),0,eps) && OPERATEUR::egal(nd->get_z(),dim_VES[2],eps))
    {
      sommet_x0y0z1=som;      
    }
  }

  int type_cl = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_VER_CL_Type]);
  double valeur_cl = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_VER_CL_Dim_valeur]);
  
  switch(type_chargement)
  {
    case VE_TYPE_CHARGEMENT::SPHERIQUE:
    {
      switch(type_cl)
      {
        case VE_TYPE_CL::DEFORMATION_HOMOGENE:
        {
          appliquer_conditions_limites_plan(&plan_xy_z0,(char*)"Dz",0.0,true);
          appliquer_conditions_limites_plan(&plan_xy_z1,(char*)"Dz",valeur_cl,true);
          appliquer_conditions_limites_plan(&plan_yz_x0,(char*)"Dx",0.0,true);
          appliquer_conditions_limites_plan(&plan_yz_x1,(char*)"Dx",valeur_cl,true);
          appliquer_conditions_limites_plan(&plan_xz_y0,(char*)"Dy",0.0,true);
          appliquer_conditions_limites_plan(&plan_xz_y1,(char*)"Dy",valeur_cl,true);
          break;
        }
        case VE_TYPE_CL::CONTRAINTE_HOMOGENE:
        {
          appliquer_conditions_limites_plan(&plan_xy_z0,(char*)"Dz",0.0,true);
          appliquer_conditions_limites_plan(&plan_xy_z1,(char*)"Pz",valeur_cl,false);
          appliquer_conditions_limites_plan(&plan_yz_x0,(char*)"Dx",0.0,true);
          appliquer_conditions_limites_plan(&plan_yz_x1,(char*)"Px",valeur_cl,false);
          appliquer_conditions_limites_plan(&plan_xz_y0,(char*)"Dy",0.0,true);
          appliquer_conditions_limites_plan(&plan_xz_y1,(char*)"Py",valeur_cl,false);
          break;
        }
        case VE_TYPE_CL::FLUX_CHALEUR_HOMOGENE:
        {
          break;
        }
        case VE_TYPE_CL::GRADIENT_TEMPERATURE_HOMOGENE:
        {
          break;
        }
      }
      break;
    }
    
    case VE_TYPE_CHARGEMENT::DEVIATORIQUE:
    {
      switch(type_cl)
      {
        case VE_TYPE_CL::DEFORMATION_HOMOGENE:
        {
          char chr_valeur_cl[1000];
          sprintf(chr_valeur_cl,"%lf",valeur_cl);
          std::string str_valeur_cl = chr_valeur_cl;
          std::string formule_Dx = str_valeur_cl+ "*Y";
          std::string formule_Dy = str_valeur_cl+ "*Z";
          std::string formule_Dz = str_valeur_cl+ "*X";
          std::vector<std::string> liste_variable_formule_Dx;
          std::vector<std::string> liste_variable_formule_Dy;
          std::vector<std::string> liste_variable_formule_Dz;
          liste_variable_formule_Dx.push_back((std::string)"Y");
          liste_variable_formule_Dy.push_back((std::string)"Z");
          liste_variable_formule_Dz.push_back((std::string)"X");
          appliquer_conditions_limites_plan(&plan_xy_z0,(char*)"Dx",formule_Dx,liste_variable_formule_Dx,true);
          appliquer_conditions_limites_plan(&plan_xy_z0,(char*)"Dy",formule_Dy,liste_variable_formule_Dy,true);
          appliquer_conditions_limites_plan(&plan_xy_z0,(char*)"Dz",formule_Dz,liste_variable_formule_Dz,true);   
          appliquer_conditions_limites_plan(&plan_xy_z1,(char*)"Dx",formule_Dx,liste_variable_formule_Dx,true);
          appliquer_conditions_limites_plan(&plan_xy_z1,(char*)"Dy",formule_Dy,liste_variable_formule_Dy,true);
          appliquer_conditions_limites_plan(&plan_xy_z1,(char*)"Dz",formule_Dz,liste_variable_formule_Dz,true);   
          appliquer_conditions_limites_plan(&plan_yz_x0,(char*)"Dx",formule_Dx,liste_variable_formule_Dx,true);
          appliquer_conditions_limites_plan(&plan_yz_x0,(char*)"Dy",formule_Dy,liste_variable_formule_Dy,true);
          appliquer_conditions_limites_plan(&plan_yz_x0,(char*)"Dz",formule_Dz,liste_variable_formule_Dz,true);   
          appliquer_conditions_limites_plan(&plan_yz_x1,(char*)"Dx",formule_Dx,liste_variable_formule_Dx,true);
          appliquer_conditions_limites_plan(&plan_yz_x1,(char*)"Dy",formule_Dy,liste_variable_formule_Dy,true);
          appliquer_conditions_limites_plan(&plan_yz_x1,(char*)"Dz",formule_Dz,liste_variable_formule_Dz,true);   
          appliquer_conditions_limites_plan(&plan_xz_y0,(char*)"Dx",formule_Dx,liste_variable_formule_Dx,true);
          appliquer_conditions_limites_plan(&plan_xz_y0,(char*)"Dy",formule_Dy,liste_variable_formule_Dy,true);
          appliquer_conditions_limites_plan(&plan_xz_y0,(char*)"Dz",formule_Dz,liste_variable_formule_Dz,true);   
          appliquer_conditions_limites_plan(&plan_xz_y1,(char*)"Dx",formule_Dx,liste_variable_formule_Dx,true);
          appliquer_conditions_limites_plan(&plan_xz_y1,(char*)"Dy",formule_Dy,liste_variable_formule_Dy,true);
          appliquer_conditions_limites_plan(&plan_xz_y1,(char*)"Dz",formule_Dz,liste_variable_formule_Dz,true);
          break;
        }
        
        case VE_TYPE_CL::CONTRAINTE_HOMOGENE:
        {
          sommet_origine->ajouter_ccf((char*)"Dt",0.0);
          sommet_x1y0z0->ajouter_ccf((char*)"Dy",0.0);
          sommet_x1y0z0->ajouter_ccf((char*)"Dz",0.0); 
          sommet_x0y1z0->ajouter_ccf((char*)"Dz",0.0);    
          appliquer_conditions_limites_plan(&plan_xy_z0,(char*)"Px",-valeur_cl,true);
          appliquer_conditions_limites_plan(&plan_xy_z0,(char*)"Py",-valeur_cl,true);
          appliquer_conditions_limites_plan(&plan_xy_z1,(char*)"Px",valeur_cl,true);
          appliquer_conditions_limites_plan(&plan_xy_z1,(char*)"Py",valeur_cl,true);      
          appliquer_conditions_limites_plan(&plan_xz_y0,(char*)"Px",-valeur_cl,true);
          appliquer_conditions_limites_plan(&plan_xz_y0,(char*)"Pz",-valeur_cl,true);
          appliquer_conditions_limites_plan(&plan_xz_y1,(char*)"Px",valeur_cl,true);
          appliquer_conditions_limites_plan(&plan_xz_y1,(char*)"Pz",valeur_cl,true);      
          appliquer_conditions_limites_plan(&plan_yz_x0,(char*)"Py",-valeur_cl,true);
          appliquer_conditions_limites_plan(&plan_yz_x0,(char*)"Pz",-valeur_cl,true);
          appliquer_conditions_limites_plan(&plan_yz_x1,(char*)"Py",valeur_cl,true);
          appliquer_conditions_limites_plan(&plan_yz_x1,(char*)"Pz",valeur_cl,true);      
          break;
        }
        case VE_TYPE_CL::FLUX_CHALEUR_HOMOGENE:
        {
          break;
        }
        case VE_TYPE_CL::GRADIENT_TEMPERATURE_HOMOGENE:
        {
          break;          
        }
      }
      break;
    }
  }
  return 0;
}

int VE_VES::appliquer_materiaux(void)
{
  double nu_inclu = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Dim_mu_nu]);
  double nu_matrice = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_MATRICE_Dim_mu_nu]);
  double Em_inclu = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Dim_mu_Em]);
  double Em_matrice = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_MATRICE_Dim_mu_Em]);
  MG_GEOMETRIE *geo = gest->get_mg_geometrie(0);
  MG_VOLUME *matrice = geo->get_mg_volume(geo->get_nb_mg_volume()-1);
  std::map<unsigned long,MG_VOLUME*,std::less<unsigned long>>::iterator it_volume;
  for(MG_VOLUME *volume = geo->get_premier_volume(it_volume);volume!=matrice;volume=geo->get_suivant_volume(it_volume))
  {
    volume->ajouter_ccf((char*)"nu",nu_inclu);
    volume->ajouter_ccf((char*)"Em",Em_inclu);
  }
  matrice->ajouter_ccf((char*)"nu",nu_matrice);
  matrice->ajouter_ccf((char*)"Em",Em_matrice);
  return 0;
}

int VE_VES::creer_fem_maillage(void)
{
  MG_GEOMETRIE *geo = gest->get_mg_geometrie(0);
  MG_MAILLAGE *mai = gest->get_mg_maillage(gest->get_nb_mg_maillage()-1);
  int degre_mail = (int)param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_MAIL_Dim_degre_maillage]);
  FEM_MAILLAGE *fem = new FEM_MAILLAGE(geo,mai,degre_mail);
  gest->ajouter_fem_maillage(fem);
  fem->construire();
  return 0;
}

int VE_VES::calcul_aster(void)
{
  char coderesu[500];
  char nomparam[500];
  char nometude[500];
  sprintf(nometude,"%s",param_ver->get_nom(VE_PARAM_CHAR[VE_PARAM::VE_IO_nom_fichier_ETUDE]).c_str());
  sprintf(nomparam,"%s",param_ver->get_nom(VE_PARAM_CHAR[VE_PARAM::VE_IO_nom_fichier_param_ASTER]).c_str());
  sprintf(coderesu,"%s",param_ver->get_nom(VE_PARAM_CHAR[VE_PARAM::VE_IO_code_resu]).c_str());
  MGASTER mgaster;
  mgaster.active_affichage(fonc_affiche);
  mgaster.calcule(nomparam,gest->get_fem_maillage(0),nometude,MAGIC::CALCUL_ASTER::ELASTIQUE,coderesu);
}

int VE_VES::homogeneisation(void)
{  
  FEM_SOLUTION* sol=gest->get_fem_solution(1);
  FEM_SOLUTION* sol2=gest->get_fem_solution(2);
  double exx=sol->get_moyenne_volumique_champs(NULL,0);
  double eyy=sol->get_moyenne_volumique_champs(NULL,1);
  double ezz=sol->get_moyenne_volumique_champs(NULL,2);
  double exy=sol->get_moyenne_volumique_champs(NULL,3);
  double exz=sol->get_moyenne_volumique_champs(NULL,4);
  double eyz=sol->get_moyenne_volumique_champs(NULL,5);
  double sxx=sol2->get_moyenne_volumique_champs(NULL,0);
  double syy=sol2->get_moyenne_volumique_champs(NULL,1);
  double szz=sol2->get_moyenne_volumique_champs(NULL,2);
  double sxy=sol2->get_moyenne_volumique_champs(NULL,3);
  double sxz=sol2->get_moyenne_volumique_champs(NULL,4);
  double syz=sol2->get_moyenne_volumique_champs(NULL,5);
  double traces=sxx+syy+szz;
  double tracee=exx+eyy+ezz;
  char message[1000];
  affiche((char*)"");
  sprintf(message, "Tenseur des deformations :"); affiche(message);
  sprintf(message, "    | exx=% 3.2le   exy=% 3.2le   exz=% 3.2le |",exx,exy,exz); affiche(message);
  sprintf(message, "    | exy=% 3.2le   eyy=% 3.2le   eyz=% 3.2le |",exy,eyy,eyz); affiche(message);
  sprintf(message, "    | exz=% 3.2le   eyz=% 3.2le   ezz=% 3.2le |",exz,eyz,ezz); affiche(message);
  affiche((char*)"");
  sprintf(message, "    Trace e = % 3.2le",tracee); affiche(message);
  affiche((char*)"");
  sprintf(message, "Tenseur des contraintes :"); affiche(message);
  sprintf(message, "    | sxx=% 3.2le   sxy=% 3.2le   sxz=% 3.2le |",sxx,sxy,sxz); affiche(message);
  sprintf(message, "    | sxy=% 3.2le   syy=% 3.2le   syz=% 3.2le |",sxy,syy,syz); affiche(message);
  sprintf(message, "    | sxz=% 3.2le   syz=% 3.2le   szz=% 3.2le |",sxz,syz,szz); affiche(message);
  affiche((char*)"");
  sprintf(message, "    Trace s = % 3.2le",traces); affiche(message);
  affiche((char*)"");
  int type_chargement = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_VER_CL_CHARGEMENT_type]);
  if(type_chargement==VE_TYPE_CHARGEMENT::SPHERIQUE)
  {
    double K = traces/3./tracee;
    sprintf(message, "Module de compressibilite apparent :"); affiche(message);
    sprintf(message, "    Kapp = % 3.5le",K); affiche(message);
  }
  else if(type_chargement==VE_TYPE_CHARGEMENT::DEVIATORIQUE)
  {
    double G = (1./3.)*((syz/(2.*eyz))+(sxz/(2.*exz))+(sxy/(2.*exy)));
    sprintf(message, "Module de cisaillement apparent :"); affiche(message);
    sprintf(message, "    Gapp = % 3.5le",G); affiche(message);
  }
}
Revision:	801
Committed:	Tue Jun 7 19:54:41 2016 UTC (8 years, 11 months ago) by couturad
File size:	24471 byte(s)
Log Message:	cas test microstructure plus bug d'inversion VER VES