geometrie/src/vct_face.cpp

#include "gestionversion.h"
//---------------------------------------------------------------------------


#pragma hdrstop

#include "vct_face.h"
#include "mg_face.h"
#include "mg_surface.h"
#include "vct_outils.h"
#include "mg_arete.h"
#include "ot_mathematique.h"
#include <math.h>
#include <iomanip>
#include "sld_fonction.h"
#include "constantegeo.h"
//---------------------------------------------------------------------------

#pragma package(smart_init)


VCT_FACE::VCT_FACE(MG_FACE* face):VCT_ELEMENT_TOPOLOGIQUE(face)
{

int indx;
nb_points=0;
TPL_LISTE_ENTITE<double> param_surf;
TPL_LISTE_ENTITE<double> param_courb;
MG_SURFACE*surf=face->get_surface();
int type=0;
if(surf->get_type_geometrique(param_surf)==MGCo_PLAN)
{
 type=1;
}
if(surf->get_type_geometrique(param_surf)==MGCo_CYLINDRE)
{
 type=2;
}
OT_VECTEUR_4DD VCT_NUL(0.,0.,0.,0.);
double2 ZERO=0.;

           int nb_boucle=((MG_FACE*)elem_topo)->get_nb_mg_boucle();

            for(int j=0;j<nb_boucle;j++)
               {
                MG_BOUCLE* Boucle = ((MG_FACE*)elem_topo)->get_mg_boucle(j);
                int nbarete = Boucle->get_nb_mg_coarete();
                for (int w =0; w<nbarete;w++)
                        {
                        double xyz[3];
                        TPL_LISTE_ENTITE<double> lst_points_ctrls;
                        MG_COARETE* coArete = Boucle->get_mg_coarete(w);
                        MG_ARETE* arete = coArete->get_arete();
                        int sens=coArete->get_orientation();
                        arete->get_param_NURBS(indx,lst_points_ctrls);
                        MG_COURBE*courb=arete->get_courbe();
                        int nb_points_arete=arete->get_vectorisation().get_nb_points();
                        vector<OT_VECTEUR_4DD>& list_points=arete->get_vectorisation().get_points_controle();

                        for(int i=0;i< nb_points_arete;i++)
                          {

                          OT_VECTEUR_4DD POINT= list_points[i];
                          if(type==2)
                           {
                           if(courb->get_type_geometrique(param_courb)==MGCo_CIRCLE)
                             if (i==0|| i==3)
                              {
                               lst_points_axes.insert(lst_points_axes.end(),POINT);
                              }
                           }

                          lst_points.insert(lst_points.end(),POINT);
                         // if (w==0&&i==0&&nb_points_arete==2)
                          if(!type||type==1)
                          lst_points_axes.insert(lst_points_axes.end(),POINT);

                          }

                          std::vector<OT_VECTEUR_4DD>& list_vect=arete->get_vectorisation().get_vecteurs() ;
                          if(!type||type==1)
                            for(unsigned int i=0;i<list_vect.size();i++)
                             {
                             OT_VECTEUR_4DD v=list_vect[i]  ;
                             if (sens<0) v=-1*v;
                             lst_vecteurs.insert(lst_vecteurs.end(),v);
                             lst_vecteurs_axes.insert(lst_vecteurs_axes.end(),v);
                             }
                        nb_points+=nb_points_arete;
                      }

               }
   if(type==2)
     {
           vector<OT_VECTEUR_4DD> lst_pts;
           lst_pts.insert(lst_pts.end(),lst_points_axes[0] ) ;
           lst_pts.insert(lst_pts.end(),lst_points_axes[1] ) ;
           lst_pts.insert(lst_pts.end(),lst_points_axes[3] ) ;
           lst_pts.insert(lst_pts.end(),lst_points_axes[2] ) ;
              for(int r=0;r<lst_pts.size();r++)
                 {     OT_VECTEUR_4DD V;
                       if(r<lst_pts.size()-1)
                         V=lst_pts[r+1]-lst_pts[r];
                       if(r==lst_pts.size()-1)
                         V=lst_pts[0]-lst_pts[r];
                        double2 norm_au_carre=(V[0]*V[0])+(V[1]*V[1])+(V[2]*V[2])+(V[3]*V[3]);
                        double2 norm=norm_au_carre^0.5;
                         if(V==VCT_NUL)
                           lst_vecteurs.insert(lst_vecteurs.end(),VCT_NUL);
                         if(norm!=ZERO)
                           {
                           V=1./norm*V;
                           lst_vecteurs_axes.insert(lst_vecteurs_axes.end(),V);
                           }
                 }
     }

}


VCT_FACE::VCT_FACE(VCT_FACE& mdd):VCT_ELEMENT_TOPOLOGIQUE(mdd.elem_topo)
{
lst_vecteurs=mdd.lst_vecteurs;
lst_points =mdd.lst_points;
nb_points=mdd.nb_points;
}


VCT_FACE::~ VCT_FACE()
{

}


std::vector<OT_VECTEUR_4DD>& VCT_FACE::get_points_controle(void)
{
return lst_points;
}
std::vector<OT_VECTEUR_4DD>& VCT_FACE::get_points_controle_pour_axes(void)
{
return lst_points_axes;
}


std::vector<OT_VECTEUR_4DD> & VCT_FACE::get_vecteurs()
{
return lst_vecteurs;
}


OT_TENSEUR VCT_FACE:: calcule_tenseur_metrique()
{
OT_TENSEUR tns(lst_vecteurs);
return tns;
}

OT_VECTEUR_4DD VCT_FACE::calcule_barycentre(OT_TENSEUR& TT)
{
T=TT;
OT_VECTEUR_4DD barycentre(0,0,0,0);

for(int i=0;i<nb_points;i++)
 {
 OT_VECTEUR_4DD pt=get_nouveau_pt(T,lst_points[i]);
 //barycentre+=lst_points[i];
 barycentre+=pt;
 }

barycentre*=1./nb_points;

return barycentre;

}


int VCT_FACE::get_nb_points()
 {
 return nb_points  ;
 }


OT_TENSEUR  VCT_FACE::calcule_covariance(OT_TENSEUR& T)
{
   OT_TENSEUR COVARIANCE(4);
   OT_VECTEUR_4DD barycentre=calcule_barycentre( T);
   OT_TENSEUR PT_CENTRE(nb_points,4),PT_CENTRE_TRANSPOSE;


   for( int i=0;i<nb_points;i++)
    {
      //OT_VECTEUR_4DD pt=lst_points[i];
      OT_VECTEUR_4DD pt=get_nouveau_pt(T,lst_points[i]);
      //OT_VECTEUR_4DD ptcent=lst_points[i]-barycentre;
       OT_VECTEUR_4DD ptcent=pt-barycentre;
            for (int j=0;j<4;j++)
              PT_CENTRE(i,j)= ptcent[j];

    }
   PT_CENTRE_TRANSPOSE =PT_CENTRE.transpose();


   COVARIANCE=PT_CENTRE_TRANSPOSE*PT_CENTRE;
   double2 COEF= 1./nb_points;
   COVARIANCE=COVARIANCE*COEF;

   for(int i=0;i<4;i++)
      for(int j=0;j<4;j++)
        {
          if(fabs(COVARIANCE(i,j).get_x())<=1e-8)
          COVARIANCE(i,j).set_x(0.);

        }


   return  COVARIANCE;
}


