dly_segment.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       dly_segment.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:55 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
 
#include "gestionversion.h"
 
#include <stdlib.h>
#include "dly_noeud.h"
#include "dly_segment.h"
#include "dly_tetra.h"
#include "ot_mathematique.h"
#include "fct_taille.h"
#include <math.h>
 
 
 
DLY_SEGMENT::DLY_SEGMENT(class DLY_NOEUD *no1,class DLY_NOEUD *no2):noeud1(no1),noeud2(no2)
{
}
DLY_SEGMENT::DLY_SEGMENT(DLY_SEGMENT& mdd):noeud1(mdd.noeud1),noeud2(mdd.noeud2),longueur(mdd.longueur)
{
}
DLY_SEGMENT::~DLY_SEGMENT()
{
}
 
DLY_NOEUD* DLY_SEGMENT::get_noeud1(void)
{
return noeud1;
}
DLY_NOEUD* DLY_SEGMENT::get_noeud2(void)
{
return noeud2;
}
 
void DLY_SEGMENT::insere_lien_tetra(DLY_TETRA* tet)
{
lsttet.push_back(tet);
}
 
 
int DLY_SEGMENT::tet_est_present(DLY_TETRA* tet)
{
for (std::vector<DLY_TETRA*>::iterator it=lsttet.begin();it!=lsttet.end();it++)
    if ((*it)==tet) return 1;return 0;
}
 
int DLY_SEGMENT::get_nb_tetra(void)
{
return lsttet.size();
}
 
DLY_TETRA* DLY_SEGMENT::get_tetra(int i)
{
return lsttet[i];
}
 
DLY_TETRA* DLY_SEGMENT::get_tetra_feuille(void)
{
int i=0;
int ok=0;
while (ok==0)
  {
  if (lsttet[i]->get_feuille()==1) ok=1;
  else i++;
  if (i>=lsttet.size()) return NULL;
  }
return lsttet[i];
}
    
double DLY_SEGMENT::get_longueur(void)
{
return longueur;
}
 
double  DLY_SEGMENT::calcul_longueur(class FCT_TAILLE *metrique,int pas,int conserve)
{
double l;
double xyz1[3],xyz2[3];
noeud1->get_coord(xyz1);
noeud2->get_coord(xyz2);
OT_VECTEUR_3D vec1(xyz1,xyz2);
if (metrique==NULL)
    {
        l=vec1.get_longueur();
        if (conserve) {longueur=l;t_demilongueur=0.5;}
        return l;
    }
l=0.;
double dxyz[3];
dxyz[0]=xyz2[0]-xyz1[0];
dxyz[1]=xyz2[1]-xyz1[1];
dxyz[2]=xyz2[2]-xyz1[2];
double tab[pas+1],t[pas+1];
for (int i=0;i<pas;i++)
        {
        double ti=1.0*i/pas;
        double tii=1.0*(i+1)/pas;
        t[i]=ti;
        t[i+1]=tii;
        double tgauss1=0.7886751345*tii+0.2113248654*ti;
        double xyz[3];
        xyz[0]=xyz1[0]+tgauss1*(xyz2[0]-xyz1[0]);
        xyz[1]=xyz1[1]+tgauss1*(xyz2[1]-xyz1[1]);
        xyz[2]=xyz1[2]+tgauss1*(xyz2[2]-xyz1[2]);
        double tenseur[9];
        metrique->evaluer(xyz,tenseur);
        double val1= sqrt(dxyz[0]*dxyz[0]*tenseur[0]+dxyz[0]*dxyz[1]*tenseur[3]+dxyz[0]*dxyz[2]*tenseur[6]+dxyz[1]*dxyz[0]*tenseur[1]+dxyz[1]*dxyz[1]*tenseur[4]+dxyz[1]*dxyz[2]*tenseur[7]+dxyz[2]*dxyz[0]*tenseur[2]+dxyz[2]*dxyz[1]*tenseur[5]+dxyz[2]*dxyz[2]*tenseur[8]);
        double tgauss2=0.7886751345*ti+0.2113248654*tii;
        xyz[0]=xyz1[0]+tgauss2*(xyz2[0]-xyz1[0]);
        xyz[1]=xyz1[1]+tgauss2*(xyz2[1]-xyz1[1]);
        xyz[2]=xyz1[2]+tgauss2*(xyz2[2]-xyz1[2]);
        metrique->evaluer(xyz,tenseur);
        double val2= sqrt(dxyz[0]*dxyz[0]*tenseur[0]+dxyz[0]*dxyz[1]*tenseur[3]+dxyz[0]*dxyz[2]*tenseur[6]+dxyz[1]*dxyz[0]*tenseur[1]+dxyz[1]*dxyz[1]*tenseur[4]+dxyz[1]*dxyz[2]*tenseur[7]+dxyz[2]*dxyz[0]*tenseur[2]+dxyz[2]*dxyz[1]*tenseur[5]+dxyz[2]*dxyz[2]*tenseur[8]);
        tab[i]=l;
        l=l+0.5*(tii-ti)*(val1+val2);
        tab[i+1]=l;
        } 
    if (conserve) 
      {
      longueur=l;
      int i;
      for(i=0;tab[i]<l/2.;i++);
      t_demilongueur=t[i]+(t[i+1]-t[i])/(tab[i+1]-tab[i])*(l/2.-tab[i]);
      }
    return l;
}
double DLY_SEGMENT::get_critere(void)
{
return critere;
}
 
void DLY_SEGMENT::change_critere(double crit)
{
critere=crit;
}
 
 
 
void DLY_SEGMENT::decoupe_noeud(std::vector<double> &lstpt) // a adapter pour taille variable
{
    double xyz1[3],xyz2[3],x,y,z;
    noeud1->get_coord(xyz1);
    noeud2->get_coord(xyz2);
    x=xyz1[0]+t_demilongueur*(xyz2[0]-xyz1[0]);
    y=xyz1[1]+t_demilongueur*(xyz2[1]-xyz1[1]);
    z=xyz1[2]+t_demilongueur*(xyz2[2]-xyz1[2]);
    lstpt.push_back(x);
    lstpt.push_back(y);
    lstpt.push_back(z);
}