1382 lines
53 KiB
C++
1382 lines
53 KiB
C++
|
|
// 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-2022 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;
|
|
};
|
|
};
|
|
|
|
|