void  VCT_FACE::calcule_axes_dinertie(OT_TENSEUR& T,OT_VECTEUR_4DD& D,OT_TENSEUR& V)
{

 int n=4;
 int nrot;

 OT_TENSEUR COV=calcule_covariance(T);


 double2 zro=0.0;

 if(COV(0,0)==zro&&COV(1,0)==zro&&COV(2,0)==zro&&COV(3,0)==zro)
   {
   COV(0,0)=1.0;
   COV(1,0)=zro;
   COV(2,0)=zro;
   COV(3,0)=zro;
   }
 if(COV(0,1)==zro&&COV(1,1)==zro&&COV(2,1)==zro&&COV(3,1)==zro)
   {
   COV(0,1)=zro;
   COV(1,1)=1.0;
   COV(2,1)=zro;
   COV(3,1)=zro;
   }
  if(COV(0,2)==zro&&COV(1,2)==zro&&COV(2,2)==zro&&COV(3,2)==zro)
   {
   COV(0,2)=zro;
   COV(1,2)=zro;
   COV(2,2)=1.0;
   COV(3,2)=zro;
   }
  if(COV(0,3)==zro&&COV(1,3)==zro&&COV(2,3)==zro&&COV(3,3)==zro)
   {
   COV(0,3)=zro;
   COV(1,3)=zro;
   COV(2,3)=zro;
   COV(3,3)=1.0;
   }


COV.get_orthogonalisation(COV,D,V,n,nrot);
/*

       OT_VECTEUR_4DD G1;
       OT_TENSEUR p(4),q(4),pT,qT;

       G1=calcule_barycentre(T);
       //OT_VECTEUR_4DD VNul(0.0001,0.0001,0.0001,0.0001);
       double2 z=0.0001;
       double2 cof=-1;
       int plan=-1;

       pT=p.transpose();

       vector<OT_VECTEUR_4DD>& list_points1=get_points_controle_pour_axes();
       vector<OT_VECTEUR_4DD>& list_vecteurs1=lst_vecteurs_axes;//get_vecteurs();
       OT_VECTEUR_4DD Normal1(0.,0.,0.,0.),N1;
       OT_VECTEUR_4DD axe11,axe12,axe13;
       int cmpt=0;

       OT_VECTEUR_4DD v11= list_vecteurs1[0];
       int nb_vecteur1=list_vecteurs1.size();
       for(unsigned int pi=0;pi<nb_vecteur1-1;pi++)
           {
               OT_VECTEUR_4DD v2= list_vecteurs1[pi+1];
               if(pi==0)
                  Normal1=v11^v2;
               if (pi>0)
                  N1=v11^v2;
               OT_VECTEUR_4DD colineaire= Normal1^N1;
               if(colineaire[0].get_fabs()<z&&colineaire[1].get_fabs()<z&&colineaire[2].get_fabs()<z&&colineaire[3].get_fabs()<z)
                  {
                    cmpt++;
                  }
           }
                vector<OT_VECTEUR_4DD> axes1;
                if (cmpt== list_vecteurs1.size()-1)
                  {
                  plan=1;
                  axe11=list_vecteurs1[0];
                  axe12=Normal1^axe11;
                  axe13=Normal1;
                  axes1.insert(axes1.end(),axe11);
                  axes1.insert(axes1.end(),axe12);
                  axes1.insert(axes1.end(),axe13);
                  }

         VCT_OUTILS VOUTIL(4);
         OT_MATRICE_3D  sys_axes1=VOUTIL.get_system_axes(G1,axes1,list_points1) ;
         for(int i=0;i<4;i++)
            {
             for(int j=0;j<4;j++)
                {
                if(i<3&&j<3)
                V(i,j)= sys_axes1(i,j);
                if(i<3 &&j>2)
                V(i,j)=0.;
                if(i==3&&j==3)  V(i,j)=1.;
                }
           }  */
 }


OT_TENSEUR VCT_FACE:: calcule_tenseur_inertie_au_barycentre(OT_TENSEUR& T)  //repere globale
{
 OT_TENSEUR INERTIE(4);
 OT_TENSEUR cov=calcule_covariance(T);
 double2 nb_pts=nb_points;
 double2 MOINS_UN=-1.0;
 INERTIE=cov*MOINS_UN;
 INERTIE=INERTIE*nb_pts;

 INERTIE(0,0)=(cov(1,1)+cov(2,2)+cov(3,3))*nb_pts;
 INERTIE(1,1)=(cov(0,0)+cov(2,2)+cov(3,3))*nb_pts;
 INERTIE(2,2)=(cov(1,1)+cov(0,0)+cov(3,3))*nb_pts;
 INERTIE(3,3)=(cov(1,1)+cov(2,2)+cov(0,0))*nb_pts;
   for(int i=0;i<4;i++)
      for(int j=0;j<4;j++)
        {
          if(fabs(INERTIE(i,j).get_x())<=1e-12) INERTIE(i,j).set_x(0.);

        }


 return INERTIE;


}


OT_TENSEUR VCT_FACE:: calcule_tenseur_inertie_au_pt(OT_TENSEUR& T,OT_VECTEUR_4DD& POINT)
{

OT_VECTEUR_4DD BARYCENTRE=calcule_barycentre(T);
OT_TENSEUR TENS=calcule_tenseur_inertie_au_barycentre(T);

OT_VECTEUR_4DD ABC=POINT-BARYCENTRE;

double2 a=ABC[0] ;
double2 b=ABC[1] ;
double2 c=ABC[2] ;
double2 d=ABC[3] ;

TENS(0,0)=TENS(0,0)+b*b+c*c+d*d;
TENS(1,1)=TENS(1,1)+a*a+c*c+d*d;
TENS(2,2)=TENS(2,2)+a*a+b*b+d*d;
TENS(3,3)=TENS(3,3)+a*a+b*b+c*c;

TENS(0,1)=TENS(0,1)-nb_points*a*b;
TENS(0,2)=TENS(0,2)-nb_points*a*c;
TENS(0,3)=TENS(0,3)-nb_points*a*d;

TENS(1,0)=TENS(1,0)-nb_points*b*a;
TENS(1,2)=TENS(1,2)-nb_points*b*c;
TENS(1,3)=TENS(1,3)-nb_points*b*d;

TENS(2,0)=TENS(2,0)-nb_points*c*a;
TENS(2,1)=TENS(2,1)-nb_points*c*b;
TENS(2,3)=TENS(2,3)-nb_points*c*d;

TENS(3,0)=TENS(3,0)-nb_points*d*a;
TENS(3,1)=TENS(3,1)-nb_points*d*b;
TENS(3,2)=TENS(3,2)-nb_points*d*c;

return TENS;
}


