fct_taille_fem_solution_generateur_echantillon_frontiere.cpp

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       fct_taille_fem_solution_generateur_echantillon_frontiere.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:53 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
#include "gestionversion.h"
#include <math.h>
#include "fct_taille_fem_solution_generateur_echantillon_frontiere.h"
#include "tpl_grille.h"
 
 
 
FCT_TAILLE_FEM_SOLUTION_GENERATEUR_ECHANTILLON_FRONTIERE::FCT_TAILLE_FEM_SOLUTION_GENERATEUR_ECHANTILLON_FRONTIERE
(MG_GESTIONNAIRE *gesttmp,MG_GEOMETRIE* geotmp,double dg,int fechantillon,int nxtmp,
 int nytmp,int nztmp,char *nomsolution,double eps,double ind1,double ind2,double *lst_pt_ctrl,int nbpt):
 FCT_TAILLE_FEM_SOLUTION_ECHANTILLONNAGE_ESTIMATION(gesttmp, geotmp, dg,fechantillon,nxtmp,
nytmp, nztmp, nomsolution, ind1, ind2),epsilon(eps),point_controle(lst_pt_ctrl),nb_pt_ctrl(nbpt)
{
 
}
 
FCT_TAILLE_FEM_SOLUTION_GENERATEUR_ECHANTILLON_FRONTIERE::FCT_TAILLE_FEM_SOLUTION_GENERATEUR_ECHANTILLON_FRONTIERE
(FCT_TAILLE_FEM_SOLUTION_GENERATEUR_ECHANTILLON_FRONTIERE &mdd):
FCT_TAILLE_FEM_SOLUTION_ECHANTILLONNAGE_ESTIMATION(mdd), epsilon(mdd.epsilon)
{
 
}
FCT_TAILLE_FEM_SOLUTION_GENERATEUR_ECHANTILLON_FRONTIERE::~FCT_TAILLE_FEM_SOLUTION_GENERATEUR_ECHANTILLON_FRONTIERE()
{
TPL_MAP_ENTITE<CT_POINT_ECHANTILLONNAGE* >::ITERATEUR it;
for(CT_POINT_ECHANTILLONNAGE* PT=lstpoint.get_premier(it);PT!=NULL;PT=lstpoint.get_suivant(it))
 delete PT;
}
void FCT_TAILLE_FEM_SOLUTION_GENERATEUR_ECHANTILLON_FRONTIERE::echantillonnage(void)
{
   double xmin=1e308,ymin=1e308,zmin=1e308,xmax=-1e308,ymax=-1e308,zmax=-1e308;
   int nb_face=geo->get_nb_mg_face();
   TPL_MAP_ENTITE<CT_FACE*> lstface;
   for (int j=0;j<nb_face;j++)
       {
       MG_FACE* face=geo->get_mg_face(j);
       CT_FACE* cface=new CT_FACE(face);
       cface->change_umax(-1e308);
       cface->change_umin(1e308);
       cface->change_vmax(-1e308);
       cface->change_vmin(1e308);
       lstface.ajouter(cface);
       }
  int nb_arete=geo->get_nb_mg_arete();
  for (int j=0;j<nb_arete;j++)
       {
       MG_ARETE* arete=geo->get_mg_arete(j);
       std::vector<MG_FACE*> vector_mgface;
       for(int k=0;k<arete->get_nb_mg_coarete();k++)
       {
         if(geo->get_mg_coareteid(arete->get_mg_coarete(k)->get_id())!=NULL)
         {
           MG_FACE* mg_face = arete->get_mg_coarete(k)->get_boucle()->get_mg_face();
           if(geo->get_mg_faceid(mg_face->get_id())!=NULL)  vector_mgface.push_back(mg_face);
         }
       }
       int nbfac = vector_mgface.size();
       double tmin=arete->get_tmin();
       double tmax=arete->get_tmax();
       double tdemi=0.5*(tmax+tmin);
       double xyz1[3],xyz2[3];
       arete->evaluer(tmin,xyz1);
       arete->evaluer(tdemi,xyz2);
       OT_VECTEUR_3D vec(xyz1,xyz2);
       double densdep=vec.get_longueur()*2.;
       for (int k=0;k<fechan+1;k++)
           {
           double t=tmin+1.0*k/fechan*(tmax-tmin);
           double xyz[3];
           arete->evaluer(t,xyz);
           if (xyz[0]<xmin) xmin=xyz[0];
           if (xyz[0]>xmax) xmax=xyz[0];
           if (xyz[1]<ymin) ymin=xyz[1];
           if (xyz[1]>ymax) ymax=xyz[1];
           if (xyz[2]<zmin) zmin=xyz[2];
           if (xyz[2]>zmax) zmax=xyz[2];
           double courbure=arete->get_M(t);
           for (int l=0;l<nbfac;l++)
               {
               double uv[2];
               vector_mgface[l]->inverser(uv,xyz);
               CT_FACE* fac=lstface.getid(vector_mgface[l]->get_id());
               
               if (uv[0]>fac->get_umax()) fac->change_umax(uv[0]);
               if (uv[0]<fac->get_umin()) fac->change_umin(uv[0]);
               if (uv[1]>fac->get_vmax()) fac->change_vmax(uv[1]);
               if (uv[1]<fac->get_vmin()) fac->change_vmin(uv[1]);
               double cmin,cmax;
               vector_mgface[l]->get_courbure(uv,cmax,cmin);
               cmax=fabs(cmax);
               if (cmax>courbure) courbure=cmax;
               }
           double dn=densdep;
           if (!(OPERATEUR::egal(courbure,0.0,1e-8))) 
                      dn=sqrt(8*epsilon/courbure);
              else 
                      dn=ecart_nodal;
           if (dn>ecart_nodal) 
              dn=ecart_nodal;
           if (densdep<dn)
              dn=densdep;
           double dist=zonezoom*(ecart_nodal-dn);
           if (!(OPERATEUR::egal(dist,0.0,1e-8)))
                    {
                        BOITE_3D boite(xyz[0]-dist,xyz[1]-dist,xyz[2]-dist,xyz[0]+dist,xyz[1]+dist,xyz[2]+dist);
                         double ecart=dn; 
                         CT_POINT_ECHANTILLONNAGE* pt=new CT_POINT_ECHANTILLONNAGE(xyz[0],xyz[1],xyz[2],ecart,boite);
                         lstpoint.ajouter(pt);
                    }
                  
           }
        }
        for (int j=0;j<nb_face;j++)
        {
          MG_FACE* face=geo->get_mg_face(j);
          CT_FACE* cface=lstface.getid(face->get_id());
          double umin=cface->get_umin();
          double vmin=cface->get_vmin();
          double umax=cface->get_umax();
          double vmax=cface->get_vmax();
          if(face->get_surface()->est_periodique_u())
          {
            umin=0;
            umax=face->get_surface()->get_periode_u();
          }
          if(face->get_surface()->est_periodique_v())
          {
            vmin=0;
            vmax=face->get_surface()->get_periode_v();
          }
            for (int k=0;k<fechan+1;k++)
              for (int l=0;l<fechan+1;l++)
              {
                double uv[2];
                uv[0]=umin+1.0*k/fechan*(umax-umin);
                uv[1]=vmin+1.0*l/fechan*(vmax-vmin);
                double xyz[3];
                face->evaluer(uv,xyz);
                if (xyz[0]<xmin) xmin=xyz[0];
                if (xyz[1]<ymin) ymin=xyz[1];
                if (xyz[2]<zmin) zmin=xyz[2];
                if (xyz[0]>xmax) xmax=xyz[0];
                if (xyz[1]>ymax) ymax=xyz[1];
                if (xyz[2]>zmax) zmax=xyz[2];
                double cmax,cmin;
                face->get_courbure(uv,cmax,cmin);
                cmax=fabs(cmax);
                double dn;
                if (!(OPERATEUR::egal(cmax,0.0,1e-8))) 
                  dn=sqrt(8*epsilon/cmax);
                else dn=ecart_nodal;
                if (dn>ecart_nodal) 
                  dn=ecart_nodal;
                double dist=zonezoom*(ecart_nodal-dn);
                if (!(OPERATEUR::egal(dist,0.0,1e-8)))
                {
                  BOITE_3D boite(xyz[0]-dist,xyz[1]-dist,xyz[2]-dist,xyz[0]+dist,xyz[1]+dist,xyz[2]+dist);
                  double ecart=dn;
                  CT_POINT_ECHANTILLONNAGE* pt=new CT_POINT_ECHANTILLONNAGE(xyz[0],xyz[1],xyz[2],ecart,boite); 
                  lstpoint.ajouter(pt);
                }
            
            
          }
          
        } 
        char message[500];
    int nbptech=lstpoint.get_nb();
        sprintf(message,"        Nombre de points d'échantillonage sur les entites %d",nbptech);
        affiche(message);
        //insertion des points de controles
    for (int i=0;i<nb_pt_ctrl;i++)
    {
        double xyz[3];
        xyz[0]=point_controle[4*i];
        xyz[1]=point_controle[4*i+1];
        xyz[2]=point_controle[4*i+2];
        double dn=point_controle[4*i+3];
        double dist=zonezoom*(ecart_nodal-dn);
        BOITE_3D boite(xyz[0]-dist,xyz[1]-dist,xyz[2]-dist,xyz[0]+dist,xyz[1]+dist,xyz[2]+dist);
        double ecart=dn;
        CT_POINT_ECHANTILLONNAGE* pt=new CT_POINT_ECHANTILLONNAGE(xyz[0],xyz[1],xyz[2],ecart,boite);
        lstpoint.ajouter(pt);
    }
    nbptech=lstpoint.get_nb()-nbptech;
        sprintf(message,"        Nombre de points d'échantillonage depuis le fichier %d",nbptech);
        affiche(message);
        TPL_MAP_ENTITE<CT_POINT_ECHANTILLONNAGE* >::ITERATEUR it11;
        BOITE_3D boi(xmin,ymin,zmin,xmax,ymax,zmax); 
        boi.change_grosseur(facteur_grossissement*1.01);
        xmin=boi.get_xmin();
        ymin=boi.get_ymin();
        zmin=boi.get_zmin();
        xmax=boi.get_xmax();
        ymax=boi.get_ymax();
        zmax=boi.get_zmax();
        int nbechan=lstpoint.get_nb();
        int nx=pow(nbechan,0.33333333333333333)+1;
        TPL_GRILLE<CT_POINT_ECHANTILLONNAGE*> grille;
        grille.initialiser(boite_englobante.get_xmin(),boite_englobante.get_ymin(),boite_englobante.get_zmin(),boite_englobante.get_xmax(),boite_englobante.get_ymax(),boite_englobante.get_zmax(),nx,ny,nz);
        TPL_MAP_ENTITE<CT_POINT_ECHANTILLONNAGE* > lstpoint2;
        for(CT_POINT_ECHANTILLONNAGE* PT=lstpoint.get_premier(it11);PT!=NULL;PT=lstpoint.get_suivant(it11))
              {
                 double xyz[3];
                 PT->evaluer(xyz);
                 double ecart=PT->get_valeur(); 
                 BOITE_3D boite(xyz[0],xyz[1],xyz[2],xyz[0],xyz[1],xyz[2]); 
                 TPL_CELLULE_GRILLE<CT_POINT_ECHANTILLONNAGE*> *cell=grille.get_cellule(xyz[0],xyz[1],xyz[2]);
                 int trouve=0;
                 for (int j=0;j<cell->get_nb_entite();j++)
                          {
                          CT_POINT_ECHANTILLONNAGE* pt=cell->get_entite(j);
                          double xyz2[3];
                          pt->evaluer(xyz2);
                          OT_VECTEUR_3D vec(xyz,xyz2);
                          if (vec.get_longueur()<1e-10*boite_englobante.get_rayon())
                                  {
                                  if (PT->get_valeur()<pt->get_valeur()) pt->change_valeur(PT->get_valeur());
                                  PT->change_etat(false);
                                  trouve=1;
                                  }
                          }
                 if (trouve==0)
                    {
                    CT_POINT_ECHANTILLONNAGE* pt=new CT_POINT_ECHANTILLONNAGE(xyz[0],xyz[1],xyz[2],ecart,boite); 
                    lstpoint2.ajouter(pt);
                    grille.inserer(pt);
                    }
              }
         
         
         
              
              
              
        octre.initialiser(&lstpoint2,1,xmin,ymin,zmin,xmax, ymax, zmax); 
        for(CT_POINT_ECHANTILLONNAGE* PT=lstpoint2.get_premier(it11);PT!=NULL;PT=lstpoint2.get_suivant(it11))
          delete PT;
        int nb_point=lstpoint.get_nb();
        for(CT_POINT_ECHANTILLONNAGE* PT=lstpoint.get_premier(it11);PT!=NULL;PT=lstpoint.get_suivant(it11))
         if (PT->get_etat()==true) octre.inserer(PT);
          
        
    
}