rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Elements/Mecanique/Deformation_gene/Met_abstraite3s2.cc

1383 lines
53 KiB
C++
Raw Normal View History

intégration du répertoire Mecanique: - contient les éléments finis, métriques associées, déformations ... intégration du réperoire Géométrie: - contient les géométries 1D 2D et 3D, les frontières des éléments géométriques
2021-09-27 12:42:13 +02:00
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
//#include "Debug.h"
#include "Met_abstraite.h"
#include "Util.h"
#include "Coordonnee3.h"
using namespace std; //introduces namespace std
// a priori on n'en n'a pas besoin mais c'est pour que l'éditeur reconnaisse les différentes
// fonctions ??
// =========================================================================================
// vu la taille des executables le fichier est decompose en trois
// le premier : Met_abstraite1s2.cp concerne les constructeurs, destructeur et
// la gestion des variables
// le deuxième : Met_abstraite2s2.cp concerne le calcul des méthodes publiques
// le troisième: Met_abstraite2s2.cp concerne le calcul des méthodes privées
// =========================================================================================
// ***********$ il faut utiliser des références pour optimiser l'opérateur parenthèse
/// ceci dans la plupart des routines gourmandes !!!!!!!!!!!!!!!!!!!!
//==================== METHODES PROTEGEES===============================
// calcul des points
// calcul du point a t0
void Met_abstraite::Calcul_M0
( const Tableau<Noeud *>& tab_noeud, const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (M0 == NULL)
{ cout << "\nErreur : le point a t=0 n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_M0 \n";
Sortie(1);
};
#endif
int amax = M0->Dimension();
for (int a=1;a<= amax;a++)
{ double & M0a=(*(M0))(a);
M0a=0.; // (*(M0))(a)= 0.;
for (int r=1;r<=nombre_noeud;r++)
{ M0a +=tab_noeud(r)->Coord0()(a) * phi(r);
};
};
};
// calcul du point a t
void Met_abstraite::Calcul_Mt
( const Tableau<Noeud *>& tab_noeud, const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (Mt == NULL)
{ cout << "\nErreur : le point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_Mt \n";
Sortie(1);
};
#endif
int amax = Mt->Dimension();
for (int a=1;a<= amax;a++)
{ double & Mta=(*(Mt))(a);
Mta=0.; // (*(Mt))(a)= 0.;
for (int r=1;r<=nombre_noeud;r++)
{ Mta +=tab_noeud(r)->Coord1()(a) * phi(r);
};
};
};
// calcul des variations du point a t
void Met_abstraite::Calcul_d_Mt
(const Tableau<Noeud *>& , const Vecteur& phi, int nbnoeu)
{
#ifdef MISE_AU_POINT
if (d_Mt == NULL)
{ cout << "\nErreur : le de variation du point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_d_Mt \n";
Sortie(1);
};
#endif
int indice;
for (int b = 1; b<= dim_base; b++)
for (int r = 1; r <= nbnoeu; r++)
{ indice = (r-1)*dim_base + b;
Coordonnee & d_Mt_indice=(*d_Mt)(indice);
d_Mt_indice.Zero();
d_Mt_indice(b)=phi(r);
}
};
// calcul du point a tdt
void Met_abstraite::Calcul_Mtdt
( const Tableau<Noeud *>& tab_noeud, const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (Mtdt == NULL)
{ cout << "\nErreur : le point a t+dt n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_Mtdt \n";
Sortie(1);
};
#endif
int amax = Mtdt->Dimension();
for (int a=1;a<= amax;a++)
{ double & Mtdta=(*(Mtdt))(a);
Mtdta=0.; // (*(Mtdt))(a)= 0.;
for (int r=1;r<=nombre_noeud;r++)
{ Mtdta +=tab_noeud(r)->Coord2()(a) * phi(r);
};
};
};
// calcul des variations du point a tdt
void Met_abstraite::Calcul_d_Mtdt
(const Tableau<Noeud *>& , const Vecteur& phi, int nbnoeu)
{
#ifdef MISE_AU_POINT
if (d_Mtdt == NULL)
{ cout << "\nErreur : le de variation du point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_d_Mtdt \n";
Sortie(1);
};
#endif
int indice;
for (int b = 1; b<= dim_base; b++)
for (int r = 1; r <= nbnoeu; r++)
{ indice = (r-1)*dim_base + b;
Coordonnee & d_Mtdt_indice=(*d_Mtdt)(indice);
d_Mtdt_indice.Zero();
d_Mtdt_indice(b)=phi(r);
}
};
// calcul de la base naturel a t0 -- calcul classique
void Met_abstraite::Calcul_giB_0
( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi, int nombre_noeud,const Vecteur&)
{
#ifdef MISE_AU_POINT
if (giB_0 == NULL)
{ cout << "\nErreur : la base a t=0 n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_giB_0 \n";
Sortie(1);
};
#endif
for (int i=1;i<= nbvec_base;i++)
{for (int a=1;a<= dim_base;a++)
{ double & gib0_i_a = giB_0->CoordoB(i)(a);
gib0_i_a = 0.;
for (int r=1;r<=nombre_noeud;r++)
{ gib0_i_a += tab_noeud(r)->Coord0()(a) * dphi(i,r);
};
};
};
};
// calcul de la base naturel a t -- calcul classique
void Met_abstraite::Calcul_giB_t
( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi, int nombre_noeud,const Vecteur&)
{
#ifdef MISE_AU_POINT
if (giB_t == NULL)
{ cout << "\nErreur : la base a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_giB_t \n";
Sortie(1);
};
#endif
for (int i=1;i<= nbvec_base;i++)
{for (int a=1;a<= dim_base;a++)
{ double & gibt_i_a = giB_t->CoordoB(i)(a);
gibt_i_a = 0.;
for (int r=1;r<=nombre_noeud;r++)
{ gibt_i_a += tab_noeud(r)->Coord1()(a) * dphi(i,r);
};
};
};
};
// calcul de la base naturel a tdt -- calcul classique
void Met_abstraite::Calcul_giB_tdt
( const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi, int nombre_noeud,const Vecteur&)
{
#ifdef MISE_AU_POINT
if (giB_tdt == NULL)
{ cout << "\nErreur : la base a t+dt n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_giB_tdt \n";
Sortie(1);
};
#endif
for (int i=1;i<= nbvec_base;i++)
{for (int a=1;a<= dim_base;a++)
{ double & gibtdt_i_a = giB_tdt->CoordoB(i)(a);
gibtdt_i_a = 0.;
for (int r=1;r<=nombre_noeud;r++)
{ gibtdt_i_a += tab_noeud(r)->Coord2()(a) * dphi(i,r);
};
};
};
};
// calcul des metriques
// Calcul des composantes covariantes de la metrique d'une base naturelle:
void Met_abstraite::Calcul_gijBB (BaseB & giB,TenseurBB & gijBB)
{ int giBnbVecteur = giB.NbVecteur();
for (int i = 1; i<= giBnbVecteur; i++)
for (int j=1; j<= i; j++)
gijBB.Coor(i,j) = (giB(i)).ScalBB(giB(j));
};
// Calcul des composantes covariantes de la metrique de la base naturelle a 0 :
void Met_abstraite::Calcul_gijBB_0 ()
{
#ifdef MISE_AU_POINT
if ((giB_0 == NULL) || (gijBB_0 == NULL))
{ cout << "\nErreur : la base et/ou metrique a t=0 n'est pas defini !\n";
cout << "Calcul_gijBB_0 \n";
Sortie(1);
};
#endif
Calcul_gijBB(*(giB_0),*(gijBB_0));
};
// Calcul des composantes covariantes de la metrique de la base naturelle a t :
void Met_abstraite::Calcul_gijBB_t ()
{
#ifdef MISE_AU_POINT
if ((giB_t == NULL) || (gijBB_t == NULL))
{ cout << "\nErreur : la base et/ou metrique a t n'est pas defini !\n";
cout << "Calcul_gijBB_t \n";
Sortie(1);
};
#endif
Calcul_gijBB(*(giB_t),*(gijBB_t));
};
// Calcul des composantes covariantes de la metrique de la base naturelle a tdt :
void Met_abstraite::Calcul_gijBB_tdt ()
{
#ifdef MISE_AU_POINT
if ((giB_tdt == NULL) || (gijBB_tdt == NULL))
{ cout << "\nErreur : la base et/ou metrique a t+dt n'est pas defini !\n";
cout << "Calcul_gijBB_tdt \n";
Sortie(1);
};
#endif
Calcul_gijBB(*(giB_tdt),*(gijBB_tdt));
};
// calcul du gradient de vitesse à t
void Met_abstraite::Calcul_gradVBB_t
(const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,int nombre_noeud)
{
#ifdef MISE_AU_POINT
if ((giB_t == NULL) || (gradVBB_t == NULL))
{ cout << "\nErreur : la base et/ou le gradient de vitesse a t n'est pas defini !\n";
cout << "\nMet_abstraite::Calcul_gradVBB_t \n";
Sortie(1);
};
#endif
// Vi|j = V^{ar} \phi_{r,j} \vec I_a . \vec g_i
for (int i=1;i<= nbvec_base;i++)
{CoordonneeB & giBt = giB_t->CoordoB(i);
for (int j=1;j<= nbvec_base;j++)
{double& gradVij=(*gradVBB_t).Coor(i,j);
gradVij = 0.;
for (int r=1;r<=nombre_noeud;r++)
{switch (dim_base)
{case 3:
gradVij += tab_noeud(r)->Valeur_t(V3) * dphi(j,r) * giBt(3);
case 2:
gradVij += tab_noeud(r)->Valeur_t(V2) * dphi(j,r) * giBt(2);
case 1:
gradVij += tab_noeud(r)->Valeur_t(V1) * dphi(j,r) * giBt(1);
} //-- fin du switch
} // -- fin du for sur r
} // -- fin du for sur j
}// -- fin du for sur i
};
// calcul gradient de vitesse à t+dt
void Met_abstraite::Calcul_gradVBB_tdt
(const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,int nombre_noeud)
{
#ifdef MISE_AU_POINT
if ((giB_tdt == NULL) || (gradVBB_tdt == NULL))
{ cout << "\nErreur : la base et/ou le gradient de vitesse a t+dt n'est pas defini !\n";
cout << "\nMet_abstraite::Calcul_gradVBB_tdt \n";
Sortie(1);
};
#endif
// Vi|j = V^{ar} \phi_{r,j} \vec I_a . \vec g_i
for (int i=1;i<= nbvec_base;i++)
{CoordonneeB & giBtdt = giB_tdt->CoordoB(i);
for (int j=1;j<= nbvec_base;j++)
{double& gradVij=(*gradVBB_tdt).Coor(i,j);
gradVij = 0.;
for (int r=1;r<=nombre_noeud;r++)
{switch (dim_base)
{case 3:
gradVij += tab_noeud(r)->Valeur_tdt(V3) * dphi(j,r) * giBtdt(3);
case 2:
gradVij += tab_noeud(r)->Valeur_tdt(V2) * dphi(j,r) * giBtdt(2);
case 1:
gradVij += tab_noeud(r)->Valeur_tdt(V1) * dphi(j,r) * giBtdt(1);
} //-- fin du switch
} // -- fin du for sur r
} // -- fin du for sur j
}// -- fin du for sur i
};
// calcul du gradient de vitesse moyen en utilisant delta x^ar/delta t
// dans le cas où les ddl à tdt n'existent pas -> utilisation de la vitesse sécante entre 0 et t !!
void Met_abstraite::Calcul_gradVBB_moyen_t
(const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,int nombre_noeud)
{
#ifdef MISE_AU_POINT
if ((giB_t == NULL) || (gradVmoyBB_t == NULL))
{ cout << "\nErreur : la base et/ou le gradient de vitesse a t+dt n'est pas defini !\n";
cout << "\nMet_abstraite::Calcul_gradVBB_moyen_t \n";
Sortie(1);
};
#endif
// on pose V^{ar} = delta X^{ar} / delta t
// on choisit une vitesse de déformation pour l'instant identique à deltaeps/t
const VariablesTemps& vartemps = ParaGlob::Variables_de_temps();
// dans le cas où l'incrément de temps est nul la vitesse est nulle
double deltat=vartemps.IncreTempsCourant();double unsurdeltat;
double temps =vartemps.TempsCourant();
// on regarde le premier noeud pour savoir s'il y a des coordonnées à t+dt
if (tab_noeud(1)->ExisteCoord2())
{// dans ce cas on utilise l'incrément de temps
if (deltat >= ConstMath::trespetit)
{unsurdeltat = 1./deltat;}
else
{unsurdeltat = 0.;} // o car on veut une vitesse nulle
}
else // sinon on utilise la variation totale de 0 à t, le delta t vaudra le temps actuel
{ if (temps >= ConstMath::trespetit)
{unsurdeltat = 1./temps;}
else
{unsurdeltat = 0.;} // o car on veut une vitesse nulle
}
// Vi|j = V^{ar} \phi_{r,j} \vec I_a . \vec g_i
gradVmoyBB_t->Inita(0.);
for (int iv=1;iv<=nbvec_base;iv++)
dmatV_moy_t->CoordoB(iv).Zero();
for (int r=1;r<=nombre_noeud;r++)
{ // on construit d'abord le vecteur vitesse
Coordonnee & V = V_moy_t(r);
if (tab_noeud(r)->ExisteCoord2())
V = (tab_noeud(r)->Coord2() - tab_noeud(r)->Coord1())*unsurdeltat;
else // sinon utilisation des coordonnées sécantes !!!
V = (tab_noeud(r)->Coord1() - tab_noeud(r)->Coord0())*unsurdeltat;
for (int i=1;i<= nbvec_base;i++)
{CoordonneeB & giBt = giB_t->CoordoB(i);
// calcul de gradVij
for (int j=1;j<= nbvec_base;j++)
{double& gradVij=(*gradVmoyBB_t).Coor(i,j);
switch (dim_base)
{case 3:
gradVij += V(3) * dphi(j,r) * giBt(3);
case 2:
gradVij += V(2) * dphi(j,r) * giBt(2);
case 1:
gradVij += V(1) * dphi(j,r) * giBt(1);
} //-- fin du switch
} // -- fin du for sur j
// calcul des vecteurs V,i moyens
CoordonneeB & dmatV_moy_t_i= dmatV_moy_t->CoordoB(i);
switch (dim_base)
{case 3:
dmatV_moy_t_i(3) += V(3) * dphi(i,r);
case 2:
dmatV_moy_t_i(2) += V(2) * dphi(i,r);
case 1:
dmatV_moy_t_i(1) += V(1) * dphi(i,r);
} //-- fin du switch
}// -- fin du for sur i
} // -- fin du for sur r
};
// calcul du gradient de vitesse moyen en utilisant delta x^ar/delta t
void Met_abstraite::Calcul_gradVBB_moyen_tdt
(const Tableau<Noeud *>& tab_noeud, const Mat_pleine& dphi,int nombre_noeud)
{
#ifdef MISE_AU_POINT
if ((giB_tdt == NULL) || (gradVmoyBB_tdt == NULL))
{ cout << "\nErreur : la base et/ou le gradient de vitesse a t+dt n'est pas defini !\n";
cout << "\nMet_abstraite::Calcul_gradVBB_moyen_tdt \n";
Sortie(1);
};
#endif
// on pose V^{ar} = delta X^{ar} / delta t
// on choisit une vitesse de déformation pour l'instant identique à deltaeps/t
const VariablesTemps& vartemps = ParaGlob::Variables_de_temps();
// dans le cas où l'incrément de temps est nul la vitesse est nulle
double deltat=vartemps.IncreTempsCourant();
double unsurdeltat;
if (deltat >= ConstMath::trespetit)
{unsurdeltat = 1./deltat;}
else
{unsurdeltat = 0.;} // o car on veut une vitesse nulle
// Vi|j = V^{ar} \phi_{r,j} \vec I_a . \vec g_i
gradVmoyBB_tdt->Inita(0.);
for (int iv=1;iv<=nbvec_base;iv++)
dmatV_moy_tdt->CoordoB(iv).Zero();
for (int r=1;r<=nombre_noeud;r++)
{ // on construit d'abord le vecteur vitesse
Coordonnee & V = V_moy_t(r);
V = (tab_noeud(r)->Coord2() - tab_noeud(r)->Coord1())*unsurdeltat;
for (int i=1;i<= nbvec_base;i++)
{CoordonneeB & giBtdt = giB_tdt->CoordoB(i);
for (int j=1;j<= nbvec_base;j++)
{double& gradVij=(*gradVmoyBB_tdt).Coor(i,j);
switch (dim_base)
{case 3:
gradVij += V(3) * dphi(j,r) * giBtdt(3);
case 2:
gradVij += V(2) * dphi(j,r) * giBtdt(2);
case 1:
gradVij += V(1) * dphi(j,r) * giBtdt(1);
} //-- fin du switch
} // -- fin du for sur j
// calcul des vecteurs V,i moyens
CoordonneeB & dmatV_moy_tdt_i= dmatV_moy_tdt->CoordoB(i);
switch (dim_base)
{case 3:
dmatV_moy_tdt_i(3) += V(3) * dphi(i,r);
case 2:
dmatV_moy_tdt_i(2) += V(2) * dphi(i,r);
case 1:
dmatV_moy_tdt_i(1) += V(1) * dphi(i,r);
} //-- fin du switch
}// -- fin du for sur i
}; // -- fin du for sur r
};
// Calcul des composantes contravariantes de la metrique de la base naturelle a 0 :
void Met_abstraite::Calcul_gijHH_0 ()
{
#ifdef MISE_AU_POINT
if ((giB_0 == NULL) || (gijBB_0 == NULL) || (gijHH_0 == NULL))
{ cout << "\nErreur : la base ou la metrique cov ou contra ne sont definis !\n";
cout << "Calcul_gijHH_0 \n";
Sortie(1);
};
#endif
*gijHH_0 = gijBB_0->Inverse();
};
// Calcul des composantes contravariantes de la metrique de la base naturelle a t :
void Met_abstraite::Calcul_gijHH_t ()
{
#ifdef MISE_AU_POINT
if ((giB_t == NULL) || (gijBB_t == NULL))
{ cout << "\nErreur : la base et la metrique n'est pas defini !\n";
cout << "Calcul_gijHH_t \n";
Sortie(1);
};
#endif
*gijHH_t = gijBB_t->Inverse();
};
// Calcul des composantes contravariantes de la metrique de la base naturelle a tdt :
void Met_abstraite::Calcul_gijHH_tdt ()
{
#ifdef MISE_AU_POINT
if ((giB_tdt == NULL) || (gijBB_tdt == NULL))
{ cout << "\nErreur : la base et la metrique n'est pas defini !\n";
cout << "Calcul_gijHH_tdt \n";
Sortie(1);
};
#endif
*gijHH_tdt = gijBB_tdt->Inverse();
};
// calcul des bases duales
void Met_abstraite::Calcul_giH(BaseB* giB, TenseurHH* gijHH, BaseH * giH)
{
#ifdef MISE_AU_POINT
if ((giB == NULL) || (gijHH == NULL))
{ cout << "\nErreur : la base naturelle n'existe pas !\n";
cout << "Erreur : la base metrique contravariante n'existe pas !\n";
cout << "Calcul_giH \n";
Sortie(1);
};
#endif
int nb = giB->NbVecteur();
for (int i=1; i<= nb; i++)
{CoordonneeH & giH_i= giH->CoordoH(i);
giH_i.Zero(); //(*giH)(i).Zero(); // mise a zero du vecteur
for (int j=1; j<= nb; j++)
{ CoordonneeB & giB_j= giB->CoordoB(j);
for (int k=1;k<= dim_base; k++)
giH_i(k) += (*gijHH)(i,j) * giB_j(k);
// (*giH)(i)(k) += gijHH(i,j) * giB(j)(k);
}
}
};
void Met_abstraite::Calcul_giH_0()
{ Calcul_giH( giB_0, gijHH_0,giH_0);};
void Met_abstraite::Calcul_giH_t()
{ Calcul_giH( giB_t, gijHH_t,giH_t);};
void Met_abstraite::Calcul_giH_tdt()
{ Calcul_giH( giB_tdt, gijHH_tdt,giH_tdt);};
// calcul des Jacobiens-----------------------------------------
void Met_abstraite::Jacobien_0()
{
#ifdef MISE_AU_POINT
if (gijBB_0 == NULL)
{ cout << "\nErreur : la metrique n'est pas defini a t=0 !\n";
cout << "Met_abstraite::Jacobien_0 \n";
Sortie(1);
};
#endif
// jacobien_0 = sqrt (gijBB_0->Det()); toujours positif donc pb donc calcul en produit mixte
jacobien_0 = Util::ProduitMixte(*giB_0);
};
void Met_abstraite::Jacobien_t()
{
#ifdef MISE_AU_POINT
if (gijBB_t == NULL)
{ cout << "\nErreur : la metrique n'est pas defini a t !\n";
cout << "Met_abstraite::Jacobien_t \n";
Sortie(1);
};
#endif
// jacobien_t = sqrt (gijBB_t->Det()); toujours positif donc pb donc calcul en produit mixte
jacobien_t = Util::ProduitMixte(*giB_t);
};
void Met_abstraite::Jacobien_tdt()
{
#ifdef MISE_AU_POINT
if (gijBB_tdt == NULL)
{ cout << "\nErreur : la metrique n'est pas defini a tdt !\n";
cout << "Met_abstraite::Jacobien_tdt \n";
Sortie(1);
};
#endif
// jacobien_tdt = sqrt (gijBB_tdt->Det()); toujours positif donc pb donc calcul en produit mixte
jacobien_tdt = Util::ProduitMixte(*giB_tdt);
};
//== calcul de la variation des bases
void Met_abstraite::D_giB_t( const Mat_pleine& dphi, int nbnoeu,const Vecteur & )
{ int indice;
// derivees de gBi par rapport a XHbr
for (int b = 1; b<= dim_base; b++)
for (int r = 1; r <= nbnoeu; r++)
{ indice = (r-1)*dim_base + b;
BaseB & d_giB_t_indice=(*d_giB_t)(indice);
for (int i =1;i<=nbvec_base;i++)
{ d_giB_t_indice.CoordoB(i).Zero();
d_giB_t_indice.CoordoB(i)(b)=dphi(i,r);
}
}
};
void Met_abstraite::D_giB_tdt( const Mat_pleine& dphi, int nbnoeu,const Vecteur &)
{ int indice;
for (int b = 1; b<= dim_base; b++)
for (int r = 1; r <= nbnoeu; r++)
{ indice = (r-1)*dim_base + b;
BaseB & d_giB_tdt_indice=(*d_giB_tdt)(indice);
for (int i =1;i<=nbvec_base;i++)
{ d_giB_tdt_indice.CoordoB(i).Zero();
d_giB_tdt_indice.CoordoB(i)(b)=dphi(i,r);
}
}
};
void Met_abstraite::D_giH_t()
{ int nbddl = d_giH_t->Taille();
for ( int indice = 1; indice <= nbddl; indice ++)
for (int j =1;j<=nbvec_base;j++)
{ ((*d_giH_t)(indice).CoordoH(j)).Zero();
for (int i =1;i<=nbvec_base;i++)
(*d_giH_t)(indice).CoordoH(j) += (-((*d_giB_t)(indice)(i))
* (*giH_t)(j)) * (*giH_t)(i);
}
};
void Met_abstraite::D_giH_tdt()
{ int nbddl = d_giH_tdt->Taille();
for (int indice = 1; indice <= nbddl; indice ++)
for (int j =1;j<=nbvec_base;j++)
{ CoordonneeH & d_giH_tdt_indice_j = (*d_giH_tdt)(indice).CoordoH(j);
BaseB & d_giB_tdt_indice = (*d_giB_tdt)(indice);
CoordonneeH & giH_tdt_j = (*giH_tdt).CoordoH(j);
d_giH_tdt_indice_j.Zero();//((*d_giH_tdt)(indice)(j)).Zero();
for (int i =1;i<=nbvec_base;i++)
d_giH_tdt_indice_j += (-(d_giB_tdt_indice(i))
* giH_tdt_j) * (*giH_tdt)(i);
}
};
//== calcul de la variation des metriques
void Met_abstraite::D_gijBB_t()
{ int nbddl = d_gijBB_t.Taille();
for ( int indice = 1; indice <= nbddl; indice ++)
{ TenseurBB & d_gijBB_t_indice = (*(d_gijBB_t(indice)));
BaseB & d_giB_t_indice = (*d_giB_t)(indice);
for (int j =1;j<=nbvec_base;j++)
for (int i =1;i<=nbvec_base;i++)
d_gijBB_t_indice.Coor(i,j) = (d_giB_t_indice(i).ScalBB((*giB_t)(j)))
+ (d_giB_t_indice(j).ScalBB((*giB_t)(i)));
}
};
void Met_abstraite::D_gijBB_tdt()
{ int nbddl = d_gijBB_tdt.Taille();
for ( int indice = 1; indice <= nbddl; indice ++)
{ TenseurBB & d_gijBB_tdt_indice = (*(d_gijBB_tdt(indice)));
BaseB & d_giB_tdt_indice = (*d_giB_tdt)(indice);
for (int j =1;j<=nbvec_base;j++)
for (int i =1;i<=nbvec_base;i++)
d_gijBB_tdt_indice.Coor(i,j) = (d_giB_tdt_indice(i).ScalBB((*giB_tdt)(j)))
+ (d_giB_tdt_indice(j).ScalBB((*giB_tdt)(i)));
}
};
void Met_abstraite::D_gijHH_t()
{ int nbddl = d_gijHH_t.Taille();
for ( int indice = 1; indice <= nbddl; indice ++)
{ TenseurHH & d_gijHH_t_indice = (*(d_gijHH_t(indice)));
BaseH & d_giH_t_indice = (*d_giH_t)(indice);
for (int j =1;j<=nbvec_base;j++)
for (int i =1;i<=nbvec_base;i++)
d_gijHH_t_indice.Coor(i,j) = (d_giH_t_indice(i).ScalHH((*giH_t)(j)))
+ (d_giH_t_indice(j).ScalHH((*giH_t)(i)));
}
};
void Met_abstraite::D_gijHH_tdt()
{ int nbddl = d_gijHH_tdt.Taille();
for ( int indice = 1; indice <= nbddl; indice ++)
{ TenseurHH & d_gijHH_tdt_indice = (*(d_gijHH_tdt(indice)));
BaseH & d_giH_tdt_indice = (*d_giH_tdt)(indice);
for (int j =1;j<=nbvec_base;j++)
for (int i =1;i<=nbvec_base;i++)
d_gijHH_tdt_indice.Coor(i,j) = (d_giH_tdt_indice(i).ScalHH((*giH_tdt)(j)))
+ (d_giH_tdt_indice(j).ScalHH((*giH_tdt)(i)));
}
};
//== calcul de la variation seconde des metriques
void Met_abstraite::D2_gijBB_tdt()
// ici on ne considère que la variation première des vecteurs de base, c-a-d que
// l'on considère que leurs variations secondes sont nulles
// ce qui est vrai dans le cas d'une cinématique simple
{ int nbddl = d_giB_tdt->Taille();
for ( int indice = 1; indice <= nbddl; indice ++)
for ( int jndice = 1; jndice <= indice; jndice ++)
{TenseurBB & d2_gijBB_tdt_indice_jndice = (*(d2_gijBB_tdt(indice,jndice)));
TenseurBB & d2_gijBB_tdt_jndice_indice = (*(d2_gijBB_tdt(jndice,indice)));
BaseB & d_giB_tdt_indice = (*d_giB_tdt)(indice);
BaseB & d_giB_tdt_jndice = (*d_giB_tdt)(jndice);
for (int j =1;j<=nbvec_base;j++)
for (int i =1;i<=j;i++)
{ d2_gijBB_tdt_indice_jndice.Coor(i,j) = d_giB_tdt_indice(i).ScalBB(d_giB_tdt_jndice(j))
+d_giB_tdt_indice(j).ScalBB(d_giB_tdt_jndice(i)) ;
// on utilise les symétries i<->j et indice<->jndice
d2_gijBB_tdt_indice_jndice.Coor(j,i) = d2_gijBB_tdt_indice_jndice(i,j);
d2_gijBB_tdt_jndice_indice.Coor(i,j) = d2_gijBB_tdt_indice_jndice(i,j);
d2_gijBB_tdt_jndice_indice.Coor(j,i) = d2_gijBB_tdt_indice_jndice(i,j);
}
}
};
//== calcul de la variation des jacobiens
// pas valable dans le cas à une dimension
void Met_abstraite::Djacobien_t()
{ int nbddl = d_giB_t->Taille();
switch (nbvec_base)
{ case 1 :
cout << "\n **** erreur le calcul de la variation du jacobien n'est pas définit "
<< " dans le cas d'une métrique à un vecteur "
<< "\n Met_abstraite::Djacobien_t()";
Sortie(1);
break;
case 2 :
// pour 2 vecteurs le jacobien est calculé
// soit comme la norme du produit vectoriel de deux vecteurs en dim 3
// soit comme le produit en croix des composantes des deux vecteurs en dim 2
// il faut donc calculer la dérivée en conséquence
{ if (ParaGlob::Dimension() == 2)
{ for ( int indice = 1; indice <= nbddl; indice ++)
d_jacobien_t(indice) =
( Util::DeterminantB((*d_giB_t)(indice)(1),(*giB_t)(2))
+ Util::DeterminantB((*giB_t)(1),(*d_giB_t)(indice)(2)) );
// je pense erreur car pas commutatif + Util::DeterminantB((*d_giB_t)(indice)(2),(*giB_t)(1)) );
}
else // sinon cela veut dire que l'on est en dim 3
{ Coordonnee3B g1vecg2(Util::ProdVec_coorB((*giB_t)(1),(*giB_t)(2)));
for ( int indice = 1; indice <= nbddl; indice ++)
{ Coordonnee3B D_g1vecg2(Util::ProdVec_coorB((*d_giB_t)(indice)(1),(*giB_t)(2)) +
Util::ProdVec_coorB((*giB_t)(1),(*d_giB_t)(indice)(2)));
d_jacobien_t(indice) = 0.5 * (D_g1vecg2.ScalBB(g1vecg2)+ g1vecg2.ScalBB(D_g1vecg2))
/ jacobien_t;
};
}
}
break;
case 3 :
for ( int indice = 1; indice <= nbddl; indice ++)
d_jacobien_t(indice) =
( Util::DeterminantB((*d_giB_t)(indice)(1),(*giB_t)(2),(*giB_t)(3))
+ Util::DeterminantB((*giB_t)(1),(*d_giB_t)(indice)(2),(*giB_t)(3))
+ Util::DeterminantB((*giB_t)(1),(*giB_t)(2),(*d_giB_t)(indice)(3))
);
break;
default : cout << "\n taille incorecte,Met_abstraite::Djacobien_t() \n";
Sortie(1);
}
};
void Met_abstraite::Djacobien_tdt()
{ int nbddl = d_giB_tdt->Taille();
switch (nbvec_base)
{case 1 :
{cout << "\n **** erreur le calcul de la variation du jacobien n'est pas définit "
<< " dans le cas d'une métrique à un vecteur "
<< "\n Met_abstraite::Djacobien_tdt()";
Sortie(1);
break;
}
case 2 :
// pour 2 vecteurs le jacobien est calculé
// soit comme la norme du produit vectoriel de deux vecteurs en dim 3
// soit comme le produit en croix des composantes des deux vecteurs en dim 2
// il faut donc calculer la dérivée en conséquence
{ if (ParaGlob::Dimension() == 2)
{ for ( int indice = 1; indice <= nbddl; indice ++)
d_jacobien_tdt(indice) =
( Util::DeterminantB((*d_giB_tdt)(indice)(1),(*giB_tdt)(2))
+ Util::DeterminantB((*giB_tdt)(1),(*d_giB_tdt)(indice)(2)) );
}
else // sinon cela veut dire que l'on est en dim 3
{ Coordonnee3B g1vecg2(Util::ProdVec_coorB((*giB_tdt)(1),(*giB_tdt)(2)));
for ( int indice = 1; indice <= nbddl; indice ++)
{ Coordonnee3B D_g1vecg2(Util::ProdVec_coorB((*d_giB_tdt)(indice)(1),(*giB_tdt)(2))
+ Util::ProdVec_coorB((*giB_tdt)(1),(*d_giB_tdt)(indice)(2)));
d_jacobien_tdt(indice) = 0.5 * (D_g1vecg2.ScalBB(g1vecg2)+ g1vecg2.ScalBB(D_g1vecg2))
/ jacobien_tdt;
};
};
break;
}
case 3 :
{
for ( int indice = 1; indice <= nbddl; indice ++)
d_jacobien_tdt(indice) =
( Util::DeterminantB((*d_giB_tdt)(indice)(1),(*giB_tdt)(2),(*giB_tdt)(3))
+ Util::DeterminantB((*giB_tdt)(1),(*d_giB_tdt)(indice)(2),(*giB_tdt)(3))
+ Util::DeterminantB((*giB_tdt)(1),(*giB_tdt)(2),(*d_giB_tdt)(indice)(3))
);
break;
}
default : cout << "\n taille incorecte,Met_abstraite::Djacobien_t() \n";
Sortie(1);
};
};
//== calcul de la variation du gradient instantannée
// par rapport aux composantes de la vitesse (et non les X^ar)
void Met_abstraite::DgradVBB_t(const Mat_pleine& dphi)
{ int indice;
// derivees par rapport a VHbr
for (int b = 1; b<= dim_base; b++)
for (int r = 1; r <= nomb_noeud; r++)
{ indice = (r-1)*dim_base + b;
TenseurBB & d_gradVBB_t_indice = (*(d_gradVBB_t(indice)));
for (int j =1;j<=nbvec_base;j++)
for (int i =1;i<=nbvec_base;i++)
// grad(i,j) = Vi|j = gj_point * gi
d_gradVBB_t_indice.Coor(i,j) = dphi(j,r) * (*giB_t)(i)(b);
}
};
//== calcul de la variation du gradient
void Met_abstraite::DgradVBB_tdt(const Mat_pleine& dphi)
// par rapport aux composantes de la vitesse (et non les X^ar)
{ int indice;
// derivees par rapport a VHbr
for (int b = 1; b<= dim_base; b++)
for (int r = 1; r <= nomb_noeud; r++)
{ indice = (r-1)*dim_base + b;
TenseurBB & d_gradVBB_tdt_indice = (*(d_gradVBB_tdt(indice)));
for (int j =1;j<=nbvec_base;j++)
for (int i =1;i<=nbvec_base;i++)
// grad(i,j) = Vi|j = gj_point * gi
d_gradVBB_tdt_indice.Coor(i,j) = dphi(j,r) * (*giB_tdt)(i)(b);
}
};
// calcul de la variation du gradient moyen à t
// par rapport ici aux composantes X^ar (et non les V^ar )
void Met_abstraite::DgradVmoyBB_t(const Mat_pleine& dphi,const Tableau<Noeud *>& tab_noeud)
{ // récup de delta t
const VariablesTemps& vartemps = ParaGlob::Variables_de_temps();
// dans le cas où l'incrément de temps est nul la vitesse est nulle
double deltat=vartemps.IncreTempsCourant();double unsurdeltat;
double temps =vartemps.TempsCourant();
// on regarde le premier noeud pour savoir s'il y a des coordonnées à t+dt
if (tab_noeud(1)->ExisteCoord2())
{// dans ce cas on utilise l'incrément de temps
if (deltat >= ConstMath::trespetit)
{unsurdeltat = 1./deltat;}
else
{unsurdeltat = 0.;} // o car on veut une vitesse nulle
}
else // sinon on utilise la variation totale de 0 à t, le delta t vaudra le temps actuel
{ if (temps >= ConstMath::trespetit)
{unsurdeltat = 1./temps;}
else
{unsurdeltat = 0.;} // o car on veut une vitesse nulle
}
int indice;
// derivees par rapport a XHbr
for (int b = 1; b<= dim_base; b++)
for (int r = 1; r <= nomb_noeud; r++)
{ indice = (r-1)*dim_base + b;
TenseurBB & d_gradVmoyBB_t_indice = (*(d_gradVmoyBB_t(indice)));
BaseB & d_giB_t_indice=(*d_giB_t)(indice);
for (int j =1;j<=nbvec_base;j++)
for (int i =1;i<=nbvec_base;i++)
// grad(i,j) = Vi|j = gj_point * gi
d_gradVmoyBB_t_indice.Coor(i,j) = dphi(j,r) *( unsurdeltat * (*giB_t)(i)(b)
+ (*dmatV_moy_t)(j).ScalBB(d_giB_t_indice(i)) );
}
};
// calcul de la variation du gradient à t dt
// par rapport ici aux composantes X^ar (et non les V^ar )
void Met_abstraite::DgradVmoyBB_tdt(const Mat_pleine& dphi)
{ // récup de delta t
const VariablesTemps& vartemps = ParaGlob::Variables_de_temps();
// dans le cas où l'incrément de temps est nul la vitesse est nulle
double deltat=vartemps.IncreTempsCourant();
double unsurdeltat;
if (deltat >= ConstMath::trespetit)
{unsurdeltat = 1./deltat;}
else
{unsurdeltat = 0.;} // o car on veut une vitesse nulle
int indice;
// derivees par rapport a XHbr
for (int b = 1; b<= dim_base; b++)
for (int r = 1; r <= nomb_noeud; r++)
{ indice = (r-1)*dim_base + b;
TenseurBB & d_gradVmoyBB_tdt_indice = (*(d_gradVmoyBB_tdt(indice)));
BaseB & d_giB_tdt_indice=(*d_giB_tdt)(indice);
for (int j =1;j<=nbvec_base;j++)
for (int i =1;i<=nbvec_base;i++)
// grad(i,j) = Vi|j = gj_point * gi
d_gradVmoyBB_tdt_indice.Coor(i,j) = dphi(j,r) *( unsurdeltat * (*giB_tdt)(i)(b)
+ (*dmatV_moy_tdt)(j).ScalBB(d_giB_tdt_indice(i)) );
}
};
// ---------------- calcul de données interpolées aux même points d'integ que la mécanique --------
// et utilisées par la mécanique (ex: température, taux de cristalinité, vecteur, etc..)
double Met_abstraite::DonneeInterpoleeScalaire
(const Tableau<Noeud *>& tab_noeud,const Vecteur& phi,int nombre_noeud
,Enum_ddl enu,Enum_dure temps) const
{ double resultat=0.;
switch (temps)
{ case TEMPS_0:
{ for (int r=1;r<=nombre_noeud;r++)
resultat += tab_noeud(r)->Valeur_0(enu) * phi(r);
break;
}
case TEMPS_t:
{ for (int r=1;r<=nombre_noeud;r++)
resultat += tab_noeud(r)->Valeur_t(enu) * phi(r);
break;
}
case TEMPS_tdt:
{ for (int r=1;r<=nombre_noeud;r++)
resultat += tab_noeud(r)->Valeur_tdt(enu) * phi(r);
break;
}
};
return resultat;
};
// --------- calcul de la variation d'une donnée interpolée par rapport aux ddl de la donnée ------
// aux même points d'integ que la mécanique --------
// et utilisées par la mécanique (ex: température, taux de cristalinité, vitesse, etc..)
// en sortie : d_A
Tableau <double >& Met_abstraite::DerDonneeInterpoleeScalaire
(Tableau <double >& d_A, const Tableau<Noeud *>& ,const Vecteur& phi
,int nombre_noeud,Enum_ddl enu) const
{ d_A.Change_taille(nombre_noeud);
for (int r=1;r<=nombre_noeud;r++)
d_A(r) = phi(r);
return d_A;
};
// ---------------- calcul du gradient d'une donnée interpolée aux même points d'integ que la mécanique --------
// et utilisées par la mécanique (ex: température, taux de cristalinité, vitesse, etc..)
// en sortie : gradB
CoordonneeB& Met_abstraite::GradDonneeInterpoleeScalaire
(CoordonneeB& gradA_B,const Tableau<Noeud *>& tab_noeud,const Mat_pleine& dphi
,int nombre_noeud,Enum_ddl enu,Enum_dure temps) const
{
//gradA_B_i = A^{r} \phi_{r,i}
gradA_B.Zero();
switch (temps)
{ case TEMPS_0:
{ for (int i=1;i<= nbvec_base;i++)
{ double & gradA_B_i = gradA_B(i);
gradA_B_i = 0.;
for (int r=1;r<=nombre_noeud;r++)
gradA_B_i += tab_noeud(r)->Valeur_0(enu) * dphi(i,r);
};
break;
}
case TEMPS_t:
{ for (int i=1;i<= nbvec_base;i++)
{ double & gradA_B_i = gradA_B(i);
gradA_B_i = 0.;
for (int r=1;r<=nombre_noeud;r++)
gradA_B_i += tab_noeud(r)->Valeur_t(enu) * dphi(i,r);
};
break;
}
case TEMPS_tdt:
{ for (int i=1;i<= nbvec_base;i++)
{ double & gradA_B_i = gradA_B(i);
gradA_B_i = 0.;
for (int r=1;r<=nombre_noeud;r++)
gradA_B_i += tab_noeud(r)->Valeur_tdt(enu) * dphi(i,r);
};
break;
}
};
// retour du gradient
return gradA_B;
};
// --------- calcul de la variation du gradient d'une donnée interpolée par rapport aux ddl de la donnée ------
// aux même points d'integ que la mécanique --------
// et utilisées par la mécanique (ex: température, taux de cristalinité, vitesse, etc..)
// en sortie : d_gradB
Tableau <CoordonneeB >& Met_abstraite::DerGradDonneeInterpoleeScalaire
(Tableau <CoordonneeB >& d_gradB,const Tableau<Noeud *>&
,const Vecteur& ,const Mat_pleine& dphi,int nombre_noeud,Enum_ddl ) const
{// ici dans la version de base, il s'agit uniquement d'un transfert de dphi dans d_gradB
// par contre pour une interpolation plus sophistiquée, ça pourrait -être très différent
// d'où l'intérêt d'avoir une différenciation entre la variation et dphi
//gradA_B_i = A^{r} \phi_{r,i}
d_gradB.Change_taille(nombre_noeud);
for (int i=1;i<= nbvec_base;i++)
{ for (int r=1;r<=nombre_noeud;r++)
d_gradB(r)(i) = dphi(i,r);
};
// retour du gradient
return d_gradB;
};
// --------- calcul de la variation seconde du gradient d'une donnée interpolée par rapport aux ddl de la donnée ------
// aux même points d'integ que la mécanique --------
// et utilisées par la mécanique (ex: température, taux de cristalinité, vitesse, etc..)
// en sortie : d2_gradB
// si d2_gradB est NULL cela signifie qu'il ne faut pas considérer cette grandeur
Tableau2 <CoordonneeB>* Met_abstraite::Der2GradDonneeInterpoleeScalaire
(Tableau2 <CoordonneeB>* d2_gradB,const Tableau<Noeud *>& tab_noeud
,const Vecteur& phi,const Mat_pleine& dphi,int nombre_noeud,Enum_ddl enu) const
{ // par défaut avec une interpolation simple la dérivée seconde est nulle
return NULL;
};
// calcul de la vitesse du point a t0 en fonction des ddl existants de vitesse
void Met_abstraite::Calcul_V0
( const Tableau<Noeud *>& tab_noeud,const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (V0 == NULL)
{ cout << "\nErreur : la vitesse au point a t=0 n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_V0 \n";
Sortie(1);
};
#endif
int amax = V0->Dimension();
V0->Zero();
for (int r=1;r<=nombre_noeud;r++)
{switch (amax)
{case 3: (*(V0))(3) += tab_noeud(r)->Valeur_0(V3) * phi(r) ;
case 2: (*(V0))(2) += tab_noeud(r)->Valeur_0(V2) * phi(r) ;
case 1: (*(V0))(1) += tab_noeud(r)->Valeur_0(V1) * phi(r) ;
};
};
};
// idem mais au noeud passé en paramètre
void Met_abstraite::Calcul_V0 (const Noeud* noeud)
{
#ifdef MISE_AU_POINT
if (V0 == NULL)
{ cout << "\nErreur : la vitesse au point a t=0 n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_V0(const Noeud* \n";
Sortie(1);
};
#endif
int amax = V0->Dimension(); V0->Zero();
switch (amax)
{case 3: (*(V0))(3) += noeud->Valeur_0(V3) ;
case 2: (*(V0))(2) += noeud->Valeur_0(V2) ;
case 1: (*(V0))(1) += noeud->Valeur_0(V1) ;
};
};
// calcul de la vitesse du point a t en fonction des ddl existants de vitesse
void Met_abstraite::Calcul_Vt
(const Tableau<Noeud *>& tab_noeud, const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (Vt == NULL)
{ cout << "\nErreur : la vitesse au point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_Vt \n";
Sortie(1);
};
#endif
int amax = Vt->Dimension(); Vt->Zero();
for (int r=1;r<=nombre_noeud;r++)
{switch (amax)
{case 3: (*(Vt))(3) += tab_noeud(r)->Valeur_t(V3) * phi(r) ;
case 2: (*(Vt))(2) += tab_noeud(r)->Valeur_t(V2) * phi(r) ;
case 1: (*(Vt))(1) += tab_noeud(r)->Valeur_t(V1) * phi(r) ;
};
};
};
// idem mais au noeud passé en paramètre
void Met_abstraite::Calcul_Vt (const Noeud* noeud)
{
#ifdef MISE_AU_POINT
if (Vt == NULL)
{ cout << "\nErreur : la vitesse au point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_Vt(const Noeud* \n";
Sortie(1);
};
#endif
int amax = Vt->Dimension(); Vt->Zero();
switch (amax)
{case 3: (*(Vt))(3) += noeud->Valeur_t(V3) ;
case 2: (*(Vt))(2) += noeud->Valeur_t(V2) ;
case 1: (*(Vt))(1) += noeud->Valeur_t(V1) ;
};
};
// calcul des variations de la vitesse du point a t en fonction des ddl existants de vitesse
void Met_abstraite::Calcul_d_Vt
(const Tableau<Noeud *>& , const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (d_Vt == NULL)
{ cout << "\nErreur : la variation de vitesse au point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_d_Vt \n";
Sortie(1);
};
#endif
int indice;
for (int b = 1; b<= dim_base; b++)
{for (int r = 1; r <= nombre_noeud; r++)
{ indice = (r-1)*dim_base + b;
Coordonnee & d_Vt_indice=(*d_Vt)(indice);
d_Vt_indice.Zero();
d_Vt_indice(b)=phi(r);
};
};
};
// idem mais au noeud passé en paramètre
void Met_abstraite::Calcul_d_Vt (const Noeud* )
{
#ifdef MISE_AU_POINT
if (d_Vt == NULL)
{ cout << "\nErreur : la variation de vitesse au point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_d_Vt(const Noeud* \n";
Sortie(1);
};
#endif
for (int b = 1; b<= dim_base; b++)
{ Coordonnee & d_Vt_indice=(*d_Vt)(b);
d_Vt_indice.Zero();
d_Vt_indice(b)=1;
};
};
// calcul de la vitesse du point a tdt en fonction des ddl existants de vitesse
void Met_abstraite::Calcul_Vtdt
(const Tableau<Noeud *>& tab_noeud,const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (Vtdt == NULL)
{ cout << "\nErreur : la vitesse au point a t+dt n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_Vtdt \n";
Sortie(1);
};
#endif
int amax = Vtdt->Dimension(); Vtdt->Zero();
for (int r=1;r<=nombre_noeud;r++)
{switch (amax)
{case 3: (*(Vtdt))(3) += tab_noeud(r)->Valeur_tdt(V3) * phi(r) ;
case 2: (*(Vtdt))(2) += tab_noeud(r)->Valeur_tdt(V2) * phi(r) ;
case 1: (*(Vtdt))(1) += tab_noeud(r)->Valeur_tdt(V1) * phi(r) ;
};
};
};
// idem mais au noeud passé en paramètre
void Met_abstraite::Calcul_Vtdt (const Noeud* noeud)
{
#ifdef MISE_AU_POINT
if (Vtdt == NULL)
{ cout << "\nErreur : la vitesse au point a tdt n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_Vtdt(const Noeud* \n";
Sortie(1);
};
#endif
int amax = Vtdt->Dimension(); Vtdt->Zero();
switch (amax)
{case 3: (*(Vtdt))(3) += noeud->Valeur_tdt(V3) ;
case 2: (*(Vtdt))(2) += noeud->Valeur_tdt(V2) ;
case 1: (*(Vtdt))(1) += noeud->Valeur_tdt(V1) ;
};
};
// calcul des variations de la vitesse du point a tdt en fonction des ddl existants de vitesse
void Met_abstraite::Calcul_d_Vtdt
(const Tableau<Noeud *>& , const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (d_Vtdt == NULL)
{ cout << "\nErreur : la variation de vitesse au point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_d_Vtdt \n";
Sortie(1);
};
#endif
int indice;
for (int b = 1; b<= dim_base; b++)
{for (int r = 1; r <= nombre_noeud; r++)
{ indice = (r-1)*dim_base + b;
Coordonnee & d_Vtdt_indice=(*d_Vtdt)(indice);
d_Vtdt_indice.Zero();
d_Vtdt_indice(b)=phi(r);
};
};
};
// idem mais au noeud passé en paramètre
void Met_abstraite::Calcul_d_Vtdt (const Noeud* )
{
#ifdef MISE_AU_POINT
if (d_Vtdt == NULL)
{ cout << "\nErreur : la variation de vitesse au point a tdt n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_d_Vtdt(const Noeud* \n";
Sortie(1);
};
#endif
for (int b = 1; b<= dim_base; b++)
{ Coordonnee & d_Vtdt_indice=(*d_Vtdt)(b);
d_Vtdt_indice.Zero();
d_Vtdt_indice(b)=1;
};
};
// calcul de la vitesse moyenne du point a t0 en fonction des ddl de position
void Met_abstraite::Calcul_V_moy0
( const Tableau<Noeud *>& ,const Vecteur& , int )
{
#ifdef MISE_AU_POINT
if (V0 == NULL)
{ cout << "\nErreur : la vitesse au point a t=0 n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_V_moy0 \n";
Sortie(1);
};
#endif
// a priori lorsque l'on calcul la vitesse moyenne initiale, on n'a pas d'élément pour la déterminer
// on la fige donc à 0
V0->Zero();
};
// idem mais au noeud passé en paramètre
void Met_abstraite::Calcul_V_moy0 (const Noeud* )
{
#ifdef MISE_AU_POINT
if (V0 == NULL)
{ cout << "\nErreur : la vitesse au point a t=0 n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_V_moy0(const Noeud* \n";
Sortie(1);
};
#endif
// a priori lorsque l'on calcul la vitesse moyenne initiale, on n'a pas d'élément pour la déterminer
// on la fige donc à 0
V0->Zero();
};
// calcul de la vitesse moyenne du point a t en fonction des ddl de position
void Met_abstraite::Calcul_V_moyt
(const Tableau<Noeud *>& tab_noeud, const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (Vt == NULL)
{ cout << "\nErreur : la vitesse au point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_V_moyt \n";
Sortie(1);
};
#endif
// la vitesse est calculée selon (M(t)-M(0)) / t
// dans le cas où le temps est nul on pose que la vitesse est nulle et non infinie !
double temps = ParaGlob::Variables_de_temps().TempsCourant(); double unsurt;
if (temps >= ConstMath::trespetit) {unsurt = 1./temps;}
else {unsurt = 0.;} // o car on veut une vitesse nulle
Vt->Zero();
for (int r=1;r<=nombre_noeud;r++)
{ (*Vt) += (tab_noeud(r)->Coord1() - tab_noeud(r)->Coord0()) * (unsurt * phi(r));} ;
};
// idem mais au noeud passé en paramètre
void Met_abstraite::Calcul_V_moyt (const Noeud* noeud)
{
#ifdef MISE_AU_POINT
if (Vt == NULL)
{ cout << "\nErreur : la vitesse au point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_V_moyt(const Noeud* \n";
Sortie(1);
};
#endif
// la vitesse est calculée selon (M(t)-M(0)) / t
// dans le cas où le temps est nul on pose que la vitesse est nulle et non infinie !
double temps = ParaGlob::Variables_de_temps().TempsCourant(); double unsurt;
if (temps >= ConstMath::trespetit) {unsurt = 1./temps;}
else {unsurt = 0.;} // o car on veut une vitesse nulle
Vt->Zero();
(*Vt) += (noeud->Coord1() - noeud->Coord0()) * unsurt;
};
// calcul des variations de la vitesse moyenne du point a t en fonction des ddl de position
void Met_abstraite::Calcul_d_V_moyt
(const Tableau<Noeud *>& , const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (d_Vt == NULL)
{ cout << "\nErreur : la variation de vitesse moyenne au point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_d_V_moyt \n";
Sortie(1);
};
#endif
// la vitesse est calculée selon (M(t)-M(0)) / t, ici on se réfère par rapport au ddl de M(t)
// dans le cas où le temps est nul on pose que la vitesse est nulle et non infinie !
double temps = ParaGlob::Variables_de_temps().TempsCourant(); double unsurt;
if (temps >= ConstMath::trespetit) {unsurt = 1./temps;}
else {unsurt = 0.;} // o car on veut une vitesse nulle
int indice;
for (int b = 1; b<= dim_base; b++)
{for (int r = 1; r <= nombre_noeud; r++)
{ indice = (r-1)*dim_base + b;
Coordonnee & d_Vt_indice=(*d_Vt)(indice);
d_Vt_indice.Zero();
d_Vt_indice(b)=unsurt * phi(r);
};
};
};
// idem mais au noeud passé en paramètre
void Met_abstraite::Calcul_d_V_moyt(const Noeud* )
{
#ifdef MISE_AU_POINT
if (d_Vt == NULL)
{ cout << "\nErreur : la variation de vitesse moyenne au point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_d_V_moyt(const Noeud* \n";
Sortie(1);
};
#endif
// la vitesse est calculée selon (M(t)-M(0)) / t, ici on se réfère par rapport au ddl de M(t)
// dans le cas où le temps est nul on pose que la vitesse est nulle et non infinie !
double temps = ParaGlob::Variables_de_temps().TempsCourant(); double unsurt;
if (temps >= ConstMath::trespetit) {unsurt = 1./temps;}
else {unsurt = 0.;} // o car on veut une vitesse nulle
for (int b = 1; b<= dim_base; b++)
{Coordonnee & d_Vt_indice=(*d_Vt)(b);
d_Vt_indice.Zero();
d_Vt_indice(b)=unsurt;
};
};
// calcul de la vitesse moyenne du point a tdt en fonction des ddl de position
void Met_abstraite::Calcul_V_moytdt
(const Tableau<Noeud *>& tab_noeud,const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (Vtdt == NULL)
{ cout << "\nErreur : la vitesse au point a t+dt n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_V_moytdt \n";
Sortie(1);
};
#endif
// la vitesse est calculée selon (M(tdt)-M(t)) / deltat
// dans le cas où l'incrément de temps est nul on pose que la vitesse est nulle et non infinie !
double deltat=ParaGlob::Variables_de_temps().IncreTempsCourant();double unsurdeltat;
if (deltat >= ConstMath::trespetit) {unsurdeltat = 1./deltat;}
else {unsurdeltat = 0.;} // o car on veut une vitesse nulle
Vtdt->Zero();
for (int r=1;r<=nombre_noeud;r++)
{ (*Vtdt) += (tab_noeud(r)->Coord2() - tab_noeud(r)->Coord1()) * (unsurdeltat * phi(r));} ;
};
// idem mais au noeud passé en paramètre
void Met_abstraite::Calcul_V_moytdt(const Noeud* noeud)
{
#ifdef MISE_AU_POINT
if (Vtdt == NULL)
{ cout << "\nErreur : la vitesse au point a t+dt n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_V_moytdt(const Noeud* \n";
Sortie(1);
};
#endif
// la vitesse est calculée selon (M(tdt)-M(t)) / deltat
// dans le cas où l'incrément de temps est nul on pose que la vitesse est nulle et non infinie !
double deltat=ParaGlob::Variables_de_temps().IncreTempsCourant();double unsurdeltat;
if (deltat >= ConstMath::trespetit) {unsurdeltat = 1./deltat;}
else {unsurdeltat = 0.;} // o car on veut une vitesse nulle
Vtdt->Zero();
(*Vtdt) += (noeud->Coord2() - noeud->Coord1()) * unsurdeltat ;
};
// calcul des variations de la vitesse moyenne du point a tdt en fonction des ddl de position
void Met_abstraite::Calcul_d_V_moytdt
(const Tableau<Noeud *>& , const Vecteur& phi, int nombre_noeud)
{
#ifdef MISE_AU_POINT
if (d_Vtdt == NULL)
{ cout << "\nErreur : la variation de vitesse moyenne au point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_d_V_moytdt \n";
Sortie(1);
};
#endif
// la vitesse est calculée selon (M(tdt)-M(t)) / deltat, les ddl sont ceux de M(tdt)
// dans le cas où l'incrément de temps est nul on pose que la vitesse est nulle et non infinie !
double deltat=ParaGlob::Variables_de_temps().IncreTempsCourant();double unsurdeltat;
if (deltat >= ConstMath::trespetit) {unsurdeltat = 1./deltat;}
else {unsurdeltat = 0.;} // o car on veut une vitesse nulle
int indice;
for (int b = 1; b<= dim_base; b++)
{for (int r = 1; r <= nombre_noeud; r++)
{ indice = (r-1)*dim_base + b;
Coordonnee & d_Vtdt_indice=(*d_Vtdt)(indice);
d_Vtdt_indice.Zero();
d_Vtdt_indice(b)=phi(r) * unsurdeltat;
};
};
};
// idem mais au noeud passé en paramètre
void Met_abstraite::Calcul_d_V_moytdt(const Noeud* )
{
#ifdef MISE_AU_POINT
if (d_Vtdt == NULL)
{ cout << "\nErreur : la variation de vitesse moyenne au point a t n'est pas dimensionne !\n";
cout << "void Met_abstraite::Calcul_d_V_moytdt(const Noeud* \n";
Sortie(1);
};
#endif
// la vitesse est calculée selon (M(tdt)-M(t)) / deltat, les ddl sont ceux de M(tdt)
// dans le cas où l'incrément de temps est nul on pose que la vitesse est nulle et non infinie !
double deltat=ParaGlob::Variables_de_temps().IncreTempsCourant();double unsurdeltat;
if (deltat >= ConstMath::trespetit) {unsurdeltat = 1./deltat;}
else {unsurdeltat = 0.;} // o car on veut une vitesse nulle
for (int b = 1; b<= dim_base; b++)
{ Coordonnee & d_Vtdt_indice=(*d_Vtdt)(b);
d_Vtdt_indice.Zero();
d_Vtdt_indice(b)= unsurdeltat;
};
};
Reference in a new issue Copy permalink