microstructure/src/ve_ves.cpp

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       ve_ves.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------

#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 "mailleur_fem.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;
    }
  }
  affiche((char*)"Evaluation de la geometrie :\n");
  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();
  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)
{
  affiche((char*)"Generation VES Aleatoire :\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();
  TPL_GRILLE<SPHERE_GRILLE*> grille;  
  double cible_frac_volumique = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Dim_pourcentage_volumique]);
  long nb_max_inclusion = (long)param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Dim_nb_max]);
  int type_inclusion = (int)param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Type_INCLUSION]);
  double facteur_distance=1.1;
  switch(type_inclusion)
  {
    case VE_TYPE_INCLUSION::BOITE:
    {      
      double mu_longueur_x = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Dim_mu_longueur_x]);
      double sigma_longueur_x = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Dim_sigma_longueur_x]);
      double mu_longueur_y = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Dim_mu_longueur_y]);
      double sigma_longueur_y = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Dim_sigma_longueur_y]);
      double mu_longueur_z = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Dim_mu_longueur_z]);
      double sigma_longueur_z = param_ver->get_valeur(VE_PARAM_CHAR[VE_PARAM::VE_INCLU_Dim_sigma_longueur_z]);
      std::random_device seed;
      std::mt19937_64 generateur(seed());
      std::normal_distribution<double> distribution_longueur_x(mu_longueur_x,sigma_longueur_x);
      std::normal_distribution<double> distribution_longueur_y(mu_longueur_y,sigma_longueur_y);
      std::normal_distribution<double> distribution_longueur_z(mu_longueur_z,sigma_longueur_z);
 
      std::uniform_real_distribution<double> distribution_position_x(-mu_longueur_x,dim_VES[0]+mu_longueur_x);
      std::uniform_real_distribution<double> distribution_position_y(-mu_longueur_y,dim_VES[1]+mu_longueur_y);
      std::uniform_real_distribution<double> distribution_position_z(-mu_longueur_z,dim_VES[2]+mu_longueur_z);
      double frac_volumique=0;
      double volume_inclusion=0;
      long nb_inclusion=0;
      long it_max=10000;
      long it=0;
      double nb_pas_grille;
      nb_pas_grille = std::max(dim_VES[0]/(mu_longueur_x-3*sigma_longueur_x),dim_VES[1]/(mu_longueur_y-3*sigma_longueur_y));
      nb_pas_grille = std::max(nb_pas_grille,dim_VES[2]/(mu_longueur_z-3*sigma_longueur_z));
      grille.initialiser(0,0,0,dim_VES[0],dim_VES[1],dim_VES[2],nb_pas_grille,nb_pas_grille,nb_pas_grille);
      long id_sphere_grille=0;
      std::vector<SPHERE_GRILLE*> vector_sphere_grille;
      MG_PRIMITIVE* matrice_ves = cube;
      while(frac_volumique< cible_frac_volumique && nb_inclusion<nb_max_inclusion && it<it_max)
      {
        double position[3];
        position[0] = distribution_position_x(generateur);
        position[1] = distribution_position_y(generateur);
        position[2] = distribution_position_z(generateur);
        double longueur[3];
        longueur[0] = distribution_longueur_x(generateur);
        longueur[1] = distribution_longueur_y(generateur);
        longueur[2] = distribution_longueur_z(generateur);
        double rayon_sphere_grille = sqrt(0.5*longueur[0]*0.5*longueur[0]+0.5*longueur[1]*0.5*longueur[1]+0.5*longueur[2]*0.5*longueur[2]);
        bool ok_position=true;
        if((position[0])<0.05) ok_position=false; 
        else if((position[1])<0.05) ok_position=false;
        else if((position[2])<0.05) ok_position=false;  
        else if((position[0]+longueur[0])>(dim_VES[0]-0.05)) ok_position=false; 
        else if((position[1]+longueur[1])>(dim_VES[1]-0.05)) ok_position=false;
        else if((position[2]+longueur[2])>(dim_VES[2]-0.05)) ok_position=false;
        if(ok_position)
        {       
          double rayon_recherche = rayon_sphere_grille*facteur_distance;
          TPL_MAP_ENTITE<SPHERE_GRILLE*> map_recherche;
          grille.rechercher(position[0]+0.5*longueur[0],position[1]+0.5*longueur[1],position[2]+0.5*longueur[2],rayon_recherche,map_recherche);
          bool ok_insert=true;
          if(map_recherche.get_nb()>0)
          {
            TPL_MAP_ENTITE<SPHERE_GRILLE*>::ITERATEUR it_map_recherche;
            for(SPHERE_GRILLE* sph = map_recherche.get_premier(it_map_recherche);sph!=NULL;sph=map_recherche.get_suivant(it_map_recherche))
            {
              double xyz_sph[3];
              sph->get_xyz(xyz_sph);
              if(sqrt((xyz_sph[0]-(position[0]+0.5*longueur[0]))*(xyz_sph[0]-(position[0]+0.5*longueur[0]))+
                      (xyz_sph[1]-(position[1]+0.5*longueur[1]))*(xyz_sph[1]-(position[1]+0.5*longueur[1]))+
                      (xyz_sph[2]-(position[2]+0.5*longueur[2]))*(xyz_sph[2]-(position[2]+0.5*longueur[2])))<(1.1*(sph->get_rayon()+rayon_sphere_grille)))
                ok_insert=false;
            }
          }
          else if(map_recherche.get_nb()==0) ok_insert=true;
          if(ok_insert)
          {
            MG_PRIMITIVE_BOITE *boite = new MG_PRIMITIVE_BOITE(position[0],position[1],position[2],position[0]+longueur[0],position[1]+longueur[1],position[2]+longueur[2]);
            boite->construit();
            MG_PRIMITIVE_BOITE *boite_outil = new MG_PRIMITIVE_BOITE(position[0],position[1],position[2],position[0]+longueur[0],position[1]+longueur[1],position[2]+longueur[2]);
            boite_outil->construit();
            if(((position[0] > 0.0) && ((position[0]+longueur[0]) < dim_VES[0])) &&
              ((position[1] > 0.0) && ((position[1]+longueur[1]) < dim_VES[1])) &&
              ((position[2] > 0.0) && ((position[2]+longueur[2]) < dim_VES[0])))
            {       
              char message[1000];
              sprintf(message,"Inclusion #%li",id_sphere_grille);
              affiche(message);
              nb_inclusion++;
              arbre->ajouter_mg_primitive(boite);
              arbre->ajouter_mg_primitive(boite_outil);
              MG_OPERATEUR_BOOLEAN_DIFFERENCE *op_difference=new MG_OPERATEUR_BOOLEAN_DIFFERENCE(MAGIC::SEMANTIQUECSG::SANS,matrice_ves,boite_outil);
              matrice_ves=op_difference->construit();
              arbre->ajouter_mg_operateur_boolean(op_difference);
              assemblage->ajouter_mg_primitive(boite);
              volume_inclusion+=boite->get_volume();                
              SPHERE_GRILLE *sp = new SPHERE_GRILLE(position[0]+0.5*longueur[0],position[1]+0.5*longueur[1],position[2]+0.5*longueur[2],rayon_sphere_grille,id_sphere_grille);
              vector_sphere_grille.push_back(sp);
              grille.inserer(sp);
              id_sphere_grille++;
              it=0;
            }
            else
            {
              
              MG_PRIMITIVE_BOITE *cube_inter = new MG_PRIMITIVE_BOITE(0,0,0,dim_VES[0],dim_VES[1],dim_VES[2]);
              cube_inter->construit();
              MG_OPERATEUR_BOOLEAN_INTERSECTION *op_intersection = new MG_OPERATEUR_BOOLEAN_INTERSECTION(MAGIC::SEMANTIQUECSG::SANS,boite,cube_inter);
              //MG_OPERATEUR_BOOLEAN_INTERSECTION *op_intersection = new MG_OPERATEUR_BOOLEAN_INTERSECTION(MAGIC::SEMANTIQUECSG::SANS,cube_inter,boite);
              MG_PRIMITIVE *boite_inter = op_intersection->construit();     
              if(boite_inter->get_volume()> 0.25*(boite->get_volume()))
              {       
                volume_inclusion+=boite_inter->get_volume();
                char message[1000];
                sprintf(message,"Inclusion #%li : COUPÉE",id_sphere_grille);
                affiche(message);
                nb_inclusion++;
                MG_OPERATEUR_BOOLEAN_DIFFERENCE *op_difference=new MG_OPERATEUR_BOOLEAN_DIFFERENCE(MAGIC::SEMANTIQUECSG::SANS,matrice_ves,boite_outil);
                matrice_ves=op_difference->construit();       
                arbre->ajouter_mg_primitive(boite);
                arbre->ajouter_mg_primitive(boite_outil);
                arbre->ajouter_mg_operateur_boolean(op_difference);
                arbre->ajouter_mg_primitive(boite_inter);
                arbre->ajouter_mg_primitive(cube_inter);
                assemblage->ajouter_mg_primitive(boite_inter);
                SPHERE_GRILLE *sp = new SPHERE_GRILLE(position[0]+0.5*longueur[0],position[1]+0.5*longueur[1],position[2]+0.5*longueur[2],rayon_sphere_grille,id_sphere_grille);
                vector_sphere_grille.push_back(sp);
                grille.inserer(sp);
                id_sphere_grille++;
                it=0;
              }
              else
              {
                delete boite;
                delete boite_outil;
                delete boite_inter;
                delete cube_inter;
                delete op_intersection;
              }
            }     
            frac_volumique = volume_inclusion/(cube->get_volume());       
          }
          it++;
        }
      }
      arbre->ajouter_mg_primitive(matrice_ves);
      assemblage->ajouter_mg_primitive(matrice_ves);
      char message[1000];
      sprintf(message,"echo -n  %li:%lf: >> resultats.txt",nb_inclusion,frac_volumique);
      system(message);
      break;
    }
  }
  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);
      }
    }
  }
return 0;
    
}

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);
      }
    }
  }
return 0;
    
}

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);
  MAILLEUR_FEM m;
  m.maille(fem);
  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);
  return 0;
}

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);
    char messagesortie[1000];
    sprintf(messagesortie,"echo  %lf  >> resultats.txt",K);
    system(messagesortie);
  }
  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);
    char messagesortie[1000];
    sprintf(messagesortie,"echo  %lf  >> resultats.txt",G);
    system(messagesortie);
  }
return 0;  
}
Revision:	1158
Committed:	Thu Jun 13 22:18:49 2024 UTC (11 months, 1 week ago) by francois
File size:	32854 byte(s)
Log Message:	compatibilité Ubuntu 22.04 Suppression des refeences à Windows Ajout d'une banière