OT_TENSEUR VCT_FACE::calcule_tenseur_inertie_base_locale(OT_TENSEUR& T)
{

 OT_VECTEUR_4DD v1,v2,v3,v4;
 OT_TENSEUR INERTIE;
 OT_TENSEUR I_GLOBALE;
 OT_VECTEUR_4DD D;
 OT_TENSEUR V(4);
 this->calcule_axes_dinertie(T,D,V);
 INERTIE=this->calcule_tenseur_inertie_au_barycentre(T);

 I_GLOBALE= INERTIE;

 OT_TENSEUR P(4);
 OT_TENSEUR I=I_GLOBALE;
 OT_TENSEUR P_TRSPOSE(4);
 OT_TENSEUR I_LOCALE;
 P=V;
 //---------------
 OT_MATRICE_3D p1;
    for(int t=0;t<3;t++)
       for(int tt=0;tt<3;tt++)
         p1(t,tt)=P(t,tt).get_x();
  p1=p1.inverse();
    for(int t=0;t<3;t++)
       for(int tt=0;tt<3;tt++)
         P_TRSPOSE(t,tt)=p1(t,tt);
  P_TRSPOSE(3,3)=1.;
 //---------------
 //P_TRSPOSE=P.transpose();

 I_LOCALE=P_TRSPOSE*I;
 I_LOCALE=I_LOCALE*P;
   for(int i=0;i<4;i++)
      for(int j=0;j<4;j++)
        {
          if(fabs(I_LOCALE(i,j).get_x())<=1e-12) I_LOCALE(i,j).set_x(0.);
        }
 return I_LOCALE;
 return INERTIE;

}


OT_TENSEUR VCT_FACE::calcule_tenseur_inertie_base_entite(OT_TENSEUR& T,VCT& vct_f)
{
OT_VECTEUR_4DD Dv,Dw,G1,G2,G1G2;
OT_TENSEUR P(4);
OT_TENSEUR pt;
OT_TENSEUR IV;
OT_TENSEUR Q(4);
OT_TENSEUR qt;
OT_TENSEUR R;
OT_TENSEUR Rt;
OT_TENSEUR IW;
OT_TENSEUR MASSE_CONCENTRE(4);
OT_TENSEUR V(4),W(4);
this->calcule_axes_dinertie(T,Dv,V);
vct_f.calcule_axes_dinertie(T,Dw,W);

P=V;
Q=W;

IW=vct_f.calcule_tenseur_inertie_base_locale(T);

pt=P.transpose();
qt=Q.transpose();
R=pt*Q;
Rt=qt*P;
IV=R*IW;
IV=IV*Rt;


G1=this->calcule_barycentre(T);
G2=vct_f.calcule_barycentre(T);

G1G2=G2-G1;

OT_VECTEUR_4DD G1G2_LOC;  //Calcul du vecteur G1G2 dans la base locale;
  for(int i=0;i<4;i++)
  {
    for(int j=0;j<4;j++)
    {
    G1G2_LOC[i]= G1G2_LOC[i]+pt(i,j)*G1G2[j];
    }
  }

MASSE_CONCENTRE(0,0)=nb_points*(G1G2_LOC[1]*G1G2_LOC[1]+G1G2_LOC[2]*G1G2_LOC[2]+G1G2_LOC[3]*G1G2_LOC[3]);
MASSE_CONCENTRE(0,1)=-1*nb_points*(G1G2_LOC[0]*G1G2_LOC[1]);
MASSE_CONCENTRE(0,2)=-1*nb_points*(G1G2_LOC[0]*G1G2_LOC[2]);
MASSE_CONCENTRE(0,3)=-1*nb_points*(G1G2_LOC[0]*G1G2_LOC[3]);

MASSE_CONCENTRE(1,0)=-1*nb_points*(G1G2_LOC[1]*G1G2_LOC[0]);
MASSE_CONCENTRE(1,1)=   nb_points*(G1G2_LOC[0]*G1G2_LOC[0]+G1G2_LOC[2]*G1G2_LOC[2]+G1G2_LOC[3]*G1G2_LOC[3]);
MASSE_CONCENTRE(1,2)=-1*nb_points*(G1G2_LOC[1]*G1G2_LOC[2]);
MASSE_CONCENTRE(1,3)=-1*nb_points*(G1G2_LOC[1]*G1G2_LOC[3]);

MASSE_CONCENTRE(2,0)=-1*nb_points*(G1G2_LOC[2]*G1G2_LOC[0]);
MASSE_CONCENTRE(2,1)=-1*nb_points*(G1G2_LOC[2]*G1G2_LOC[1]);
MASSE_CONCENTRE(2,2)=nb_points*(G1G2_LOC[0]*G1G2_LOC[0]+G1G2_LOC[1]*G1G2_LOC[1]+G1G2_LOC[3]*G1G2_LOC[3]);
MASSE_CONCENTRE(2,3)=-1*nb_points*(G1G2_LOC[3]*G1G2_LOC[2]);

MASSE_CONCENTRE(3,0)=-1*nb_points*(G1G2_LOC[0]*G1G2_LOC[3]);
MASSE_CONCENTRE(3,1)=-1*nb_points*(G1G2_LOC[1]*G1G2_LOC[3]);
MASSE_CONCENTRE(3,2)=-1*nb_points*(G1G2_LOC[2]*G1G2_LOC[3]);
MASSE_CONCENTRE(3,3)=nb_points*(G1G2_LOC[0]*G1G2_LOC[0]+G1G2_LOC[1]*G1G2_LOC[1]+G1G2_LOC[2]*G1G2_LOC[2]);

IV=IV+MASSE_CONCENTRE;


return IV;

}


ostream& operator <<(ostream& os, VCT_FACE& vct_f)
{

vct_f.enregistrer(os) ;
return os;
}


OT_VECTEUR_4DD VCT_FACE::get_nouveau_pt(OT_TENSEUR& T,OT_VECTEUR_4DD& v)
{
OT_VECTEUR_4DD temp;

    for( int i=0;i<4;i++)
     { temp[i]=0.;
       for(int j=0;j<4;j++)
        temp[i]= temp[i]+T(i,j)*v[j];
     }
return temp;

}
//==========================================================================
//Visualisation
//==========================================================================


