// 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 "Base.h"
#include "Util.h"
#ifndef BASE_HetB_deja_inclus
//===============================================================
// Les base covariantes et absolus
//===============================================================
// CONSTRUCTEURS :
// par defaut, defini la Base absolu en dimension 3
#ifndef MISE_AU_POINT
inline
#endif
BaseB::BaseB () :
dimension(3), nb_vecteur(3), v(3), v_sans(3)
{ v(1).Change_dim(3); v(1)(1) = 1.;
v(2).Change_dim(3); v(2)(2) = 1.;
v(3).Change_dim(3); v(3)(3) = 1.;
// on va définir les v_sans associé, stocké au même endroit
Meme_place_coordonnee();
};
// defini la Base absolu en dimension dim
#ifndef MISE_AU_POINT
inline
#endif
BaseB::BaseB (int dim) :
dimension(dim) , nb_vecteur(dim), v(dim), v_sans(dim)
{ switch (nb_vecteur)
{ case 3: v(3).Change_dim(dimension); v(3)(3) = 1.;
case 2: v(2).Change_dim(dimension); v(2)(2) = 1.;
case 1: v(1).Change_dim(dimension); v(1)(1) = 1.;
break;
default:
{ cout << "\n ** erreur en dimensionnement d'une base, le nombre de vecteur = 0"
<< "\n BaseB::BaseB (int dim)";
Sortie(1);
}
};
// on va définir les v_sans associé, stocké au même endroit
Meme_place_coordonnee();
};
// defini une Base relative v1(dim)
#ifndef MISE_AU_POINT
inline
#endif
BaseB::BaseB (int dim,const Tableau<CoordonneeB > & v1) :
dimension(dim) ,nb_vecteur(v1.Taille()), v(v1.Taille()), v_sans(v1.Taille())
{ switch (nb_vecteur)
{ case 3: v(3).Change_dim(v1(3).Dimension()); v(3) = v1(3);
case 2: v(2).Change_dim(v1(2).Dimension()); v(2) = v1(2);
case 1: v(1).Change_dim(v1(1).Dimension()); v(1) = v1(1);
break;
default:
{ cout << "\n ** erreur en dimensionnement d'une base, le nombre de vecteur = 0"
<< "\n BaseB::BaseB (int dim,const Tableau<CoordonneeB > & v1)";
Sortie(1);
}
};
// on va définir les v_sans associé, stocké au même endroit
Meme_place_coordonnee();
};
// defini une Base locale absolu en dimension dim de n vecteurs
#ifndef MISE_AU_POINT
inline
#endif
BaseB::BaseB (int dim,int n) :
dimension(dim) , nb_vecteur(n), v(n), v_sans(n)
{ switch (nb_vecteur)
{ case 3: v(3).Change_dim(dimension); v(3)(3) = 1.;
case 2: v(2).Change_dim(dimension); v(2)(2) = 1.;
case 1: v(1).Change_dim(dimension); v(1)(1) = 1.;
break;
default:
{ cout << "\n ** erreur en dimensionnement d'une base, le nombre de vecteur = 0"
<< "\n BaseB::BaseB (int dim,int n)";
Sortie(1);
}
};
// on va définir les v_sans associé, stocké au même endroit
Meme_place_coordonnee();
};
// idem dessus mais avec toutes les composantes = s
#ifndef MISE_AU_POINT
inline
#endif
BaseB::BaseB (int dim,int n,double s) :
dimension(dim) , nb_vecteur(n), v(n) , v_sans(n)
{ switch (nb_vecteur)
{ case 3: v(3).Change_dim(dimension);
case 2: v(2).Change_dim(dimension);
case 1: v(1).Change_dim(dimension);
break;
default:
{ cout << "\n ** erreur en dimensionnement d'une base, le nombre de vecteur = 0"
<< "\n BaseB::BaseB (int dim,int n,double s)";
Sortie(1);
}
};
if (s != 0.)
for (int i=1; i<=nb_vecteur;i++)
for (int j =1; j<= dimension; j++)
v(i)(j) = s;
// on va définir les v_sans associé, stocké au même endroit
Meme_place_coordonnee();
};
// DESTRUCTEUR :
#ifndef MISE_AU_POINT
inline
#endif
BaseB::~BaseB ()
{ };
// constructeur de copie
#ifndef MISE_AU_POINT
inline
#endif
BaseB::BaseB (const BaseB & b) :
dimension(b.dimension) , nb_vecteur(b.nb_vecteur), v(b.v), v_sans(b.v_sans)
{ // on va définir les v_sans associé, stocké au même endroit
// on va définir les v_sans associé, stocké au même endroit
Meme_place_coordonnee();
} ;
// defini une Base relative v1(dim) de n vecteurs
#ifndef MISE_AU_POINT
inline
#endif
BaseB::BaseB (int dim,int n,const Tableau<CoordonneeB> & v1) :
dimension(dim) , nb_vecteur(n), v(n), v_sans(n)
{
#ifdef MISE_AU_POINT
if (nb_vecteur > v1.Taille())
{ cout << "\nErreur : la taille relative est > a la taille du tableau !\n";
cout << " nb_vevteur = " << nb_vecteur
<< " v1.Taille = " << v1.Taille() << '\n';
cout << "BaseB::BaseB (int dim,int n,Tableau<CoordonneeB > v1) \n";
Sortie(1);
};
#endif
switch (nb_vecteur)
{ case 3: v(3).Change_dim(v1(3).Dimension()); v(3) = v1(3);
case 2: v(2).Change_dim(v1(2).Dimension()); v(2) = v1(2);
case 1: v(1).Change_dim(v1(1).Dimension()); v(1) = v1(1);
break;
default:
{ cout << "\n ** erreur en dimensionnement d'une base, le nombre de vecteur = 0"
<< "\n BaseB::BaseB (int dim,int n)";
Sortie(1);
};
};
// on va définir les v_sans associé, stocké au même endroit
Meme_place_coordonnee();
};
// surcharge de l'affectation
#ifndef MISE_AU_POINT
inline
#endif
BaseB & BaseB::operator = (const BaseB & aB)
{ dimension = aB.dimension;
nb_vecteur = aB.nb_vecteur;
// on affecte directement
v = aB.v; // il y aura redimentionnement automatique
// on va définir les v_sans associé, stocké au même endroit
v_sans.Change_taille(aB.v_sans.Taille());
Meme_place_coordonnee();
return *this;
};
#ifndef MISE_AU_POINT
inline
#endif
const CoordonneeB & BaseB::operator () (int i) const
{
#ifdef MISE_AU_POINT
if ((i < 1) || (i > dimension))
{ cout << "\nErreur : composante inexistante !\n";
cout << " i = " << i << '\n';
cout << "BaseB::OPERATOR() (int ) const \n";
Sortie(1);
};
#endif
return v(i);
};
#ifndef MISE_AU_POINT
inline
#endif
CoordonneeB& BaseB::CoordoB(int i) // retourne le i ieme vecteurs en I/O
{
#ifdef MISE_AU_POINT
if ((i < 1) || (i > dimension))
{ cout << "\nErreur : composante inexistante !\n";
cout << " i = " << i << '\n';
cout << "BaseB::CoordoB(i) \n";
Sortie(1);
};
#endif
return v(i);
};
// acces contrôlé à des vecteurs sans variance: uniquement en lecture
#ifndef MISE_AU_POINT
inline
#endif
const Coordonnee & BaseB::Coordo(int i) const
{
#ifdef MISE_AU_POINT
if ((i < 1) || (i > dimension))
{ cout << "\nErreur : composante inexistante !\n";
cout << " i = " << i << '\n';
cout << "BaseB::Coordo(int i) \n";
Sortie(1);
};
#endif
// on est obligé d'appliquer Meme_place, car comme on peut accèder directement à v,
// et que via les opérations sur v, on peut changer son pointeur!!
// dans le cas où c'est déjà à la même place, il n'y a aucune action (juste un test)
// donc normalement ce n'est pas "trop" couteux, en tout cas c'est moins que de créer
// un coordonnee intermédiaire.
v_sans(i).Meme_place(v(i));
return v_sans(i);
};
// affichage à l'écran des infos
#ifndef MISE_AU_POINT
inline
#endif
void BaseB::Affiche() const
{ // écriture du type, de la dimension et du nombre de vecteur
cout << "\n BaseB dimension: " << dimension << " nombre de vecteurs : " << nb_vecteur << " ";
// les data
cout << "\n les vecteurs de la base: ";
v.Sortir_sansRet(cout);
};
// changement de base
// on suppose que this(i) correspond aux coordonnées dans un premier repère I_a
// IpH correspond aux coordonnées dans I_a d'un nouveau repère
// en sortie: apB(i) correspond aux coordonnées dans ipB de this(i)
#ifndef MISE_AU_POINT
inline
#endif
void BaseB::Change_repere(const BaseH& IpH, BaseB& apB)
{
#ifdef MISE_AU_POINT
if (dimension != IpH.Dimension())
{ cout << "\nErreur : dimension de this "<< dimension
<< " est differente de celle de la nouvelle base " << IpH.Dimension()
<< " !\n";
cout << "BaseB::Change_repere(... \n";
Sortie(1);
};
if (nb_vecteur != apB.NbVecteur())
{ cout << "\nErreur : le nombre de vecteur de this "<< nb_vecteur
<< " est different de celui de la base que l'on cherche a calculer " << apB.NbVecteur()
<< " !\n";
cout << "BaseB::Change_repere(... \n";
Sortie(1);
};
#endif
for (int i=1;i<= nb_vecteur;i++)
for (int j=1;j<=dimension;j++)
apB.CoordoB(i)(j) = v(i) * IpH(j);
};
// affectation trans_variance: utile pour une recopie de mêmes valeurs
// mais ici l'appel est explicite donc a priori on sait ce que l'on fait
// il n'y a pas de redimensionnement, donc la dimension et le nombre des vecteurs
// doivent être identiques
#ifndef MISE_AU_POINT
inline
#endif
void BaseB::Affectation_trans_variance(const BaseH& aH)
{
#ifdef MISE_AU_POINT
if ((dimension != aH.Dimension()) || (nb_vecteur != aH.NbVecteur()))
{ cout << "\nErreur : dimension de this "<< dimension
<< " difference de celle de la base a affecter: " << aH.Dimension()
<< " ou nombre de vecteur de this " << nb_vecteur
<< " different de celle de la base a affecter: " << aH.NbVecteur()
<< " !\n";
cout << "BaseB::Affectation_trans_variance(... \n";
Sortie(1);
};
#endif
// on affecte directement
for (int i=1;i<=nb_vecteur;i++)
v_sans(i) = aH.Coordo(i); // pas de redimensionnent car même dimension et même nombre
//return *this;
};
// la méthode qui suit a pour objectif de calcul les vecteurs de la base naturelle finale
// associée à un paramétrage cartésien initiale
// donc soit connue une base naturelle \hat g_i associée à un paramétrage theta^i
// \hat g_i est représenté par les vecteurs de this, et représente la situation déformée
// soit la base duale de g_i : gammaH^i = g^i c-à-d la base duale en situation non déformée
// maintenant: si on considère les coordonnées initiales X^i on cherche
// les vecteurs des bases naturelles associées à X^i avant g'_i et après déformation \hat g'_i
// on a (cf. annexe dans le document théorique d'Herezh)
// g'_i = I_i par définition et
// \hat g'_i = (\vec I_i . \vec g^j) ~\hat g_j c-a-d
// \hat g'_i = gammaH^j(i) * (*this)(j)
// c'est le résultat de la méthode qui suit
// si
// changement de base: retourne apB(a) = (*this)(j) . gamma^j_a
// il faut que le nombre de vecteur de apB soit identique à la dimension de gammaH
// et que le nombre de vecteur de gammaH soit identique au nombre de vecteur de this
// et que la dimension de apB soit identique à la dimension de this
#ifndef MISE_AU_POINT
inline
#endif
void BaseB::ChangeBase_theta_vers_Xi(BaseB& apB, const BaseH& gammaH)
{ int apB_nbVecteur = apB.NbVecteur();
#ifdef MISE_AU_POINT
if (apB.Dimension()!= dimension)
{ cout << "\n erreur en changement de base , la dimension des vecteurs de la base resultante "
<< apB.Dimension() << " est differente de celle initiale " << dimension
<< "\n BaseB::ChangeBase_theta_vers_Xi(BaseB& apB, const BaseH& gammaH)";
Sortie(1);
};
if (gammaH.NbVecteur()!= nb_vecteur)
{ cout << "\n erreur en changement de base , le nombre de vecteur de this et gammaH est different"
<< "\n BaseB::ChangeBase_theta_vers_Xi(BaseB& apB, const BaseH& gammaH)";
Sortie(1);
};
#endif
for (int a=1; a<= apB_nbVecteur; a++)
{apB.CoordoB(a).Zero();
for (int j=1;j<= nb_vecteur; j++)
apB.CoordoB(a) += gammaH(j)(a) * v(j);
};
};
// calcul des composantes de coordonnées locales dans la base absolue
// en argument : A -> une reference sur les coordonnées résultat qui peut avoir une dimension
// différente des coordonnées locale, retour d'une reference sur A
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee & BaseB::BaseAbsolue(Coordonnee & A,const CoordonneeH & B) const
{
#ifdef MISE_AU_POINT
if (B.Dimension()!= nb_vecteur)
{ cout << "\n erreur, le nombre de vecteur de la base: " << nb_vecteur << ", est different du nombre de coordonnee "
<< " de B : "<< B.Dimension()
<< "\n BaseB::BaseAbsolue(Coordonnee & A,const CoordonneeH & B)";
Sortie(1);
};
if (A.Dimension()!= dimension )
{ cout << "\n erreur, la dimension de A : " << A.Dimension() << ", est differente de la dimension "
<< " des vecteurs de la base : "<< dimension
<< "\n BaseB::BaseAbsolue(Coordonnee & A,const CoordonneeH & B)";
Sortie(1);
};
#endif
A.Zero();
for (int i=1; i<=nb_vecteur;i++)
A += B(i) * v_sans(i);
return A;
};
// une partie des vecteurs de B est affectée à this,
// si this contient plus de vecteur que B, les autres vecteurs sont mis à 0 ou non
// suivant la valeur de plusZero: = false: les autres vecteurs sont inchangées,
// plusZero = true: les autres vecteurs sont mis à 0
#ifndef MISE_AU_POINT
inline
#endif
void BaseB::Affectation_partielle(int nb_vecteur_a_affecter, const BaseB & B,bool plusZero)
{ // on commence par vérifier si tout est ok (en débug)
#ifdef MISE_AU_POINT
if ((nb_vecteur_a_affecter > nb_vecteur) || (nb_vecteur_a_affecter > B.nb_vecteur))
{cout << "\n*** affectation partielle impossible: nb_vecteur_a_affecter = "<< nb_vecteur_a_affecter
<< " et nb_vecteur = " << nb_vecteur << " et B.nb_vecteur = " << B.nb_vecteur
<< "\n BaseB::Affectation_partielle(int nb_vecteur_a_affecter,... ";
Sortie(1);
};
#endif
switch (nb_vecteur_a_affecter)
{ case 3: v(3) = B.v(3);
case 2: v(2) = B.v(2);
case 1: v(1) = B.v(1);
};
if ((plusZero) && (nb_vecteur_a_affecter < nb_vecteur))
{ switch (nb_vecteur)
{ case 3: {switch (nb_vecteur_a_affecter) { case 1: v(2).Zero(); case 2: v(3).Zero();}break;}
case 2: {switch (nb_vecteur_a_affecter) {case 1: v(2).Zero();} break;}
};
};
};
// surcharge de l'operateur de lecture
#ifndef MISE_AU_POINT
inline
#endif
istream & operator >> ( istream & ent, BaseB & ba)
{ // lecture du type et vérification
string nomtype; ent >> nomtype;
if (nomtype != "BaseB")
{ Sortie(1);
return ent;
}
// lecture de la dimension et du nombre de vecteur
ent >> ba.dimension >> ba.nb_vecteur ;
// les data
ba.v.Entree(ent);
// on met à la même place les v_sans que les v
ba.v_sans.Change_taille(ba.v.Taille());
ba.Meme_place_coordonnee();
return ent;
};
// surcharge de l'operateur d'ecriture
#ifndef MISE_AU_POINT
inline
#endif
ostream & operator << ( ostream & sort,const BaseB & ba)
{ // écriture du type, de la dimension et du nombre de vecteur
sort << "BaseB " << ba.dimension << " " << ba.nb_vecteur << " ";
// les data
ba.v.Sortir_sansRet(sort);
// sort << ba.v;
return sort;
};
//----------------------------- fonctions internes protégées ---------------
// on met à la même place les v_sans que les v
#ifndef MISE_AU_POINT
inline
#endif
void BaseB::Meme_place_coordonnee()
{ switch (nb_vecteur)
{ case 3: v_sans(3).Meme_place(v(3));
case 2: v_sans(2).Meme_place(v(2));
case 1: v_sans(1).Meme_place(v(1));
};
};
//===============================================================
// Les base duales
//===============================================================
// CONSTRUCTEURS :
// par defaut, defini la Base absolu en dimension 3
#ifndef MISE_AU_POINT
inline
#endif
BaseH::BaseH () :
dimension(3), nb_vecteur(3), v(3) , v_sans(3)
{ v(1).Change_dim(3); v(1)(1) = 1.;
v(2).Change_dim(3); v(2)(2) = 1.;
v(3).Change_dim(3); v(3)(3) = 1.;
// on va définir les v_sans associé, stocké au même endroit
Meme_place_coordonnee();
};
// defini la Base absolu en dimension dim
#ifndef MISE_AU_POINT
inline
#endif
BaseH::BaseH (int dim) :
dimension(dim) , nb_vecteur(dim), v(dim), v_sans(dim)
{ switch (nb_vecteur)
{ case 3: v(3).Change_dim(dimension); v(3)(3) = 1.;
case 2: v(2).Change_dim(dimension); v(2)(2) = 1.;
case 1: v(1).Change_dim(dimension); v(1)(1) = 1.;
break;
default:
{ cout << "\n ** erreur en dimensionnement d'une base, le nombre de vecteur = 0"
<< "\n BaseH::BaseH (int dim)";
Sortie(1);
}
};
// on va définir les v_sans associé, stocké au même endroit
Meme_place_coordonnee();
};
// defini une Base relative v1(dim)
#ifndef MISE_AU_POINT
inline
#endif
BaseH::BaseH (int dim,const Tableau<CoordonneeH >& v1) :
dimension(dim) ,nb_vecteur(v1.Taille()), v(v1.Taille()), v_sans(v1.Taille())
{ switch (nb_vecteur)
{ case 3: v(3).Change_dim(v1(3).Dimension()); v(3) = v1(3);
case 2: v(2).Change_dim(v1(2).Dimension()); v(2) = v1(2);
case 1: v(1).Change_dim(v1(1).Dimension()); v(1) = v1(1);
break;
default:
{ cout << "\n ** erreur en dimensionnement d'une base, le nombre de vecteur = 0"
<< "\n BaseH::BaseH (int dim,const Tableau<CoordonneeH > & v1)";
Sortie(1);
}
};
// on va définir les v_sans associé, stocké au même endroit
Meme_place_coordonnee();
};
// defini une Base locale absolu en dimension dim de n vecteurs
#ifndef MISE_AU_POINT
inline
#endif
BaseH::BaseH (int dim,int n) :
dimension(dim) , nb_vecteur(n), v(n), v_sans(n)
{ switch (nb_vecteur)
{ case 3: v(3).Change_dim(dimension); v(3)(3) = 1.;
case 2: v(2).Change_dim(dimension); v(2)(2) = 1.;
case 1: v(1).Change_dim(dimension); v(1)(1) = 1.;
break;
default:
{ cout << "\n ** erreur en dimensionnement d'une base, le nombre de vecteur = 0"
<< "\n BaseH::BaseH (int dim,int n)";
Sortie(1);
}
};
// on va définir les v_sans associé, stocké au même endroit
Meme_place_coordonnee();
};
// idem dessus mais avec toutes les composantes = s
#ifndef MISE_AU_POINT
inline
#endif
BaseH::BaseH (int dim,int n,double s) :
dimension(dim) , nb_vecteur(n), v(n) , v_sans(n)
{ switch (nb_vecteur)
{ case 3: v(3).Change_dim(dimension);
case 2: v(2).Change_dim(dimension);
case 1: v(1).Change_dim(dimension);
break;
default:
{ cout << "\n ** erreur en dimensionnement d'une base, le nombre de vecteur = 0"
<< "\n BaseH::BaseH (int dim,int n,double s)";
Sortie(1);
}
};
if (s != 0.)
for (int i=1; i<=nb_vecteur;i++)
for (int j =1; j<= dimension; j++)
v(i)(j) = s;
// on va définir les v_sans associé, stocké au même endroit
Meme_place_coordonnee();
};
// DESTRUCTEUR :
#ifndef MISE_AU_POINT
inline
#endif
BaseH::~BaseH ()
{ };
// constructeur de copie
#ifndef MISE_AU_POINT
inline
#endif
BaseH::BaseH (const BaseH & b) :
dimension(b.dimension) , nb_vecteur(b.nb_vecteur), v(b.v), v_sans(b.v_sans)
{ // on va définir les v_sans associé, stocké au même endroit
// on va définir les v_sans associé, stocké au même endroit
Meme_place_coordonnee();
} ;
// defini une Base relative v1(dim) de n vecteurs
#ifndef MISE_AU_POINT
inline
#endif
BaseH::BaseH (int dim,int n,const Tableau<CoordonneeH > & v1) :
dimension(dim) , nb_vecteur(n), v(n), v_sans(n)
{
#ifdef MISE_AU_POINT
if (nb_vecteur > v1.Taille())
{ cout << "\nErreur : la taille relative est > a la taille du tableau !\n";
cout << " nb_vevteur = " << nb_vecteur
<< " v1.Taille = " << v1.Taille() << '\n';
cout << "BaseH::BaseH (int dim,int n,Tableau<CoordonneeH > v1) \n";
Sortie(1);
};
#endif
switch (nb_vecteur)
{ case 3: v(3).Change_dim(v1(3).Dimension()); v(3) = v1(3);
case 2: v(2).Change_dim(v1(2).Dimension()); v(2) = v1(2);
case 1: v(1).Change_dim(v1(1).Dimension()); v(1) = v1(1);
break;
default:
{ cout << "\n ** erreur en dimensionnement d'une base, le nombre de vecteur = 0"
<< "\n BaseH::BaseH (int dim,int n)";
Sortie(1);
}
};
// on va définir les v_sans associé, stocké au même endroit
Meme_place_coordonnee();
};
// surcharge de l'affectation
#ifndef MISE_AU_POINT
inline
#endif
BaseH & BaseH::operator = (const BaseH & aH)
{ dimension = aH.dimension;
nb_vecteur = aH.nb_vecteur;
// on affecte directement
v = aH.v; // il y aura redimentionnement automatique
// on va définir les v_sans associé, stocké au même endroit
v_sans.Change_taille(aH.v_sans.Taille());
Meme_place_coordonnee();
return *this;
};
#ifndef MISE_AU_POINT
inline
#endif
const CoordonneeH & BaseH::operator () (int i) const
{
#ifdef MISE_AU_POINT
if ((i < 1) || (i > dimension))
{ cout << "\nErreur : composante inexistante !\n";
cout << " i = " << i << '\n';
cout << "BaseH::OPERATOR() (int i) const \n";
Sortie(1);
};
#endif
return v(i);
};
#ifndef MISE_AU_POINT
inline
#endif
CoordonneeH& BaseH::CoordoH(int i) // retourne le i ieme vecteurs en I/0
{
#ifdef MISE_AU_POINT
if ((i < 1) || (i > dimension))
{ cout << "\nErreur : composante inexistante !\n";
cout << " i = " << i << '\n';
cout << "BaseH::CoordoH(i) \n";
Sortie(1);
};
#endif
return v(i);
};
// acces contrôlé à des vecteurs sans variance: uniquement en lecture
#ifndef MISE_AU_POINT
inline
#endif
const Coordonnee & BaseH::Coordo(int i) const
{
#ifdef MISE_AU_POINT
if ((i < 1) || (i > dimension))
{ cout << "\nErreur : composante inexistante !\n";
cout << " i = " << i << '\n';
cout << "BaseH::Coordo(int i) \n";
Sortie(1);
};
#endif
// on est obligé d'appliquer Meme_place, car comme on peut accèder directement à v,
// et que via les opérations sur v, on peut changer son pointeur!!
// dans le cas où c'est déjà à la même place, il n'y a aucune action (juste un test)
// donc normalement ce n'est pas "trop" couteux, en tout cas c'est moins que de créer
// un coordonnee intermédiaire.
v_sans(i).Meme_place(v(i));
return v_sans(i);
};
// affectation trans_variance: utile pour une recopie de mêmes valeurs
// mais ici l'appel est explicite donc a priori on sait ce que l'on fait
// il n'y a pas de redimensionnement, donc la dimension et le nombre des vecteurs
// doivent être identiques
#ifndef MISE_AU_POINT
inline
#endif
void BaseH::Affectation_trans_variance(const BaseB& aB)
{
#ifdef MISE_AU_POINT
if ((dimension != aB.Dimension()) || (nb_vecteur != aB.NbVecteur()))
{ cout << "\nErreur : dimension de this "<< dimension
<< " difference de celle de la base a affecter: " << aB.Dimension()
<< " ou nombre de vecteur de this " << nb_vecteur
<< " different de celle de la base a affecter: " << aB.NbVecteur()
<< " !\n";
cout << "BaseH::Affectation_trans_variance(... \n";
Sortie(1);
};
#endif
// on affecte directement
for (int i=1;i<=nb_vecteur;i++)
v_sans(i) = aB.Coordo(i); // pas de redimensionnent car même dimension et même nombre
//return *this;
};
// affichage à l'écran des infos
#ifndef MISE_AU_POINT
inline
#endif
void BaseH::Affiche() const
{ // écriture du type, de la dimension et du nombre de vecteur
cout << "\n BaseH dimension: " << dimension << " nombre de vecteurs : " << nb_vecteur << " ";
// les data
cout << "\n les vecteurs de la base: ";
v.Sortir_sansRet(cout);
};
// changement de base
// on suppose que this(i) correspond aux coordonnées dans un premier repère I_a
// IpB correspond aux coordonnées dans I_a d'un nouveau repère
// en sortie: apH(i) correspond aux coordonnées dans ipH de this(i)
#ifndef MISE_AU_POINT
inline
#endif
void BaseH::Change_repere(const BaseB& IpB, BaseH& apH)
{
#ifdef MISE_AU_POINT
if (dimension != IpB.Dimension())
{ cout << "\nErreur : dimension de this "<< dimension
<< " est differente de celle de la nouvelle base " << IpB.Dimension()
<< " !\n";
cout << "BaseH::Change_repere(... \n";
Sortie(1);
};
if (nb_vecteur != apH.NbVecteur())
{ cout << "\nErreur : le nombre de vecteur de this "<< nb_vecteur
<< " est different de celui de la base que l'on cherche a calculer " << apH.NbVecteur()
<< " !\n";
cout << "BaseH::Change_repere(... \n";
Sortie(1);
};
#endif
for (int i=1;i<= nb_vecteur;i++)
for (int j=1;j<=dimension;j++)
apH.CoordoH(i)(j) = v(i) * IpB(j);
};
// la méthode qui suit a pour objectif de calcul les vecteurs de la base naturelle finale
// associée à un paramétrage cartésien initiale
// donc soit connue une base duale \hat g^i associée à un paramétrage theta^i
// \hat g^i est représenté par les vecteurs de this, et représente la situation déformée
// soit la base naturel de g_i : betaB_i = g_i c-à-d la base naturelle en situation non déformée
// maintenant: si on considère les coordonnées initiales X^i on cherche
// les vecteurs des bases duales associées à X^i avant g'^i et après déformation \hat g'^i
// on a (cf. annexe dans le document théorique d'Herezh)
// g'^i = g'_i = I_i = I^i par définition et
// \hat g'^i = (\vec I_i . \vec g_j) ~\hat g^j c-a-d
// \hat g'^i = betaB^j(i) * (*this)(j)
// c'est le résultat de la méthode qui suit
// changement de base: retourne apH(a) = (*this)(j) . beta_j^a
// il faut que le nombre de vecteur de apH soit identique à la dimension de betaB
// et que le nombre de vecteur de betaB soit identique au nombre de vecteur de this
// et que la dimension de apB soit identique à la dimension de this
#ifndef MISE_AU_POINT
inline
#endif
void BaseH::ChangeBase_theta_vers_Xi(BaseH& apH, const BaseB& betaB)
{ int apH_nbVecteur = apH.NbVecteur();
#ifdef MISE_AU_POINT
if (apH.Dimension()!= dimension)
{ cout << "\n erreur en changement de base , la dimension des vecteurs de la base resultante "
<< apH.Dimension() << " est differente de celle initiale " << dimension
<< "\n BaseH::ChangeBase_theta_vers_Xi(BaseH& apH, const BaseB& gammaB)";
Sortie(1);
};
if (betaB.NbVecteur()!= nb_vecteur)
{ cout << "\n erreur en changement de base , le nombre de vecteur de this et betaB est different"
<< "\n BaseH::ChangeBase_theta_vers_Xi(BaseB& apH, const BaseH& betaB)";
Sortie(1);
};
#endif
for (int a=1; a<= apH_nbVecteur; a++)
{apH.CoordoH(a).Zero();
for (int j=1;j<= nb_vecteur; j++)
apH.CoordoH(a) += betaB(j)(a) * v(j);
};
};
// calcul des composantes de coordonnées locales dans la base absolue
// en argument : A -> une reference sur les coordonnées résultat qui peut avoir une dimension
// différente des coordonnées locale, retour d'une reference sur A
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee & BaseH::BaseAbsolue(Coordonnee & A,const CoordonneeB & B) const
{
#ifdef MISE_AU_POINT
if (B.Dimension()!= nb_vecteur)
{ cout << "\n erreur, le nombre de vecteur de la base: " << nb_vecteur << ", est different du nombre de coordonnee "
<< " de B : "<< B.Dimension()
<< "\n BaseH::BaseAbsolue(Coordonnee & A,const CoordonneeB & B)";
Sortie(1);
};
if (A.Dimension()!= dimension )
{ cout << "\n erreur, la dimension de A : " << A.Dimension() << ", est differente de la dimension "
<< " des vecteurs de la base : "<< dimension
<< "\n BaseH::BaseAbsolue(Coordonnee & A,const CoordonneeB & B)";
Sortie(1);
};
#endif
A.Zero();
for (int i=1; i<=nb_vecteur;i++)
A += B(i) * v_sans(i);
return A;
};
// une partie des vecteurs de B est affectée à this,
// si this contient plus de vecteur que B, les autres vecteurs sont mis à 0 ou non
// suivant la valeur de plusZero: = false: les autres vecteurs sont inchangées,
// plusZero = true: les autres vecteurs sont mis à 0
#ifndef MISE_AU_POINT
inline
#endif
void BaseH::Affectation_partielle(int nb_vecteur_a_affecter, const BaseH & B,bool plusZero)
{ // on commence par vérifier si tout est ok (en débug)
#ifdef MISE_AU_POINT
if ((nb_vecteur_a_affecter > nb_vecteur) || (nb_vecteur_a_affecter > B.nb_vecteur))
{cout << "\n*** affectation partielle impossible: nb_vecteur_a_affecter = "<< nb_vecteur_a_affecter
<< " et nb_vecteur = " << nb_vecteur << " et B.nb_vecteur = " << B.nb_vecteur
<< "\n BaseH::Affectation_partielle(int nb_vecteur_a_affecter,... ";
Sortie(1);
};
#endif
switch (nb_vecteur_a_affecter)
{ case 3: v(3) = B.v(3);
case 2: v(2) = B.v(2);
case 1: v(1) = B.v(1);
};
if ((plusZero) && (nb_vecteur_a_affecter < nb_vecteur))
{ switch (nb_vecteur)
{ case 3: {switch (nb_vecteur_a_affecter) { case 1: v(2).Zero(); case 2: v(3).Zero();}break;}
case 2: {switch (nb_vecteur_a_affecter) {case 1: v(2).Zero();} break;}
};
};
};
// surcharge de l'operateur de lecture
#ifndef MISE_AU_POINT
inline
#endif
istream & operator >> ( istream & ent, BaseH & ba)
{ // lecture du type et vérification
string nomtype; ent >> nomtype;
if (nomtype != "BaseH")
{ Sortie(1);
return ent;
}
// lecture de la dimension et du nombre de vecteur
ent >> ba.dimension >> ba.nb_vecteur ;
// on met à la même place les v_sans que les v
ba.v_sans.Change_taille(ba.v.Taille());
ba.Meme_place_coordonnee();
ent >> ba.v;
return ent;
};
// surcharge de l'operateur d'ecriture
#ifndef MISE_AU_POINT
inline
#endif
ostream & operator << ( ostream & sort,const BaseH & ba)
{ // écriture du type, de la dimension et du nombre de vecteur
sort << "BaseH " << ba.dimension << " " << ba.nb_vecteur << " ";
// les data
// ba.v.Sortir_sansRet(sort);
sort << ba.v;
return sort;
};
//----------------------------- fonctions internes protégées ---------------
// on met à la même place les v_sans que les v
#ifndef MISE_AU_POINT
inline
#endif
void BaseH::Meme_place_coordonnee()
{ switch (nb_vecteur)
{ case 3: v_sans(3).Meme_place(v(3));
case 2: v_sans(2).Meme_place(v(2));
case 1: v_sans(1).Meme_place(v(1));
};
};
#endif