void VCT_FACE::enregistrer(std::ostream& ost)
 {
OT_TENSEUR TT(4);
for(int i=0;i<4;i++)
 TT(i,i)=1.0;
 T=TT;
ost<<"========================================"<<endl;
ost<<"POINTS_DE_CONTROLS:    "<<endl;
ost<<"========================================"<<endl;

 for (unsigned int i=0;i< lst_points.size();i++)
   {
      OT_VECTEUR_4DD v= lst_points[i];   // Rmq: la precision n�est pas affocher, il faut rajouter l'affichage
        ost<< v<<endl;                   // de la precision dans la classe doubleprecision
   }
ost<<endl;   
/*
ost<<"========================================"<<endl;
ost<<"POINTS_DE_CONTROLS_AXES:    "<<endl;
ost<<"========================================"<<endl;

 for (unsigned int i=0;i< lst_points_axes.size();i++)
   {
      OT_VECTEUR_4DD v= lst_points_axes[i];   // Rmq: la precision n�est pas affocher, il faut rajouter l'affichage
        ost<< v<<endl;                   // de la precision dans la classe doubleprecision
   }
ost<<endl;
ost<<"VECTORISATION:    "<<endl;
ost<<"========================================"<<endl;
  for (unsigned int i=0;i< lst_vecteurs.size();i++)
   {
      OT_VECTEUR_4DD v= lst_vecteurs[i];
        ost<< v<<endl;
   }      
ost<<endl;
ost<<endl<<endl;
ost<<"BARYCENTRE:    "<<endl; */
ost<<"========================================"<<endl;
OT_VECTEUR_4DD BARY= calcule_barycentre(T);
ost<<BARY<<endl;
ost<<endl<<endl;     /*
ost<<"TENSEUR_METRIQUE:    "<<endl;
ost<<"========================================"<<endl;
OT_TENSEUR TNS_MT= calcule_tenseur_metrique() ;
ost<< TNS_MT<<endl;
ost<<endl<<endl;

ost<<"TENSEUR_DE_COVARIANCE:    "<<endl;
ost<<"========================================"<<endl;
OT_TENSEUR TNS_CV=  calcule_covariance();
ost<< TNS_CV<<endl;
ost<<endl<<endl;    */
ost<<"AXES_D'INERTIE:    "<<endl;
ost<<"========================================"<<endl;
OT_VECTEUR_4DD D;
OT_TENSEUR V(4);
calcule_axes_dinertie(T,D,V);

ost<<V<<endl;
ost<<endl<<endl;        /*
ost<<"INERTIE_CALCUL�E_AU_BARYCENTRE:    "<<endl;
ost<<"========================================"<<endl;
OT_TENSEUR I_BARY=calcule_tenseur_inertie_au_barycentre();
ost<<I_BARY<<endl;
              /*
ost<<endl<<endl;
ost<<"INERTIE_TRANSPORT�E_EN_UN_POINT:    "<<endl;
ost<<"========================================"<<endl;
OT_TENSEUR I_TRANSP=calcule_tenseur_inertie_au_pt(BARY);
ost<<I_TRANSP<<endl;
ost<<endl<<endl;     /  */

ost<<"INERTIE_CALCUL�_DANS_LA_BASE_LOCALE:    "<<endl;
ost<<"========================================"<<endl;
OT_TENSEUR I_BASE=calcule_tenseur_inertie_base_locale(T);
ost<<I_BASE<<endl;


}


Revision:	150
Committed:	Tue Sep 9 18:41:41 2008 UTC (16 years, 8 months ago) by souaissa
Original Path:	*magic/lib/geometrie/geometrie/src/vct_face.cpp*
File size:	17087 byte(s)
Log Message:	mise a jour des classes vct
#	User	Rev	Content
1	souaissa	66	#include "gestionversion.h"
2			//---------------------------------------------------------------------------
3
4
5			#pragma hdrstop
6
7			#include "vct_face.h"
8			#include "mg_face.h"
9			#include "mg_surface.h"
10	souaissa	150	#include "vct_outils.h"
11	souaissa	66	#include "mg_arete.h"
12			#include "ot_mathematique.h"
13	francois	102	#include <math.h>
14	souaissa	66	#include <iomanip>
15			#include "sld_fonction.h"
16	souaissa	150	#include "constantegeo.h"
17	souaissa	66	//---------------------------------------------------------------------------
18
19			#pragma package(smart_init)
20
21
22
23			VCT_FACE::VCT_FACE(MG_FACE* face):VCT_ELEMENT_TOPOLOGIQUE(face)
24			{
25
26	souaissa	69	int indx;
27	souaissa	68	nb_points=0;
28	souaissa	150	TPL_LISTE_ENTITE<double> param_surf;
29			TPL_LISTE_ENTITE<double> param_courb;
30			MG_SURFACE*surf=face->get_surface();
31			int type=0;
32			if(surf->get_type_geometrique(param_surf)==MGCo_PLAN)
33			{
34			type=1;
35			}
36			if(surf->get_type_geometrique(param_surf)==MGCo_CYLINDRE)
37			{
38			type=2;
39			}
40			OT_VECTEUR_4DD VCT_NUL(0.,0.,0.,0.);
41			double2 ZERO=0.;
42	souaissa	66
43			int nb_boucle=((MG_FACE*)elem_topo)->get_nb_mg_boucle();
44	souaissa	69
45	souaissa	66	for(int j=0;j<nb_boucle;j++)
46			{
47			MG_BOUCLE* Boucle = ((MG_FACE*)elem_topo)->get_mg_boucle(j);
48			int nbarete = Boucle->get_nb_mg_coarete();
49			for (int w =0; w<nbarete;w++)
50			{
51	souaissa	150	double xyz[3];
52	souaissa	69	TPL_LISTE_ENTITE<double> lst_points_ctrls;
53	souaissa	66	MG_COARETE* coArete = Boucle->get_mg_coarete(w);
54	souaissa	69	MG_ARETE* arete = coArete->get_arete();
55	souaissa	150	int sens=coArete->get_orientation();
56	souaissa	69	arete->get_param_NURBS(indx,lst_points_ctrls);
57	souaissa	150	MG_COURBE*courb=arete->get_courbe();
58	souaissa	71	int nb_points_arete=arete->get_vectorisation().get_nb_points();
59	francois	72	vector<OT_VECTEUR_4DD>& list_points=arete->get_vectorisation().get_points_controle();
60
61	souaissa	71	for(int i=0;i< nb_points_arete;i++)
62			{
63	souaissa	150
64	souaissa	71	OT_VECTEUR_4DD POINT= list_points[i];
65	souaissa	150	if(type==2)
66			{
67			if(courb->get_type_geometrique(param_courb)==MGCo_CIRCLE)
68			if (i==0\|\| i==3)
69			{
70			lst_points_axes.insert(lst_points_axes.end(),POINT);
71			}
72			}
73
74	souaissa	71	lst_points.insert(lst_points.end(),POINT);
75	souaissa	150	// if (w==0&&i==0&&nb_points_arete==2)
76			if(!type\|\|type==1)
77			lst_points_axes.insert(lst_points_axes.end(),POINT);
78
79	souaissa	71	}
80	souaissa	67
81	souaissa	150	std::vector<OT_VECTEUR_4DD>& list_vect=arete->get_vectorisation().get_vecteurs() ;
82			if(!type\|\|type==1)
83			for(unsigned int i=0;i<list_vect.size();i++)
84			{
85			OT_VECTEUR_4DD v=list_vect[i] ;
86			if (sens<0) v=-1*v;
87			lst_vecteurs.insert(lst_vecteurs.end(),v);
88			lst_vecteurs_axes.insert(lst_vecteurs_axes.end(),v);
89			}
90	souaissa	71	nb_points+=nb_points_arete;
91	souaissa	66	}
92
93			}
94	souaissa	150	if(type==2)
95			{
96			vector<OT_VECTEUR_4DD> lst_pts;
97			lst_pts.insert(lst_pts.end(),lst_points_axes[0] ) ;
98			lst_pts.insert(lst_pts.end(),lst_points_axes[1] ) ;
99			lst_pts.insert(lst_pts.end(),lst_points_axes[3] ) ;
100			lst_pts.insert(lst_pts.end(),lst_points_axes[2] ) ;
101			for(int r=0;r<lst_pts.size();r++)
102			{ OT_VECTEUR_4DD V;
103			if(r<lst_pts.size()-1)
104			V=lst_pts[r+1]-lst_pts[r];
105			if(r==lst_pts.size()-1)
106			V=lst_pts[0]-lst_pts[r];
107			double2 norm_au_carre=(V[0]V[0])+(V[1]V[1])+(V[2]V[2])+(V[3]V[3]);
108			double2 norm=norm_au_carre^0.5;
109			if(V==VCT_NUL)
110			lst_vecteurs.insert(lst_vecteurs.end(),VCT_NUL);
111			if(norm!=ZERO)
112			{
113			V=1./norm*V;
114			lst_vecteurs_axes.insert(lst_vecteurs_axes.end(),V);
115			}
116			}
117			}
118	souaissa	67
119	souaissa	66	}
120
121
122	souaissa	69
123			VCT_FACE::VCT_FACE(VCT_FACE& mdd):VCT_ELEMENT_TOPOLOGIQUE(mdd.elem_topo)
124	souaissa	66	{
125	souaissa	69	lst_vecteurs=mdd.lst_vecteurs;
126			lst_points =mdd.lst_points;
127			nb_points=mdd.nb_points;
128	souaissa	66	}
129
130
131	souaissa	69	VCT_FACE::~ VCT_FACE()
132			{
133	souaissa	66
134	souaissa	69	}
135
136
137	francois	72	std::vector<OT_VECTEUR_4DD>& VCT_FACE::get_points_controle(void)
138	souaissa	71	{
139			return lst_points;
140			}
141	souaissa	150	std::vector<OT_VECTEUR_4DD>& VCT_FACE::get_points_controle_pour_axes(void)
142			{
143			return lst_points_axes;
144			}
145	souaissa	69
146	souaissa	150
147	souaissa	69	std::vector<OT_VECTEUR_4DD> & VCT_FACE::get_vecteurs()
148	souaissa	66	{
149	souaissa	69	return lst_vecteurs;
150			}
151	souaissa	66
152
153	souaissa	69	OT_TENSEUR VCT_FACE:: calcule_tenseur_metrique()
154			{
155			OT_TENSEUR tns(lst_vecteurs);
156			return tns;
157			}
158
159	souaissa	150	OT_VECTEUR_4DD VCT_FACE::calcule_barycentre(OT_TENSEUR& TT)
160	souaissa	69	{
161	souaissa	150	T=TT;
162	souaissa	69	OT_VECTEUR_4DD barycentre(0,0,0,0);
163
164			for(int i=0;i<nb_points;i++)
165	souaissa	66	{
166	souaissa	150	OT_VECTEUR_4DD pt=get_nouveau_pt(T,lst_points[i]);
167			//barycentre+=lst_points[i];
168			barycentre+=pt;
169	souaissa	66	}
170
171	souaissa	69	barycentre*=1./nb_points;
172	souaissa	150
173	souaissa	69	return barycentre;
174	souaissa	150
175	souaissa	66	}
176
177
178
179	souaissa	68	int VCT_FACE::get_nb_points()
180	souaissa	66	{
181	souaissa	68	return nb_points ;
182	souaissa	66	}
183
184
185	souaissa	150	OT_TENSEUR VCT_FACE::calcule_covariance(OT_TENSEUR& T)
186	souaissa	66	{
187	souaissa	150	OT_TENSEUR COVARIANCE(4);
188			OT_VECTEUR_4DD barycentre=calcule_barycentre( T);
189			OT_TENSEUR PT_CENTRE(nb_points,4),PT_CENTRE_TRANSPOSE;
190	souaissa	79
191	souaissa	66
192	souaissa	150	for( int i=0;i<nb_points;i++)
193			{
194			//OT_VECTEUR_4DD pt=lst_points[i];
195			OT_VECTEUR_4DD pt=get_nouveau_pt(T,lst_points[i]);
196			//OT_VECTEUR_4DD ptcent=lst_points[i]-barycentre;
197			OT_VECTEUR_4DD ptcent=pt-barycentre;
198			for (int j=0;j<4;j++)
199			PT_CENTRE(i,j)= ptcent[j];
200	souaissa	66
201	souaissa	71	}
202			PT_CENTRE_TRANSPOSE =PT_CENTRE.transpose();
203
204	souaissa	150
205	souaissa	71	COVARIANCE=PT_CENTRE_TRANSPOSE*PT_CENTRE;
206			double2 COEF= 1./nb_points;
207			COVARIANCE=COVARIANCE*COEF;
208
209	souaissa	79	for(int i=0;i<4;i++)
210			for(int j=0;j<4;j++)
211			{
212	souaissa	85	if(fabs(COVARIANCE(i,j).get_x())<=1e-8)
213	souaissa	79	COVARIANCE(i,j).set_x(0.);
214
215			}
216	souaissa	150
217
218			return COVARIANCE;
219	souaissa	66	}
220
221
222	souaissa	150	void VCT_FACE::calcule_axes_dinertie(OT_TENSEUR& T,OT_VECTEUR_4DD& D,OT_TENSEUR& V)
223	souaissa	66	{
224	souaissa	150
225	souaissa	69	int n=4;
226			int nrot;
227	souaissa	66
228	souaissa	150	OT_TENSEUR COV=calcule_covariance(T);
229	souaissa	71
230
231	souaissa	69	double2 zro=0.0;
232	souaissa	66
233	souaissa	71	if(COV(0,0)==zro&&COV(1,0)==zro&&COV(2,0)==zro&&COV(3,0)==zro)
234	souaissa	66	{
235	souaissa	71	COV(0,0)=1.0;
236			COV(1,0)=zro;
237			COV(2,0)=zro;
238			COV(3,0)=zro;
239	souaissa	66	}
240	souaissa	71	if(COV(0,1)==zro&&COV(1,1)==zro&&COV(2,1)==zro&&COV(3,1)==zro)
241	souaissa	66	{
242	souaissa	71	COV(0,1)=zro;
243			COV(1,1)=1.0;
244			COV(2,1)=zro;
245			COV(3,1)=zro;
246	souaissa	66	}
247	souaissa	71	if(COV(0,2)==zro&&COV(1,2)==zro&&COV(2,2)==zro&&COV(3,2)==zro)
248	souaissa	66	{
249	souaissa	71	COV(0,2)=zro;
250			COV(1,2)=zro;
251			COV(2,2)=1.0;
252			COV(3,2)=zro;
253	souaissa	66	}
254	souaissa	71	if(COV(0,3)==zro&&COV(1,3)==zro&&COV(2,3)==zro&&COV(3,3)==zro)
255	souaissa	69	{
256	souaissa	71	COV(0,3)=zro;
257			COV(1,3)=zro;
258			COV(2,3)=zro;
259			COV(3,3)=1.0;
260	souaissa	69	}
261	souaissa	66
262
263	souaissa	71	COV.get_orthogonalisation(COV,D,V,n,nrot);
264	souaissa	150	/*
265	souaissa	66
266	souaissa	150	OT_VECTEUR_4DD G1;
267			OT_TENSEUR p(4),q(4),pT,qT;
268	souaissa	66
269	souaissa	150	G1=calcule_barycentre(T);
270			//OT_VECTEUR_4DD VNul(0.0001,0.0001,0.0001,0.0001);
271			double2 z=0.0001;
272			double2 cof=-1;
273			int plan=-1;
274	souaissa	66
275	souaissa	150	pT=p.transpose();
276
277			vector<OT_VECTEUR_4DD>& list_points1=get_points_controle_pour_axes();
278			vector<OT_VECTEUR_4DD>& list_vecteurs1=lst_vecteurs_axes;//get_vecteurs();
279			OT_VECTEUR_4DD Normal1(0.,0.,0.,0.),N1;
280			OT_VECTEUR_4DD axe11,axe12,axe13;
281			int cmpt=0;
282
283			OT_VECTEUR_4DD v11= list_vecteurs1[0];
284			int nb_vecteur1=list_vecteurs1.size();
285			for(unsigned int pi=0;pi<nb_vecteur1-1;pi++)
286			{
287			OT_VECTEUR_4DD v2= list_vecteurs1[pi+1];
288			if(pi==0)
289			Normal1=v11^v2;
290			if (pi>0)
291			N1=v11^v2;
292			OT_VECTEUR_4DD colineaire= Normal1^N1;
293			if(colineaire[0].get_fabs()<z&&colineaire[1].get_fabs()<z&&colineaire[2].get_fabs()<z&&colineaire[3].get_fabs()<z)
294			{
295			cmpt++;
296			}
297			}
298			vector<OT_VECTEUR_4DD> axes1;
299			if (cmpt== list_vecteurs1.size()-1)
300			{
301			plan=1;
302			axe11=list_vecteurs1[0];
303			axe12=Normal1^axe11;
304			axe13=Normal1;
305			axes1.insert(axes1.end(),axe11);
306			axes1.insert(axes1.end(),axe12);
307			axes1.insert(axes1.end(),axe13);
308			}
309
310			VCT_OUTILS VOUTIL(4);
311			OT_MATRICE_3D sys_axes1=VOUTIL.get_system_axes(G1,axes1,list_points1) ;
312			for(int i=0;i<4;i++)
313			{
314			for(int j=0;j<4;j++)
315			{
316			if(i<3&&j<3)
317			V(i,j)= sys_axes1(i,j);
318			if(i<3 &&j>2)
319			V(i,j)=0.;
320			if(i==3&&j==3) V(i,j)=1.;
321			}
322			} */
323			}
324
325
326
327			OT_TENSEUR VCT_FACE:: calcule_tenseur_inertie_au_barycentre(OT_TENSEUR& T) //repere globale
328	souaissa	66	{
329	souaissa	71	OT_TENSEUR INERTIE(4);
330	souaissa	150	OT_TENSEUR cov=calcule_covariance(T);
331	souaissa	69	double2 nb_pts=nb_points;
332			double2 MOINS_UN=-1.0;
333	souaissa	71	INERTIE=cov*MOINS_UN;
334			INERTIE=INERTIE*nb_pts;
335	souaissa	66
336	souaissa	71	INERTIE(0,0)=(cov(1,1)+cov(2,2)+cov(3,3))*nb_pts;
337			INERTIE(1,1)=(cov(0,0)+cov(2,2)+cov(3,3))*nb_pts;
338			INERTIE(2,2)=(cov(1,1)+cov(0,0)+cov(3,3))*nb_pts;
339			INERTIE(3,3)=(cov(1,1)+cov(2,2)+cov(0,0))*nb_pts;
340	souaissa	79	for(int i=0;i<4;i++)
341			for(int j=0;j<4;j++)
342			{
343			if(fabs(INERTIE(i,j).get_x())<=1e-12) INERTIE(i,j).set_x(0.);
344	souaissa	71
345	souaissa	79	}
346	souaissa	150
347
348	souaissa	71	return INERTIE;
349	souaissa	150
350
351	souaissa	66	}
352
353
354	souaissa	150	OT_TENSEUR VCT_FACE:: calcule_tenseur_inertie_au_pt(OT_TENSEUR& T,OT_VECTEUR_4DD& POINT)
355	souaissa	66	{
356
357	souaissa	150	OT_VECTEUR_4DD BARYCENTRE=calcule_barycentre(T);
358			OT_TENSEUR TENS=calcule_tenseur_inertie_au_barycentre(T);
359	souaissa	66
360	souaissa	69	OT_VECTEUR_4DD ABC=POINT-BARYCENTRE;
361	souaissa	66
362	souaissa	69	double2 a=ABC[0] ;
363			double2 b=ABC[1] ;
364			double2 c=ABC[2] ;
365			double2 d=ABC[3] ;
366	souaissa	66
367	souaissa	69	TENS(0,0)=TENS(0,0)+bb+cc+d*d;
368			TENS(1,1)=TENS(1,1)+aa+cc+d*d;
369			TENS(2,2)=TENS(2,2)+aa+bb+d*d;
370	souaissa	71	TENS(3,3)=TENS(3,3)+aa+bb+c*c;
371	souaissa	66
372	souaissa	69	TENS(0,1)=TENS(0,1)-nb_pointsab;
373			TENS(0,2)=TENS(0,2)-nb_pointsac;
374			TENS(0,3)=TENS(0,3)-nb_pointsad;
375	souaissa	66
376	souaissa	69	TENS(1,0)=TENS(1,0)-nb_pointsba;
377			TENS(1,2)=TENS(1,2)-nb_pointsbc;
378			TENS(1,3)=TENS(1,3)-nb_pointsbd;
379	souaissa	66
380	souaissa	69	TENS(2,0)=TENS(2,0)-nb_pointsca;
381			TENS(2,1)=TENS(2,1)-nb_pointscb;
382			TENS(2,3)=TENS(2,3)-nb_pointscd;
383	souaissa	66
384	souaissa	69	TENS(3,0)=TENS(3,0)-nb_pointsda;
385			TENS(3,1)=TENS(3,1)-nb_pointsdb;
386			TENS(3,2)=TENS(3,2)-nb_pointsdc;
387
388			return TENS;
389	souaissa	66	}
390
391
392	souaissa	150	OT_TENSEUR VCT_FACE::calcule_tenseur_inertie_base_locale(OT_TENSEUR& T)
393	souaissa	66	{
394	souaissa	71
395	souaissa	69	OT_VECTEUR_4DD v1,v2,v3,v4;
396			OT_TENSEUR INERTIE;
397			OT_TENSEUR I_GLOBALE;
398	souaissa	71	OT_VECTEUR_4DD D;
399			OT_TENSEUR V(4);
400	souaissa	150	this->calcule_axes_dinertie(T,D,V);
401			INERTIE=this->calcule_tenseur_inertie_au_barycentre(T);
402	souaissa	66
403	souaissa	69	I_GLOBALE= INERTIE;
404	souaissa	66
405	souaissa	69	OT_TENSEUR P(4);
406			OT_TENSEUR I=I_GLOBALE;
407	souaissa	150	OT_TENSEUR P_TRSPOSE(4);
408	souaissa	69	OT_TENSEUR I_LOCALE;
409	souaissa	71	P=V;
410	souaissa	150	//---------------
411			OT_MATRICE_3D p1;
412			for(int t=0;t<3;t++)
413			for(int tt=0;tt<3;tt++)
414			p1(t,tt)=P(t,tt).get_x();
415			p1=p1.inverse();
416			for(int t=0;t<3;t++)
417			for(int tt=0;tt<3;tt++)
418			P_TRSPOSE(t,tt)=p1(t,tt);
419			P_TRSPOSE(3,3)=1.;
420			//---------------
421			//P_TRSPOSE=P.transpose();
422	souaissa	66
423	souaissa	69	I_LOCALE=P_TRSPOSE*I;
424			I_LOCALE=I_LOCALE*P;
425	souaissa	79	for(int i=0;i<4;i++)
426			for(int j=0;j<4;j++)
427			{
428			if(fabs(I_LOCALE(i,j).get_x())<=1e-12) I_LOCALE(i,j).set_x(0.);
429			}
430	souaissa	71	return I_LOCALE;
431	souaissa	150	return INERTIE;
432	souaissa	71
433	souaissa	66	}
434
435
436
437
438	souaissa	150
439			OT_TENSEUR VCT_FACE::calcule_tenseur_inertie_base_entite(OT_TENSEUR& T,VCT& vct_f)
440	souaissa	66	{
441	souaissa	71	OT_VECTEUR_4DD Dv,Dw,G1,G2,G1G2;
442	souaissa	69	OT_TENSEUR P(4);
443			OT_TENSEUR pt;
444			OT_TENSEUR IV;
445	souaissa	71	OT_TENSEUR Q(4);
446	souaissa	69	OT_TENSEUR qt;
447			OT_TENSEUR R;
448			OT_TENSEUR Rt;
449			OT_TENSEUR IW;
450	souaissa	71	OT_TENSEUR MASSE_CONCENTRE(4);
451			OT_TENSEUR V(4),W(4);
452	souaissa	150	this->calcule_axes_dinertie(T,Dv,V);
453			vct_f.calcule_axes_dinertie(T,Dw,W);
454	souaissa	66
455	souaissa	71	P=V;
456			Q=W;
457	souaissa	66
458	souaissa	150	IW=vct_f.calcule_tenseur_inertie_base_locale(T);
459	souaissa	69
460			pt=P.transpose();
461			qt=Q.transpose();
462	souaissa	66	R=pt*Q;
463			Rt=qt*P;
464			IV=R*IW;
465			IV=IV*Rt;
466
467
468	souaissa	150	G1=this->calcule_barycentre(T);
469			G2=vct_f.calcule_barycentre(T);
470	souaissa	66
471	souaissa	69	G1G2=G2-G1;
472	souaissa	66
473	souaissa	69	OT_VECTEUR_4DD G1G2_LOC; //Calcul du vecteur G1G2 dans la base locale;
474			for(int i=0;i<4;i++)
475			{
476			for(int j=0;j<4;j++)
477	souaissa	66	{
478	souaissa	69	G1G2_LOC[i]= G1G2_LOC[i]+pt(i,j)*G1G2[j];
479	souaissa	66	}
480	souaissa	69	}
481	souaissa	66
482	souaissa	69	MASSE_CONCENTRE(0,0)=nb_points(G1G2_LOC[1]G1G2_LOC[1]+G1G2_LOC[2]G1G2_LOC[2]+G1G2_LOC[3]G1G2_LOC[3]);
483			MASSE_CONCENTRE(0,1)=-1nb_points(G1G2_LOC[0]*G1G2_LOC[1]);
484			MASSE_CONCENTRE(0,2)=-1nb_points(G1G2_LOC[0]*G1G2_LOC[2]);
485			MASSE_CONCENTRE(0,3)=-1nb_points(G1G2_LOC[0]*G1G2_LOC[3]);
486	souaissa	66
487	souaissa	69	MASSE_CONCENTRE(1,0)=-1nb_points(G1G2_LOC[1]*G1G2_LOC[0]);
488			MASSE_CONCENTRE(1,1)= nb_points(G1G2_LOC[0]G1G2_LOC[0]+G1G2_LOC[2]G1G2_LOC[2]+G1G2_LOC[3]G1G2_LOC[3]);
489			MASSE_CONCENTRE(1,2)=-1nb_points(G1G2_LOC[1]*G1G2_LOC[2]);
490			MASSE_CONCENTRE(1,3)=-1nb_points(G1G2_LOC[1]*G1G2_LOC[3]);
491	souaissa	66
492	souaissa	69	MASSE_CONCENTRE(2,0)=-1nb_points(G1G2_LOC[2]*G1G2_LOC[0]);
493			MASSE_CONCENTRE(2,1)=-1nb_points(G1G2_LOC[2]*G1G2_LOC[1]);
494			MASSE_CONCENTRE(2,2)=nb_points(G1G2_LOC[0]G1G2_LOC[0]+G1G2_LOC[1]G1G2_LOC[1]+G1G2_LOC[3]G1G2_LOC[3]);
495	souaissa	79	MASSE_CONCENTRE(2,3)=-1nb_points(G1G2_LOC[3]*G1G2_LOC[2]);
496	souaissa	66
497	souaissa	69	MASSE_CONCENTRE(3,0)=-1nb_points(G1G2_LOC[0]*G1G2_LOC[3]);
498			MASSE_CONCENTRE(3,1)=-1nb_points(G1G2_LOC[1]*G1G2_LOC[3]);
499			MASSE_CONCENTRE(3,2)=-1nb_points(G1G2_LOC[2]*G1G2_LOC[3]);
500			MASSE_CONCENTRE(3,3)=nb_points(G1G2_LOC[0]G1G2_LOC[0]+G1G2_LOC[1]G1G2_LOC[1]+G1G2_LOC[2]G1G2_LOC[2]);
501	souaissa	66
502	souaissa	69	IV=IV+MASSE_CONCENTRE;
503	souaissa	66
504	souaissa	79
505			return IV;
506
507	souaissa	69	}
508	souaissa	66
509
510	souaissa	150
511
512
513
514	souaissa	69	ostream& operator <<(ostream& os, VCT_FACE& vct_f)
515	souaissa	66	{
516	souaissa	71
517	souaissa	66	vct_f.enregistrer(os) ;
518			return os;
519			}
520
521	souaissa	150
522			OT_VECTEUR_4DD VCT_FACE::get_nouveau_pt(OT_TENSEUR& T,OT_VECTEUR_4DD& v)
523			{
524			OT_VECTEUR_4DD temp;
525
526			for( int i=0;i<4;i++)
527			{ temp[i]=0.;
528			for(int j=0;j<4;j++)
529			temp[i]= temp[i]+T(i,j)*v[j];
530			}
531			return temp;
532
533			}
534	souaissa	66	//==========================================================================
535			//Visualisation
536			//==========================================================================
537
538
539
540
541			void VCT_FACE::enregistrer(std::ostream& ost)
542			{
543	souaissa	150	OT_TENSEUR TT(4);
544			for(int i=0;i<4;i++)
545			TT(i,i)=1.0;
546			T=TT;
547	souaissa	71	ost<<"========================================"<<endl;
548			ost<<"POINTS_DE_CONTROLS: "<<endl;
549			ost<<"========================================"<<endl;
550	souaissa	66
551	souaissa	71	for (unsigned int i=0;i< lst_points.size();i++)
552			{
553			OT_VECTEUR_4DD v= lst_points[i]; // Rmq: la precision n�est pas affocher, il faut rajouter l'affichage
554			ost<< v<<endl; // de la precision dans la classe doubleprecision
555			}
556	souaissa	150	ost<<endl;
557			/*
558			ost<<"========================================"<<endl;
559			ost<<"POINTS_DE_CONTROLS_AXES: "<<endl;
560			ost<<"========================================"<<endl;
561	souaissa	66
562	souaissa	150	for (unsigned int i=0;i< lst_points_axes.size();i++)
563			{
564			OT_VECTEUR_4DD v= lst_points_axes[i]; // Rmq: la precision n�est pas affocher, il faut rajouter l'affichage
565			ost<< v<<endl; // de la precision dans la classe doubleprecision
566			}
567			ost<<endl;
568	souaissa	71	ost<<"VECTORISATION: "<<endl;
569			ost<<"========================================"<<endl;
570			for (unsigned int i=0;i< lst_vecteurs.size();i++)
571			{
572			OT_VECTEUR_4DD v= lst_vecteurs[i];
573			ost<< v<<endl;
574	souaissa	79	}
575	souaissa	150	ost<<endl;
576			ost<<endl<<endl;
577			ost<<"BARYCENTRE: "<<endl; */
578	souaissa	71	ost<<"========================================"<<endl;
579	souaissa	150	OT_VECTEUR_4DD BARY= calcule_barycentre(T);
580	souaissa	71	ost<<BARY<<endl;
581	souaissa	150	ost<<endl<<endl; /*
582	souaissa	71	ost<<"TENSEUR_METRIQUE: "<<endl;
583			ost<<"========================================"<<endl;
584			OT_TENSEUR TNS_MT= calcule_tenseur_metrique() ;
585			ost<< TNS_MT<<endl;
586			ost<<endl<<endl;
587	souaissa	79
588	souaissa	71	ost<<"TENSEUR_DE_COVARIANCE: "<<endl;
589			ost<<"========================================"<<endl;
590			OT_TENSEUR TNS_CV= calcule_covariance();
591			ost<< TNS_CV<<endl;
592	souaissa	150	ost<<endl<<endl; */
593	souaissa	71	ost<<"AXES_D'INERTIE: "<<endl;
594			ost<<"========================================"<<endl;
595			OT_VECTEUR_4DD D;
596			OT_TENSEUR V(4);
597	souaissa	150	calcule_axes_dinertie(T,D,V);
598
599			ost<<V<<endl;
600			ost<<endl<<endl; /*
601	souaissa	71	ost<<"INERTIE_CALCUL�E_AU_BARYCENTRE: "<<endl;
602			ost<<"========================================"<<endl;
603			OT_TENSEUR I_BARY=calcule_tenseur_inertie_au_barycentre();
604			ost<<I_BARY<<endl;
605	souaissa	79	/*
606	souaissa	71	ost<<endl<<endl;
607			ost<<"INERTIE_TRANSPORT�E_EN_UN_POINT: "<<endl;
608			ost<<"========================================"<<endl;
609			OT_TENSEUR I_TRANSP=calcule_tenseur_inertie_au_pt(BARY);
610			ost<<I_TRANSP<<endl;
611	souaissa	150	ost<<endl<<endl; / */
612	souaissa	66
613	souaissa	71	ost<<"INERTIE_CALCUL�_DANS_LA_BASE_LOCALE: "<<endl;
614			ost<<"========================================"<<endl;
615	souaissa	150	OT_TENSEUR I_BASE=calcule_tenseur_inertie_base_locale(T);
616	souaissa	71	ost<<I_BASE<<endl;
617	souaissa	66
618	souaissa	150
619	souaissa	66	}
620
621
622
623
624
625
626