rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

V 7.050 : nombreuses modifications du contact en //, en particulier:

Browse source 
- pb de renumérotation: du au fait que l'algo de renumérotation ne donne pas deux fois de suite le même résultat
- cor pb d'I/O avec contact en //
- corr d'un vieux bug sur HexaQ et HexaQcomp : concerne la désalocation de mémoire (ne change pas les calculs)

Tests de contact en // avec un grand nombre de noeuds (27000), avec 3 maillages dont un qui est maître et esclave en meme temps
- calcul // , restart //, post-traitement mono
- reprise et amélioration de toutes les classes de Coordonnée (dim 1,2 3 , sans variance, avec variance H et B)
This commit is contained in:
Gérard Rio 2025-02-23 18:56:18 +01:00
parent c7f5b8e77c
commit 4ef53d73cc
58 changed files with 4061 additions and 3106 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
Algo/AlgoRef/Algori.cc
View file

@ -2431,6 +2431,28 @@ bool Algori::RaidSmEnerContact(LesContacts * lesCont,Assemblage& Ass,Vecteur & v
// on récupère la liste des éléments de contact
LaLIST <ElContact>& listElContact = lesCont->LesElementsDeContact();
LaLIST <ElContact>::iterator il,ilfin=listElContact.end();
////------ debug
// {cout <<"\n debug Algori::RaidSmEnerContact";
// int nb_assemblage = 0;// init
// // 1: on récupère le pointeur d'assemblage
// for (il=listElContact.begin();il != ilfin; il++)
// {ElContact& elcontact = (*il);
// if (elcontact.Const_Esclave()->Num_noeud() == 1309)
// {nb_assemblage = elcontact.Const_Esclave()->PosiAssemb(Ass.Nb_cas_assemb().n );
// }
// }
// cout << "\n nb assembblage :: "<<nb_assemblage;
// for (il=listElContact.begin();il != ilfin; il++)
// {ElContact& elcontact = (*il);
// if (nb_assemblage == elcontact.Const_Esclave()->PosiAssemb(Ass.Nb_cas_assemb().n))
// cout << "\n nnoeud avec le poinnteur d'assemblage :"
// << elcontact.Const_Esclave()->Num_noeud();
// }
// }
//// (resu.raid)->Affiche(); //1,8,1,1,8,1);
//// (resu.raid)->Affiche1(1,6,1,1,6,1);
// // (int min_i,int max_i,int pas_i,int min_j,int max_j,int pas_j,int nd)
//// ------ fin debug
// on gère les exceptions éventuelles en mettant le bloc sous surveillance
try
{// boucle sur les elements de contact
@ -2461,12 +2483,15 @@ bool Algori::RaidSmEnerContact(LesContacts * lesCont,Assemblage& Ass,Vecteur & v
// calcul effectif de la raideur et résidu locals
Element::ResRaid resu = elcontact.SM_K_charge_contact();
// cout << "numéro =" << ne << endl;
//------ debug
// (resu.res)->Affiche();
// (resu.raid)->Affiche(); //1,8,1,1,8,1);
// (resu.raid)->Affiche1(1,6,1,1,6,1);
// (int min_i,int max_i,int pas_i,int min_j,int max_j,int pas_j,int nd)
// ------ fin debug
////------ debug
// if (elcontact.Const_Esclave()->Num_noeud() == 1309)
// {cout <<"\n debug Algori::RaidSmEnerContact";
// (resu.res)->Affiche();
// }
//// (resu.raid)->Affiche(); //1,8,1,1,8,1);
//// (resu.raid)->Affiche1(1,6,1,1,6,1);
// // (int min_i,int max_i,int pas_i,int min_j,int max_j,int pas_j,int nd)
//// ------ fin debug
#ifndef UTILISATION_MPI
// assemblage
// dans le cas où le retour est un pointeur nul, cela signifie qu'il n'y a pas de second membre et raideur calculés

3
Algo/AlgoRef/Algori4.cc
View file

@ -1024,6 +1024,9 @@ bool Algori::Gestion_stockage_et_renumerotation_avec_contact(bool premier_calcul
#ifdef UTILISATION_MPI
// il faut que tous les proc effectuent la renumérotation, il faut donc transmettre les conditions linéaires de contact
//le pb est que la renumérotation ne donne pas deux fois de suite le même résultat donc il faut changer la chose
//on va demander à proc 0 de faire la renumérotation et ensuite on va répercuter le résultat sur tous les proc donc
//il va falloir intervenir dans lesmaillages ---> à faire
int proc_en_cours = ParaGlob::Monde()->rank();
// seule le proc 0 a récupérer la liste complète des conditions linéaires
int taille_conteneur=0; // init

38
Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc
View file

@ -916,15 +916,22 @@ void AlgoriNonDyna::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
if (!RaidSmEnerContact(lescontacts,Ass,vcontact,(*matglob))) break;
//cout << "\n debug AlgoNonDyna::CalEquilibre: vcontact => "; vcontact.Affiche();
// //------- debug
// #ifdef UTILISATION_MPI
// // cas d'un calcul //, pour l'instant seul le CPU 0 sont concerné
// if (proc_en_cours == 0)
// #endif
// { cout << "\n debug AlgoriNonDyna::CalEquilibre";
// cout << "\n max forces de contact " << vcontact.Max_val_abs();
// };
// //--- fin debug
//------- debug
#ifdef UTILISATION_MPI
// cas d'un calcul //, pour l'instant seul le CPU 0 sont concerné
if (proc_en_cours == 0)
#endif
{ cout << "\n debug AlgoriNonDyna::CalEquilibre";
int i=0;
double maxi = vcontact.Max_val_abs(i);
cout << "\n max forces de contact " << maxi << ", i= " << i;
// on va chercher le noeud avec ce point
int nbNoeud,nbMaillage;
Ddl toto = lesMail->NoeudIndice(i,nbNoeud,nbMaillage,Ass.Nb_cas_assemb());
cout << " noeud "<< nbNoeud << ", maillage "<< nbMaillage;
//Ddl LesMaillages::NoeudIndice(int inSol,int& nbNoeud, int& nbMaillage,const Nb_assemb& casAssemb)
};
//--- fin debug
// on globalise tout pour les forces externes généralisées
#ifdef UTILISATION_MPI
@ -1198,8 +1205,11 @@ decol = false; // pour debugger
// pour tester sol->Broadcast(0);
MPI_Request sol_request;
sol->IBroadcast(0,&sol_request);
// MPI_Request sol_request;
// sol->IBroadcast(0,&sol_request);
sol->Broadcast(0);
// broadcast(*ParaGlob::Monde(), *sol, 0); // essai avec un accès directe à une routine MPI
// synchronisation ici de tous les process (à supprimer par la suite car n'est
@ -1208,9 +1218,9 @@ decol = false; // pour debugger
temps_transfert_long_algo.Arret_du_comptage(); // fin comptage cpu
if (proc_en_cours != 0) // pour proc 0 c'est fait dans InfoIncrementDdl
{maxDeltaDdl = sol->Max_val_abs(inSol);
temps_attente_algo.Mise_en_route_du_comptage();
MPI_Wait(&sol_request, MPI_STATUS_IGNORE);
temps_attente_algo.Arret_du_comptage();
// temps_attente_algo.Mise_en_route_du_comptage();
// MPI_Wait(&sol_request, MPI_STATUS_IGNORE);
// temps_attente_algo.Arret_du_comptage();
double maxDeltatDdl_signe=(*sol)(inSol);
// passage en global
ParaGlob::param->Mise_a_jour_grandeur_consultable_Scalaire_double(MAXvarDdl,maxDeltatDdl_signe);

40
Elements/Geometrie/Frontiere/Front.cc
View file

@ -91,13 +91,16 @@ Front::~Front()
void Front::Affiche(int cas) const
{ if (elem != NULL)
{if (cas == 1)
{ cout << " front " ;
if (angle_mort)
cout << "(angle mort) ";
cout << num_frontiere << " (dans le type) ("<<elem->TypeFrontiere()<<") de l'EF " << ptEl->Num_elt()
<< " ("<< ptEl->Geometrie()<<", "<<ptEl->Interpolation() <<") mail. "
<< ptEl->Num_maillage() << flush;
}
{ cout << " front " ;
if (angle_mort)
cout << "(angle mort) ";
cout << num_frontiere << " (dans le type) ("<<elem->TypeFrontiere()<<") de l'EF " << ptEl->Num_elt()
<< " ("<< ptEl->Geometrie()<<", "<<ptEl->Interpolation() <<") mail. "
<< ptEl->Num_maillage() << flush;
#ifdef UTILISATION_MPI
cout << "\n num_unique= "<<num_unique<<flush;
#endif
}
else
{cout << "\n element de frontiere du maillage " << ptEl->Num_maillage() <<" , cree par l'element "
<< ptEl->Num_elt() << " de numero " << num_frontiere << " (dans le type) , de type de geometrie: "
@ -110,20 +113,23 @@ void Front::Affiche(int cas) const
for (int i=1;i<=tabtaille;i++)
cout << tabnoeud(i)->Num_noeud() << " , ";
cout << " , et contiend les degres de liberte suivants: "
<< elem->DdlElem_const();
<< elem->DdlElem_const();
if (this->tabmitoyen != NULL)
{int tai = this->tabmitoyen->Taille();
cout << "\n " << tai << " elements mitoyens: ( ";
for (int i=1;i<=tai;i++)
cout << (*tabmitoyen)(i)->PtEI()->Num_elt() << " , ";
cout << ") ";
}
{int tai = this->tabmitoyen->Taille();
cout << "\n " << tai << " elements mitoyens: ( ";
for (int i=1;i<=tai;i++)
cout << (*tabmitoyen)(i)->PtEI()->Num_elt() << " , ";
cout << ") ";
}
else
cout << "\n *** aucun element mitoyen !!!! *** ";
};
cout << "\n *** aucun element mitoyen !!!! *** ";
#ifdef UTILISATION_MPI
cout << "\n num_unique= "<<num_unique<<flush;
#endif
};
}
else
{ cout << "\n element de frontiere associe a un element fini: FRONTIERE NON DEFINIE !! "; };
{ cout << "\n element de frontiere associe a un element fini non defini : FRONTIERE NON DEFINIE !! "; };
// cout << "\n ";
};

17
Elements/Mecanique/ElemMeca.cc
View file

@ -1183,6 +1183,23 @@ void ElemMeca::Cal_implicit (DdlElement & tab_ddl
cout << "\n second membre: " << (*residu);
};
};
////------ debug
// if ((Num_elt_const()==11)&&(Num_maillage() == 2))
// {Affiche(2);
//
// cout << "\n debug ElemMeca::Cal_implicit ";
// cout << " Raideur et second membre locaux: elem= " << Num_elt_const()
// << ", maillage= " << Num_maillage();
//// cout << "\n raideur: ";
//// raideur->Affiche();
// cout << "\n second membre: " << (*residu);
// };
//--- fin debug
#endif
// --- intervention dans le cas d'une stabilisation d'hourglass
// stabilisation pour un calcul implicit

26
Elements/Mecanique/Hexaedre/Hexa.cc
View file

@ -60,7 +60,7 @@ Hexa::NombresConstruireHexa::NombresConstruireHexa()
nbiS = 4; // le nombre de point d'intégration pour le calcul de second membre surfacique
nbiA = 2; // le nombre de point d'intégration pour le calcul de second membre linéique
nbiMas = 8; // le nombre de point d'intégration pour le calcul de la matrice masse
nbiHour = 0; // éventuellement, le nombre de point d'intégration un blocage d'hourglass
nbiHour = 0; // éventuellement, le nombre de point d'intégration un blocage d'hourglass
};
@ -85,20 +85,21 @@ Hexa::Hexa () :
if ( doCoHexa == NULL)
{hexa = new GeomHexalin(nombre->nbi);
hexaEr = new GeomHexalin(nombre->nbiEr);
hexaMas = new GeomHexalin(nombre->nbiMas);}
hexaMas = new GeomHexalin(nombre->nbiMas);
}
int dim = ParaGlob::Dimension();
if (dim != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 7)
cout << "\nATTENTION -> dimension " << dim
<<", pas de definition d\'elements hexaedriques lineaires "<< endl;
delete hexa;delete hexaEr;delete hexaMas;
unefois = NULL;
}
{ if (ParaGlob::NiveauImpression() >= 7)
cout << "\nATTENTION -> dimension " << dim
<<", pas de definition d\'elements hexaedriques lineaires "<< endl;
delete hexa;delete hexaEr;delete hexaMas;
unefois = NULL;
}
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
unefois->nbelem_in_Prog++;
}
};
};
};
@ -121,7 +122,8 @@ Hexa::Hexa (int num_mail,int num_id) :
if ( doCoHexa == NULL)
{hexa = new GeomHexalin(nombre->nbi);
hexaEr = new GeomHexalin(nombre->nbiEr);
hexaMas = new GeomHexalin(nombre->nbiMas);}
hexaMas = new GeomHexalin(nombre->nbiMas);
}
#ifdef MISE_AU_POINT
if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois
{if (ParaGlob::NiveauImpression() >= 2)
@ -184,7 +186,7 @@ Hexa::Hexa (const Hexa& HexaraM) :
// Constructeur de copie
// a priori si on utilise le constructeur de copie, donc il y a déjà un élément
// par contre a priori on ne doit pas faire une copie du premier élément
{ if (uneFois.nbelem_in_Prog == 1)
{if (uneFois.nbelem_in_Prog == 1)
{ cout << "\n **** erreur pour l'element Hexa, le constructeur de copie ne doit pas etre utilise"
<< " pour le premier element !! " << endl;
Sortie (1);
@ -201,7 +203,7 @@ Hexa::~Hexa ()
{ if (unefois != NULL)
{unefois->nbelem_in_Prog--;
Destruction();
}
};
};
// affichage dans la sortie transmise, des variables duales "nom"

2
Elements/Mecanique/Hexaedre/Hexa.h
View file

@ -137,7 +137,7 @@ class Hexa : public HexaMemb
{ return ((ElFrontiere*) (new FrontQuadLine(tab,ddelem)));};
// VARIABLES PRIVEES :
// place memoire commune a tous les elements TriaMembL1
// place memoire commune a tous les elements Hexa
static HexaMemb::DonnComHexa * doCoHexa;
// idem mais pour les indicateurs qui servent pour l'initialisation
static HexaMemb::UneFois uneFois;

2
Elements/Mecanique/Hexaedre/HexaMemb.h
View file

@ -547,7 +547,7 @@ class HexaMemb : public ElemMeca
// classe contenant tous les indicateurs statique qui sont modifiés une seule fois
// et un pointeur sur les données statiques communes
// la classe est interne, toutes les variables sont publique. Un pointeur sur une instance de la
// la classe est interne, toutes les variables sont publiques. Un pointeur sur une instance de la
// classe est défini. Son allocation est effectuée dans les classes dérivées
class UneFois
{ public :

146
Elements/Mecanique/Hexaedre/HexaQ.cc
View file

@ -43,7 +43,7 @@ using namespace std; //introduces namespace std
// la taille n'est pas defini ici car elle depend de la lecture
//----------------------------------------------------------------
HexaMemb::DonnComHexa * HexaQ::doCoHexa = NULL;
HexaMemb::DonnComHexa * HexaQ::doCoHexaQ = NULL;
HexaMemb::UneFois HexaQ::uneFois;
HexaQ::NombresConstruireHexaQ HexaQ::nombre_V;
HexaQ::ConsHexaQ HexaQ::consHexaQ;
@ -60,7 +60,7 @@ HexaQ::NombresConstruireHexaQ::NombresConstruireHexaQ()
nbiS = 4; // le nombre de point d'intégration pour le calcul de second membre surfacique
nbiA = 2; // le nombre de point d'intégration pour le calcul de second membre linéique
nbiMas = 27; // le nombre de point d'intégration pour le calcul de la matrice masse
nbiHour = 27; // éventuellement, le nombre de point d'intégration un blocage d'hourglass
nbiHour = 27; // éventuellement, le nombre de point d'intégration un blocage d'hourglass
};
// =========================== constructeurs ==================
@ -69,14 +69,19 @@ HexaQ::NombresConstruireHexaQ::NombresConstruireHexaQ()
// Constructeur par defaut, le seul accepte en dimension different de 3
HexaQ::HexaQ () :
HexaMemb(0,-3,QUADRATIQUE,HEXAEDRE)
{ nombre = & nombre_V;
{ // on intervient seulement à partir du deuxième élément,
if (uneFois.nbelem_in_Prog == 0)
{ uneFois.nbelem_in_Prog++; // au premier passage on se contente d'incrémenter
}
else // sinon on construit
{nombre = & nombre_V;
tab_noeud.Change_taille(nombre->nbne);
// 20 noeuds,8 pt d'integration
// calcul de doCoHexaQ egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 8 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
if ( doCoHexaQ == NULL)
{hexa = new GeomHexaQuad(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
@ -86,37 +91,44 @@ HexaQ::HexaQ () :
}
int dim = ParaGlob::Dimension();
if (dim != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 7)
cout << "\nATTENTION -> dimension " << dim
<<", pas de definition d\'elements hexaedriques quadratiques "<< endl;
delete hexa;delete hexaEr;delete hexaMas;
unefois = NULL;
}
{ if (ParaGlob::NiveauImpression() >= 7)
cout << "\nATTENTION -> dimension " << dim
<<", pas de definition d\'elements hexaedriques quadratiques "<< endl;
delete hexa;delete hexaEr;delete hexaMas;
unefois = NULL;
}
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
{ unefois = & uneFois; // affectation du pointeur de la classe générique HexaMemb
doCoHexaQ = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
unefois->nbelem_in_Prog++;
}
};
};
};
// Constructeur fonction d'un numero
// d'identification
HexaQ::HexaQ (int num_mail,int num_id) :
HexaMemb(num_mail,num_id,QUADRATIQUE,HEXAEDRE)
{ nombre = & nombre_V;
{ // on intervient seulement à partir du deuxième élément,
if (uneFois.nbelem_in_Prog == 0)
{ uneFois.nbelem_in_Prog++; // au premier passage on se contente d'incrémenter
}
else // sinon on construit
{nombre = & nombre_V;
tab_noeud.Change_taille(nombre->nbne);
// 20 noeuds,8 pt d'integration
// calcul de doCoHexa egalement si c'est le premier passage
// calcul de doCoHexaQ egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 4 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
if ( doCoHexaQ == NULL)
{hexa = new GeomHexaQuad(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
hexaEr = new GeomHexaQuad(nombre->nbiEr);}
hexaEr = new GeomHexaQuad(nombre->nbiEr);
// idem pour les calculs de matrices masses consitstantes
hexaMas = new GeomHexaQuad(nombre->nbiMas);
}
#ifdef MISE_AU_POINT
if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 2)
@ -125,48 +137,57 @@ HexaQ::HexaQ (int num_mail,int num_id) :
Sortie (1);
}
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
{ unefois = & uneFois; // affectation du pointeur de la classe générique HexaMemb
doCoHexaQ = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
unefois->nbelem_in_Prog++;
}
};
};
};
// Constructeur utile si le numero de l'element et
// le tableau des noeuds sont connus
HexaQ::HexaQ (int num_mail,int num_id,const Tableau<Noeud *>& tab):
HexaMemb(num_mail,num_id,QUADRATIQUE,HEXAEDRE,tab)
{ nombre = & nombre_V;
if (tab_noeud.Taille() != nombre->nbne)
{ cout << "\n erreur de dimensionnement du tableau de noeud \n";
cout << " HexaQ::HexaQ (int num_mail,int num_id,const Tableau<Noeud *>& tab)\n";
Sortie (1); }
// 20 noeuds,8 pt d'integration
// calcul de doCoHexa egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 4 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
{hexa = new GeomHexaQuad(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> nombre->nbiEr
hexaEr = new GeomHexaQuad(nombre->nbiEr);}
// idem pour les calculs de matrices masses consitstantes
hexaMas = new GeomHexaQuad(nombre->nbiMas);
#ifdef MISE_AU_POINT
if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 2)
cout << "\n erreur de dimension dans HexaQ, dim = " << ParaGlob::Dimension()
<< "\n alors que l'on doit avoir 3 !! " << endl;
Sortie (1);
}
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
bool sans_init_noeud = true;
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL,sans_init_noeud);
// construction du tableau de ddl spécifique à l'élément pour ses
ConstTabDdl();
unefois->nbelem_in_Prog++;
}
{ // on intervient seulement à partir du deuxième élément,
if (uneFois.nbelem_in_Prog == 0)
{ uneFois.nbelem_in_Prog++; // au premier passage on se contente d'incrémenter
}
else // sinon on construit
{nombre = & nombre_V;
if (tab_noeud.Taille() != nombre->nbne)
{ cout << "\n erreur de dimensionnement du tableau de noeud \n";
cout << " HexaQ::HexaQ (int num_mail,int num_id,const Tableau<Noeud *>& tab)\n";
Sortie (1);
}
// 20 noeuds,8 pt d'integration
// calcul de doCoHexaQ egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 4 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexaQ == NULL)
{hexa = new GeomHexaQuad(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> nombre->nbiEr
hexaEr = new GeomHexaQuad(nombre->nbiEr);
// idem pour les calculs de matrices masses consitstantes
hexaMas = new GeomHexaQuad(nombre->nbiMas);
}
#ifdef MISE_AU_POINT
if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 2)
cout << "\n erreur de dimension dans HexaQ, dim = " << ParaGlob::Dimension()
<< "\n alors que l'on doit avoir 3 !! " << endl;
Sortie (1);
}
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
bool sans_init_noeud = true;
doCoHexaQ = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL,sans_init_noeud);
// construction du tableau de ddl spécifique à l'élément pour ses
ConstTabDdl();
unefois->nbelem_in_Prog++;
}
};
};
HexaQ::HexaQ (const HexaQ& HexaQraM) :
@ -174,17 +195,24 @@ HexaQ::HexaQ (const HexaQ& HexaQraM) :
// Constructeur de copie
{ ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
unefois = & uneFois; // affectation du pointeur de la classe générique
if (uneFois.nbelem_in_Prog == 1)
{ cout << "\n **** erreur pour l'element HexaQ, le constructeur de copie ne doit pas etre utilise"
<< " pour le premier element !! " << endl;
Sortie (1);
}
else
{unefois = & uneFois; // affectation du pointeur de la classe générique
// ce qui est relatif à l'initialisation est déjà effectué dans elem_meca et HexaMemb
unefois->nbelem_in_Prog++;
};
unefois->nbelem_in_Prog++;
};
};
HexaQ::~HexaQ ()
// Destruction effectuee dans HexaMemb
{ if (unefois != NULL)
{unefois->nbelem_in_Prog--;
Destruction();
}
};
};
// renseignement d'un élément quadratique incomplet à partir d'un élément linéaire de même type
@ -210,9 +238,9 @@ list <Noeud *> HexaQ::Construct_from_lineaire(const Element & elem,list <DeuxEnt
int idmail = tab_noeud(1)->Num_Mail(); // récup du numéro de maillage associé au noeud
int dim = ParaGlob::Dimension();
HexaMemb::DonnComHexa* doCoHexa = unefois->doCoMemb; // pour simplifier l'écriture
HexaMemb::DonnComHexa* doCoHexaQ = unefois->doCoMemb; // pour simplifier l'écriture
// récupération des coordonnées des noeuds locaux
Tableau <Coordonnee > const & ptlocal = doCoHexa->hexaed->PtelemRef();
Tableau <Coordonnee > const & ptlocal = doCoHexaQ->hexaed->PtelemRef();
// on boucle sur les noeuds supplémentaires : de 9 à 20
int ib=1; // indice sup pour l'attribution d'un bon numéro
for (int ine=num_inf;ine<=num_sup;ine++,ib++)
@ -260,7 +288,7 @@ list <Noeud *> HexaQ::Construct_from_lineaire(const Element & elem,list <DeuxEnt
for (int ine4=num_inf;ine4<=num_sup;ine4++) li_ret.push_back(tab_noeud(ine4));
// 4) remplissage de li_bornes
// recup de la connection des noeuds des arrêtes par rapport a ceux de l'element
Tableau<Tableau<int> > const & nons = doCoHexa->hexaed->NonS();
Tableau<Tableau<int> > const & nons = doCoHexaQ->hexaed->NonS();
// initialisation de li_bornes
li_bornes.erase(li_bornes.begin(),li_bornes.end());
// on boucle sur les arrêtes

4
Elements/Mecanique/Hexaedre/HexaQ.h
View file

@ -145,8 +145,8 @@ class HexaQ : public HexaMemb
ElFrontiere* new_frontiere_surf(int ,Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontQuadQuad(tab,ddelem)));};
// VARIABLES PRIVEES :
// place memoire commune a tous les elements TriaMembL1
static HexaMemb::DonnComHexa * doCoHexa;
// place memoire commune a tous les elements HexaQ
static HexaMemb::DonnComHexa * doCoHexaQ;
// idem mais pour les indicateurs qui servent pour l'initialisation
static HexaMemb::UneFois uneFois;

255
Elements/Mecanique/Hexaedre/HexaQComp.cc
View file

@ -43,7 +43,7 @@ using namespace std; //introduces namespace std
// la taille n'est pas defini ici car elle depend de la lecture
//----------------------------------------------------------------
HexaMemb::DonnComHexa * HexaQComp::doCoHexa = NULL;
HexaMemb::DonnComHexa * HexaQComp::doCoHexaQComp = NULL;
HexaMemb::UneFois HexaQComp::uneFois;
HexaQComp::NombresConstruireHexaQComp HexaQComp::nombre_V;
HexaQComp::ConsHexaQComp HexaQComp::consHexaQComp;
@ -70,133 +70,160 @@ HexaQComp::NombresConstruireHexaQComp::NombresConstruireHexaQComp()
// Constructeur par defaut, le seul accepte en dimension different de 3
HexaQComp::HexaQComp () :
HexaMemb(0,-3,QUADRACOMPL,HEXAEDRE)
{ nombre = & nombre_V;
tab_noeud.Change_taille(nombre->nbne);
// 27 noeuds,8 pt d'integration
// calcul de doCoHexaQComp egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 9 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass
if ( doCoHexa == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
hexaEr = new GeomHexaQuadComp(nombre->nbiEr);
// idem pour les calculs de matrices masses consitstantes
hexaMas = new GeomHexaQuadComp(nombre->nbiMas);
hexaeHourg = new GeomHexaQuadComp(nombre->nbiHour);
}
int dim = ParaGlob::Dimension();
if (dim != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 7)
cout << "\nATTENTION -> dimension " << dim
<<", pas de definition d\'elements hexaedriques quadratiques complet"<< endl;
delete hexa;delete hexaEr;delete hexaMas;
unefois = NULL;
}
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg);
unefois->nbelem_in_Prog++;
}
};
{// on intervient seulement à partir du deuxième élément,
if (uneFois.nbelem_in_Prog == 0)
{ uneFois.nbelem_in_Prog++; // au premier passage on se contente d'incrémenter
}
else // sinon on construit
{ nombre = & nombre_V;
tab_noeud.Change_taille(nombre->nbne);
// 27 noeuds,8 pt d'integration
// calcul de doCoHexaQComp egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 9 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass
if ( doCoHexaQComp == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
hexaEr = new GeomHexaQuadComp(nombre->nbiEr);
// idem pour les calculs de matrices masses consitstantes
hexaMas = new GeomHexaQuadComp(nombre->nbiMas);
hexaeHourg = new GeomHexaQuadComp(nombre->nbiHour);
}
int dim = ParaGlob::Dimension();
if (dim != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 7)
cout << "\nATTENTION -> dimension " << dim
<<", pas de definition d\'elements hexaedriques quadratiques complet"<< endl;
delete hexa;delete hexaEr;delete hexaMas;
unefois = NULL;
}
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexaQComp = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg);
unefois->nbelem_in_Prog++;
};
}
};
// Constructeur fonction d'un numero
// d'identification
HexaQComp::HexaQComp (int num_mail,int num_id) :
HexaMemb(num_mail,num_id,QUADRACOMPL,HEXAEDRE)
{ nombre = & nombre_V;
tab_noeud.Change_taille(nombre->nbne);
// 27 noeuds,8 pt d'integration
// calcul de doCoHexa egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 9 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass
if ( doCoHexa == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
hexaEr = new GeomHexaQuadComp(nombre->nbiEr);
};
// idem pour les calculs de matrices masses consitstantes
hexaMas = new GeomHexaQuadComp(nombre->nbiMas);
hexaeHourg = new GeomHexaQuadComp(nombre->nbiHour);
{// on intervient seulement à partir du deuxième élément,
if (uneFois.nbelem_in_Prog == 0)
{ uneFois.nbelem_in_Prog++; // au premier passage on se contente d'incrémenter
}
else // sinon on construit
{ nombre = & nombre_V;
tab_noeud.Change_taille(nombre->nbne);
// 27 noeuds,8 pt d'integration
// calcul de doCoHexaQComp egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 9 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass
if ( doCoHexaQComp == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
hexaEr = new GeomHexaQuadComp(nombre->nbiEr);
// idem pour les calculs de matrices masses consitstantes
hexaMas = new GeomHexaQuadComp(nombre->nbiMas);
hexaeHourg = new GeomHexaQuadComp(nombre->nbiHour);
};
// #ifdef MISE_AU_POINT
if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 2)
cout << "\n erreur de dimension dans HexaQComp, dim = " << ParaGlob::Dimension()
<< "\n alors que l'on doit avoir 3 !! " << endl;
Sortie (1);
}
// #endif
else
{unefois = & uneFois; // affectation du pointeur de la classe générique
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg);
unefois->nbelem_in_Prog++;
};
};
if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 2)
cout << "\n erreur de dimension dans HexaQComp, dim = " << ParaGlob::Dimension()
<< "\n alors que l'on doit avoir 3 !! " << endl;
Sortie (1);
}
// #endif
else
{unefois = & uneFois; // affectation du pointeur de la classe générique
doCoHexaQComp = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg);
unefois->nbelem_in_Prog++;
};
};
};
// Constructeur utile si le numero de l'element et
// le tableau des noeuds sont connus
HexaQComp::HexaQComp (int num_mail,int num_id,const Tableau<Noeud *>& tab):
HexaMemb(num_mail,num_id,QUADRACOMPL,HEXAEDRE,tab)
{ nombre = & nombre_V;
if (tab_noeud.Taille() != nombre->nbne)
{ cout << "\n erreur de dimensionnement du tableau de noeud \n";
cout << " HexaQComp::HexaQComp (int num_mail,int num_id,const Tableau<Noeud *>& tab)\n";
Sortie (1);
};
// 27 noeuds,8 pt d'integration
// calcul de doCoHexa egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 9 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass
if ( doCoHexa == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> nombre->nbiEr
hexaEr = new GeomHexaQuadComp(nombre->nbiEr);}
// idem pour les calculs de matrices masses consitstantes
hexaMas = new GeomHexaQuadComp(nombre->nbiMas);
hexaeHourg = new GeomHexaQuadComp(nombre->nbiHour);
// #ifdef MISE_AU_POINT
if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 2)
cout << "\n erreur de dimension dans HexaQComp, dim = " << ParaGlob::Dimension()
<< "\n alors que l'on doit avoir 3 !! " << endl;
Sortie (1);
}
// #endif
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
bool sans_init_noeud = true;
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg,sans_init_noeud);
// construction du tableau de ddl spécifique à l'élément pour ses
ConstTabDdl();
unefois->nbelem_in_Prog++;
{// on intervient seulement à partir du deuxième élément,
if (uneFois.nbelem_in_Prog == 0)
{ uneFois.nbelem_in_Prog++; // au premier passage on se contente d'incrémenter
}
else // sinon on construit
{ nombre = & nombre_V;
if (tab_noeud.Taille() != nombre->nbne)
{ cout << "\n erreur de dimensionnement du tableau de noeud \n";
cout << " HexaQComp::HexaQComp (int num_mail,int num_id,const Tableau<Noeud *>& tab)\n";
Sortie (1);
};
// 27 noeuds,8 pt d'integration
// calcul de doCoHexaQComp egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 9 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass
if ( doCoHexaQComp == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> nombre->nbiEr
hexaEr = new GeomHexaQuadComp(nombre->nbiEr);
// idem pour les calculs de matrices masses consitstantes
hexaMas = new GeomHexaQuadComp(nombre->nbiMas);
hexaeHourg = new GeomHexaQuadComp(nombre->nbiHour);
}
// #ifdef MISE_AU_POINT
if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois
{ if (ParaGlob::NiveauImpression() >= 2)
cout << "\n erreur de dimension dans HexaQComp, dim = " << ParaGlob::Dimension()
<< "\n alors que l'on doit avoir 3 !! " << endl;
Sortie (1);
}
// #endif
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
bool sans_init_noeud = true;
doCoHexaQComp = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg,sans_init_noeud);
// construction du tableau de ddl spécifique à l'élément pour ses
ConstTabDdl();
unefois->nbelem_in_Prog++;
};
};
};
};
HexaQComp::HexaQComp (const HexaQComp& HexaQraM) :
HexaMemb (HexaQraM)
// Constructeur de copie
{ unefois = & uneFois; // affectation du pointeur de la classe générique
// ce qui est relatif à l'initialisation est déjà effectué dans elem_meca et HexaMemb
unefois->nbelem_in_Prog++;
};
HexaQComp::~HexaQComp ()
// Destruction effectuee dans HexaMemb
{ if (unefois != NULL)
{unefois->nbelem_in_Prog--;
Destruction();
}
};
// a priori si on utilise le constructeur de copie, donc il y a déjà un élément
// par contre a priori on ne doit pas faire une copie du premier élément
{if (uneFois.nbelem_in_Prog == 1)
{ cout << "\n **** erreur pour l'element HexaQComp, le constructeur de copie ne doit pas etre utilise"
<< " pour le premier element !! " << endl;
Sortie (1);
}
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique
// ce qui est relatif à l'initialisation est déjà effectué dans elem_meca et HexaMemb
unefois->nbelem_in_Prog++;
};
};
HexaQComp::~HexaQComp ()
// Destruction effectuee dans HexaMemb
{ if (unefois != NULL)
{unefois->nbelem_in_Prog--;
Destruction();
}
};
// renseignement d'un élément complet à partir d'un élément incomplet de même type
// retourne les nouveaux noeuds construit à partir de l'interpolation incomplète.
@ -221,9 +248,9 @@ list <Noeud *> HexaQComp::Construct_from_imcomplet(const Element & elem,list <De
int idmail = tab_noeud(1)->Num_Mail(); // récup du numéro de maillage associé au noeud
int dim = ParaGlob::Dimension();
HexaMemb::DonnComHexa* doCoHexa = unefois->doCoMemb; // pour simplifier l'écriture
HexaMemb::DonnComHexa* doCoHexaQComp = unefois->doCoMemb; // pour simplifier l'écriture
// récupération des coordonnées des noeuds locaux
Tableau <Coordonnee > const & ptlocal = doCoHexa->hexaed->PtelemRef();
Tableau <Coordonnee > const & ptlocal = doCoHexaQComp->hexaed->PtelemRef();
// on boucle sur les noeuds supplémentaires : de 21 à 27
int ib=1; // indice sup pour l'attribution d'un bon numéro
for (int ine=num_inf;ine<=num_sup;ine++,ib++)
@ -271,7 +298,7 @@ list <Noeud *> HexaQComp::Construct_from_imcomplet(const Element & elem,list <De
for (int ine4=num_inf;ine4<=num_sup;ine4++) li_ret.push_back(tab_noeud(ine4));
// 4) remplissage de li_bornes
// recup de la connection des noeuds des faces par rapport a ceux de l'element
Tableau<Tableau<int> > const & nonf = doCoHexa->hexaed->Nonf();
Tableau<Tableau<int> > const & nonf = doCoHexaQComp->hexaed->Nonf();
// initialisation de li_bornes
li_bornes.erase(li_bornes.begin(),li_bornes.end());
// On travaille d'abord sur les faces de l'élément

4
Elements/Mecanique/Hexaedre/HexaQComp.h
View file

@ -145,8 +145,8 @@ class HexaQComp : public HexaMemb
ElFrontiere* new_frontiere_surf(int ,Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontQuadQC(tab,ddelem)));};
// VARIABLES PRIVEES :
// place memoire commune a tous les elements TriaMembL1
static HexaMemb::DonnComHexa * doCoHexa;
// place memoire commune a tous les elements HexaQComp
static HexaMemb::DonnComHexa * doCoHexaQComp;
// idem mais pour les indicateurs qui servent pour l'initialisation
static HexaMemb::UneFois uneFois;

18
Elements/Mecanique/Hexaedre/HexaQComp_1pti.cc
View file

@ -43,7 +43,7 @@ using namespace std; //introduces namespace std
// la taille n'est pas defini ici car elle depend de la lecture
//----------------------------------------------------------------
HexaMemb::DonnComHexa * HexaQComp_cm1pti::doCoHexa = NULL;
HexaMemb::DonnComHexa * HexaQComp_cm1pti::doCoHexaQComp_cm1pti = NULL;
HexaMemb::UneFois HexaQComp_cm1pti::uneFois;
HexaQComp_cm1pti::NombresConstruireHexaQComp_cm1pti HexaQComp_cm1pti::nombre_V;
HexaQComp_cm1pti::ConsHexaQComp_cm1pti HexaQComp_cm1pti::consHexaQComp_cm1pti;
@ -81,7 +81,7 @@ HexaQComp_cm1pti::HexaQComp_cm1pti () :
// ici 4 et 9 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass
if ( doCoHexa == NULL)
if ( doCoHexaQComp_cm1pti == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
@ -100,7 +100,7 @@ HexaQComp_cm1pti::HexaQComp_cm1pti () :
}
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg);
doCoHexaQComp_cm1pti = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg);
unefois->nbelem_in_Prog++;
}
};
@ -117,12 +117,12 @@ HexaQComp_cm1pti::HexaQComp_cm1pti (int num_mail,int num_id) :
else // sinon on construit
{nombre = & nombre_V;
tab_noeud.Change_taille(nombre->nbne);
// calcul de doCoHexa egalement si c'est le premier passage
// calcul de doCoHexaQComp_cm1pti egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 9 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass
if ( doCoHexa == NULL)
if ( doCoHexaQComp_cm1pti == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
@ -139,7 +139,7 @@ HexaQComp_cm1pti::HexaQComp_cm1pti (int num_mail,int num_id) :
}
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg);
doCoHexaQComp_cm1pti = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg);
unefois->nbelem_in_Prog++;
}
};
@ -159,12 +159,12 @@ HexaQComp_cm1pti::HexaQComp_cm1pti (int num_mail,int num_id,const Tableau<Noeud
{ cout << "\n erreur de dimensionnement du tableau de noeud \n";
cout << " HexaQComp_cm1pti::HexaQComp_cm1pti (int num_mail,int num_id,const Tableau<Noeud *>& tab)\n";
Sortie (1); }
// calcul de doCoHexa egalement si c'est le premier passage
// calcul de doCoHexaQComp_cm1pti egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 9 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass
if ( doCoHexa == NULL)
if ( doCoHexaQComp_cm1pti == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> nombre->nbiEr
@ -182,7 +182,7 @@ HexaQComp_cm1pti::HexaQComp_cm1pti (int num_mail,int num_id,const Tableau<Noeud
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
bool sans_init_noeud = true;
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg,sans_init_noeud);
doCoHexaQComp_cm1pti = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg,sans_init_noeud);
// construction du tableau de ddl spécifique à l'élément pour ses
ConstTabDdl();
unefois->nbelem_in_Prog++;

18
Elements/Mecanique/Hexaedre/HexaQComp_27pti.cc
View file

@ -43,7 +43,7 @@ using namespace std; //introduces namespace std
// la taille n'est pas defini ici car elle depend de la lecture
//----------------------------------------------------------------
HexaMemb::DonnComHexa * HexaQComp_cm27pti::doCoHexa = NULL;
HexaMemb::DonnComHexa * HexaQComp_cm27pti::doCoHexaQComp_cm27pti = NULL;
HexaMemb::UneFois HexaQComp_cm27pti::uneFois;
HexaQComp_cm27pti::NombresConstruireHexaQComp_cm27pti HexaQComp_cm27pti::nombre_V;
HexaQComp_cm27pti::ConsHexaQComp_cm27pti HexaQComp_cm27pti::consHexaQComp_cm27pti;
@ -80,7 +80,7 @@ HexaQComp_cm27pti::HexaQComp_cm27pti () :
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 9 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
if ( doCoHexaQComp_cm27pti == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
@ -98,7 +98,7 @@ HexaQComp_cm27pti::HexaQComp_cm27pti () :
}
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
doCoHexaQComp_cm27pti = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
unefois->nbelem_in_Prog++;
}
};
@ -115,11 +115,11 @@ HexaQComp_cm27pti::HexaQComp_cm27pti (int num_mail,int num_id) :
else // sinon on construit
{nombre = & nombre_V;
tab_noeud.Change_taille(nombre->nbne);
// calcul de doCoHexa egalement si c'est le premier passage
// calcul de doCoHexaQComp_cm27pti egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 9 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
if ( doCoHexaQComp_cm27pti == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
@ -135,7 +135,7 @@ HexaQComp_cm27pti::HexaQComp_cm27pti (int num_mail,int num_id) :
}
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
doCoHexaQComp_cm27pti = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
unefois->nbelem_in_Prog++;
}
};
@ -155,11 +155,11 @@ HexaQComp_cm27pti::HexaQComp_cm27pti (int num_mail,int num_id,const Tableau<Noeu
{ cout << "\n erreur de dimensionnement du tableau de noeud \n";
cout << " HexaQComp_cm27pti::HexaQComp_cm27pti (int num_mail,int num_id,const Tableau<Noeud *>& tab)\n";
Sortie (1); }
// calcul de doCoHexa egalement si c'est le premier passage
// calcul de doCoHexaQComp_cm27pti egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 9 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
if ( doCoHexaQComp_cm27pti == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> nombre->nbiEr
@ -176,7 +176,7 @@ HexaQComp_cm27pti::HexaQComp_cm27pti (int num_mail,int num_id,const Tableau<Noeu
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
bool sans_init_noeud = true;
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL,sans_init_noeud);
doCoHexaQComp_cm27pti = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL,sans_init_noeud);
// construction du tableau de ddl spécifique à l'élément pour ses
ConstTabDdl();
unefois->nbelem_in_Prog++;

18
Elements/Mecanique/Hexaedre/HexaQComp_64pti.cc
View file

@ -43,7 +43,7 @@ using namespace std; //introduces namespace std
// la taille n'est pas defini ici car elle depend de la lecture
//----------------------------------------------------------------
HexaMemb::DonnComHexa * HexaQComp_cm64pti::doCoHexa = NULL;
HexaMemb::DonnComHexa * HexaQComp_cm64pti::doCoHexaQComp_cm64pti = NULL;
HexaMemb::UneFois HexaQComp_cm64pti::uneFois;
HexaQComp_cm64pti::NombresConstruireHexaQComp_cm64pti HexaQComp_cm64pti::nombre_V;
HexaQComp_cm64pti::ConsHexaQComp_cm64pti HexaQComp_cm64pti::consHexaQComp_cm64pti;
@ -79,7 +79,7 @@ HexaQComp_cm64pti::HexaQComp_cm64pti () :
// calcul de doCoHexaQComp_cm64pti egalement si c'est le premier passage
// après hexa
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
if ( doCoHexaQComp_cm64pti == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
@ -97,7 +97,7 @@ HexaQComp_cm64pti::HexaQComp_cm64pti () :
}
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
doCoHexaQComp_cm64pti = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
unefois->nbelem_in_Prog++;
}
};
@ -114,10 +114,10 @@ HexaQComp_cm64pti::HexaQComp_cm64pti (int num_mail,int num_id) :
else // sinon on construit
{nombre = & nombre_V;
tab_noeud.Change_taille(nombre->nbne);
// calcul de doCoHexa egalement si c'est le premier passage
// calcul de doCoHexaQComp_cm64pti egalement si c'est le premier passage
// après hexa,
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
if ( doCoHexaQComp_cm64pti == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
@ -133,7 +133,7 @@ HexaQComp_cm64pti::HexaQComp_cm64pti (int num_mail,int num_id) :
}
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
doCoHexaQComp_cm64pti = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
unefois->nbelem_in_Prog++;
}
};
@ -153,10 +153,10 @@ HexaQComp_cm64pti::HexaQComp_cm64pti (int num_mail,int num_id,const Tableau<Noeu
{ cout << "\n erreur de dimensionnement du tableau de noeud \n";
cout << " HexaQComp_cm64pti::HexaQComp_cm64pti (int num_mail,int num_id,const Tableau<Noeud *>& tab)\n";
Sortie (1); }
// calcul de doCoHexa egalement si c'est le premier passage
// calcul de doCoHexaQComp_cm64pti egalement si c'est le premier passage
// après hexa,
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
if ( doCoHexaQComp_cm64pti == NULL)
{hexa = new GeomHexaQuadComp(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> nombre->nbiEr
@ -173,7 +173,7 @@ HexaQComp_cm64pti::HexaQComp_cm64pti (int num_mail,int num_id,const Tableau<Noeu
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
bool sans_init_noeud = true;
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL,sans_init_noeud);
doCoHexaQComp_cm64pti = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL,sans_init_noeud);
// construction du tableau de ddl spécifique à l'élément pour ses
ConstTabDdl();
unefois->nbelem_in_Prog++;

4
Elements/Mecanique/Hexaedre/HexaQComp_cm1pti.h
View file

@ -136,8 +136,8 @@ class HexaQComp_cm1pti : public HexaMemb
ElFrontiere* new_frontiere_surf(int ,Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontQuadQC(tab,ddelem)));};
// VARIABLES PRIVEES :
// place memoire commune a tous les elements TriaMembL1
static HexaMemb::DonnComHexa * doCoHexa;
// place memoire commune a tous les elements HexaQComp_cm1pti
static HexaMemb::DonnComHexa * doCoHexaQComp_cm1pti;
// idem mais pour les indicateurs qui servent pour l'initialisation
static HexaMemb::UneFois uneFois;

4
Elements/Mecanique/Hexaedre/HexaQComp_cm27pti.h
View file

@ -136,8 +136,8 @@ class HexaQComp_cm27pti : public HexaMemb
ElFrontiere* new_frontiere_surf(int ,Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontQuadQC(tab,ddelem)));};
// VARIABLES PRIVEES :
// place memoire commune a tous les elements TriaMembL1
static HexaMemb::DonnComHexa * doCoHexa;
// place memoire commune a tous les elements HexaQComp_cm27pti
static HexaMemb::DonnComHexa * doCoHexaQComp_cm27pti;
// idem mais pour les indicateurs qui servent pour l'initialisation
static HexaMemb::UneFois uneFois;

4
Elements/Mecanique/Hexaedre/HexaQComp_cm64pti.h
View file

@ -136,8 +136,8 @@ class HexaQComp_cm64pti : public HexaMemb
ElFrontiere* new_frontiere_surf(int ,Tableau <Noeud *> & tab, DdlElement& ddelem)
{ return ((ElFrontiere*) (new FrontQuadQC(tab,ddelem)));};
// VARIABLES PRIVEES :
// place memoire commune a tous les elements TriaMembL1
static HexaMemb::DonnComHexa * doCoHexa;
// place memoire commune a tous les elements HexaQComp_cm64pti
static HexaMemb::DonnComHexa * doCoHexaQComp_cm64pti;
// idem mais pour les indicateurs qui servent pour l'initialisation
static HexaMemb::UneFois uneFois;

18
Elements/Mecanique/Hexaedre/HexaQ_cm1pti.cc
View file

@ -43,7 +43,7 @@ using namespace std; //introduces namespace std
// la taille n'est pas defini ici car elle depend de la lecture
//----------------------------------------------------------------
HexaMemb::DonnComHexa * HexaQ_cm1pti::doCoHexa = NULL;
HexaMemb::DonnComHexa * HexaQ_cm1pti::doCoHexaQ_cm1pti = NULL;
HexaMemb::UneFois HexaQ_cm1pti::uneFois;
HexaQ_cm1pti::NombresConstruireHexaQ_cm1pti HexaQ_cm1pti::nombre_V;
HexaQ_cm1pti::ConsHexaQ_cm1pti HexaQ_cm1pti::consHexaQ_cm1pti;
@ -82,7 +82,7 @@ HexaQ_cm1pti::HexaQ_cm1pti () :
// ici 4 et 8 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
ElemGeomC0* hexaeHourg=NULL; // pour le blocage d'hourglass
if ( doCoHexa == NULL)
if ( doCoHexaQ_cm1pti == NULL)
{hexa = new GeomHexaQuad(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
@ -101,7 +101,7 @@ HexaQ_cm1pti::HexaQ_cm1pti () :
}
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg);
doCoHexaQ_cm1pti = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg);
unefois->nbelem_in_Prog++;
}
};
@ -119,12 +119,12 @@ HexaQ_cm1pti::HexaQ_cm1pti (int num_mail,int num_id) :
{nombre = & nombre_V;
tab_noeud.Change_taille(nombre->nbne);
// 20 noeuds,8 pt d'integration
// calcul de doCoHexa egalement si c'est le premier passage
// calcul de doCoHexaQ_cm1pti egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 4 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
ElemGeomC0* hexaeHourg=NULL; // pour le blocage d'hourglass
if ( doCoHexa == NULL)
if ( doCoHexaQ_cm1pti == NULL)
{hexa = new GeomHexaQuad(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
@ -141,7 +141,7 @@ HexaQ_cm1pti::HexaQ_cm1pti (int num_mail,int num_id) :
}
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg);
doCoHexaQ_cm1pti = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg);
unefois->nbelem_in_Prog++;
}
};
@ -162,12 +162,12 @@ HexaQ_cm1pti::HexaQ_cm1pti (int num_mail,int num_id,const Tableau<Noeud *>& tab)
cout << " HexaQ_cm1pti::HexaQ_cm1pti (int num_mail,int num_id,const Tableau<Noeud *>& tab)\n";
Sortie (1); }
// 20 noeuds,8 pt d'integration
// calcul de doCoHexa egalement si c'est le premier passage
// calcul de doCoHexaQ_cm1pti egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 4 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
ElemGeomC0* hexaeHourg=NULL; // pour le blocage d'hourglass
if ( doCoHexa == NULL)
if ( doCoHexaQ_cm1pti == NULL)
{hexa = new GeomHexaQuad(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> nombre->nbiEr
@ -185,7 +185,7 @@ HexaQ_cm1pti::HexaQ_cm1pti (int num_mail,int num_id,const Tableau<Noeud *>& tab)
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique
bool sans_init_noeud = true;
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg,sans_init_noeud);
doCoHexaQ_cm1pti = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg,sans_init_noeud);
// construction du tableau de ddl spécifique à l'élément pour ses
ConstTabDdl();
unefois->nbelem_in_Prog++;

2
Elements/Mecanique/Hexaedre/HexaQ_cm1pti.h
View file

@ -137,7 +137,7 @@ class HexaQ_cm1pti : public HexaMemb
{ return ((ElFrontiere*) (new FrontQuadQuad(tab,ddelem)));};
// VARIABLES PRIVEES :
// place memoire commune a tous les elements HexaQ_cm1pti
static HexaMemb::DonnComHexa * doCoHexa;
static HexaMemb::DonnComHexa * doCoHexaQ_cm1pti;
// idem mais pour les indicateurs qui servent pour l'initialisation
static HexaMemb::UneFois uneFois;

18
Elements/Mecanique/Hexaedre/HexaQ_cm27pti.cc
View file

@ -43,7 +43,7 @@ using namespace std; //introduces namespace std
// la taille n'est pas defini ici car elle depend de la lecture
//----------------------------------------------------------------
HexaMemb::DonnComHexa * HexaQ_cm27pti::doCoHexa = NULL;
HexaMemb::DonnComHexa * HexaQ_cm27pti::doCoHexaHexaQ_cm27pti = NULL;
HexaMemb::UneFois HexaQ_cm27pti::uneFois;
HexaQ_cm27pti::NombresConstruireHexaQ_cm27pti HexaQ_cm27pti::nombre_V;
HexaQ_cm27pti::ConsHexaQ_cm27pti HexaQ_cm27pti::consHexaQ_cm27pti;
@ -81,7 +81,7 @@ HexaQ_cm27pti::HexaQ_cm27pti () :
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 8 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
if ( doCoHexaHexaQ_cm27pti == NULL)
{hexa = new GeomHexaQuad(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
@ -99,7 +99,7 @@ HexaQ_cm27pti::HexaQ_cm27pti () :
}
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
doCoHexaHexaQ_cm27pti = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
unefois->nbelem_in_Prog++;
}
};
@ -117,11 +117,11 @@ HexaQ_cm27pti::HexaQ_cm27pti (int num_mail,int num_id) :
{nombre = & nombre_V;
tab_noeud.Change_taille(nombre->nbne);
// 20 noeuds,8 pt d'integration
// calcul de doCoHexa egalement si c'est le premier passage
// calcul de doCoHexaHexaQ_cm27pti egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 4 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
if ( doCoHexaHexaQ_cm27pti == NULL)
{hexa = new GeomHexaQuad(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
@ -137,7 +137,7 @@ HexaQ_cm27pti::HexaQ_cm27pti (int num_mail,int num_id) :
}
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
doCoHexaHexaQ_cm27pti = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
unefois->nbelem_in_Prog++;
}
};
@ -158,11 +158,11 @@ HexaQ_cm27pti::HexaQ_cm27pti (int num_mail,int num_id,const Tableau<Noeud *>& ta
cout << " HexaQ_cm27pti::HexaQ_cm27pti (int num_mail,int num_id,const Tableau<Noeud *>& tab)\n";
Sortie (1); }
// 20 noeuds,8 pt d'integration
// calcul de doCoHexa egalement si c'est le premier passage
// calcul de doCoHexaHexaQ_cm27pti egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 4 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
if ( doCoHexaHexaQ_cm27pti == NULL)
{hexa = new GeomHexaQuad(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> nombre->nbiEr
@ -179,7 +179,7 @@ HexaQ_cm27pti::HexaQ_cm27pti (int num_mail,int num_id,const Tableau<Noeud *>& ta
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
bool sans_init_noeud = true;
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL,sans_init_noeud);
doCoHexaHexaQ_cm27pti = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL,sans_init_noeud);
// construction du tableau de ddl spécifique à l'élément pour ses
ConstTabDdl();
unefois->nbelem_in_Prog++;

2
Elements/Mecanique/Hexaedre/HexaQ_cm27pti.h
View file

@ -137,7 +137,7 @@ class HexaQ_cm27pti : public HexaMemb
{ return ((ElFrontiere*) (new FrontQuadQuad(tab,ddelem)));};
// VARIABLES PRIVEES :
// place memoire commune a tous les elements HexaQ_cm27pti
static HexaMemb::DonnComHexa * doCoHexa;
static HexaMemb::DonnComHexa * doCoHexaHexaQ_cm27pti;
// idem mais pour les indicateurs qui servent pour l'initialisation
static HexaMemb::UneFois uneFois;

18
Elements/Mecanique/Hexaedre/HexaQ_cm64pti.cc
View file

@ -43,7 +43,7 @@ using namespace std; //introduces namespace std
// la taille n'est pas defini ici car elle depend de la lecture
//----------------------------------------------------------------
HexaMemb::DonnComHexa * HexaQ_cm64pti::doCoHexa = NULL;
HexaMemb::DonnComHexa * HexaQ_cm64pti::doCoHexaQ_cm64pti = NULL;
HexaMemb::UneFois HexaQ_cm64pti::uneFois;
HexaQ_cm64pti::NombresConstruireHexaQ_cm64pti HexaQ_cm64pti::nombre_V;
HexaQ_cm64pti::ConsHexaQ_cm64pti HexaQ_cm64pti::consHexaQ_cm64pti;
@ -81,7 +81,7 @@ HexaQ_cm64pti::HexaQ_cm64pti () :
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 8 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
if ( doCoHexaQ_cm64pti == NULL)
{hexa = new GeomHexaQuad(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
@ -99,7 +99,7 @@ HexaQ_cm64pti::HexaQ_cm64pti () :
}
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
doCoHexaQ_cm64pti = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
unefois->nbelem_in_Prog++;
}
};
@ -117,11 +117,11 @@ HexaQ_cm64pti::HexaQ_cm64pti (int num_mail,int num_id) :
{nombre = & nombre_V;
tab_noeud.Change_taille(nombre->nbne);
// 20 noeuds,8 pt d'integration
// calcul de doCoHexa egalement si c'est le premier passage
// calcul de doCoHexaQ_cm64pti egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 4 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
if ( doCoHexaQ_cm64pti == NULL)
{hexa = new GeomHexaQuad(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> 27
@ -137,7 +137,7 @@ HexaQ_cm64pti::HexaQ_cm64pti (int num_mail,int num_id) :
}
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
doCoHexaQ_cm64pti = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL);
unefois->nbelem_in_Prog++;
}
};
@ -158,11 +158,11 @@ HexaQ_cm64pti::HexaQ_cm64pti (int num_mail,int num_id,const Tableau<Noeud *>& ta
cout << " HexaQ_cm64pti::HexaQ_cm64pti (int num_mail,int num_id,const Tableau<Noeud *>& tab)\n";
Sortie (1); }
// 20 noeuds,8 pt d'integration
// calcul de doCoHexa egalement si c'est le premier passage
// calcul de doCoHexaQ_cm64pti egalement si c'est le premier passage
// après hexa, le nombre de point d'intégration de surface pour le second membre
// ici 4 et 4 noeuds pour les éléments de surface
ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL;
if ( doCoHexa == NULL)
if ( doCoHexaQ_cm64pti == NULL)
{hexa = new GeomHexaQuad(nombre->nbi);
// pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité
// de la matrice de raideur -> nombre->nbiEr
@ -179,7 +179,7 @@ HexaQ_cm64pti::HexaQ_cm64pti (int num_mail,int num_id,const Tableau<Noeud *>& ta
#endif
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
bool sans_init_noeud = true;
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL,sans_init_noeud);
doCoHexaQ_cm64pti = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL,sans_init_noeud);
// construction du tableau de ddl spécifique à l'élément pour ses
ConstTabDdl();
unefois->nbelem_in_Prog++;

2
Elements/Mecanique/Hexaedre/HexaQ_cm64pti.h
View file

@ -137,7 +137,7 @@ class HexaQ_cm64pti : public HexaMemb
{ return ((ElFrontiere*) (new FrontQuadQuad(tab,ddelem)));};
// VARIABLES PRIVEES :
// place memoire commune a tous les elements HexaQ_cm64pti
static HexaMemb::DonnComHexa * doCoHexa;
static HexaMemb::DonnComHexa * doCoHexaQ_cm64pti;
// idem mais pour les indicateurs qui servent pour l'initialisation
static HexaMemb::UneFois uneFois;

2
Elements/Mecanique/Hexaedre/Hexa_cm1pti.cc
View file

@ -44,7 +44,7 @@ using namespace std; //introduces namespace std
// la taille n'est pas defini ici car elle depend de la lecture
//----------------------------------------------------------------
HexaMemb::DonnComHexa * Hexa_cm1pti::doCoHexa_cm1pti = NULL;
HexaMemb::DonnComHexa * Hexa_cm1pti::doCoHexa_cm1pti = NULL;
HexaMemb::UneFois Hexa_cm1pti::uneFois;
Hexa_cm1pti::NombresConstruireHexa_cm1pti Hexa_cm1pti::nombre_V;
Hexa_cm1pti::ConsHexa_cm1pti Hexa_cm1pti::consHexa_cm1pti;

2
Elements/Mecanique/Hexaedre/Hexa_cm1pti.h
View file

@ -132,7 +132,7 @@ class Hexa_cm1pti : public HexaMemb
{ return ((ElFrontiere*) (new FrontQuadLine(tab,ddelem)));};
// VARIABLES PRIVEES :
// place memoire commune a tous les elements TriaMembL1
// place memoire commune a tous les elements Hexa_cm1pti
static HexaMemb::DonnComHexa * doCoHexa_cm1pti;
// idem mais pour les indicateurs qui servent pour l'initialisation
static HexaMemb::UneFois uneFois;

2
Elements/Mecanique/Hexaedre/Hexa_cm27pti.cc
View file

@ -43,7 +43,7 @@ using namespace std; //introduces namespace std
// la taille n'est pas defini ici car elle depend de la lecture
//----------------------------------------------------------------
HexaMemb::DonnComHexa * Hexa_cm27pti::doCoHexa_cm27pti = NULL;
HexaMemb::DonnComHexa * Hexa_cm27pti::doCoHexa_cm27pti = NULL;
HexaMemb::UneFois Hexa_cm27pti::uneFois;
Hexa_cm27pti::NombresConstruireHexa_cm27pti Hexa_cm27pti::nombre_V;
Hexa_cm27pti::ConsHexa_cm27pti Hexa_cm27pti::consHexa_cm27pti;

2
Elements/Mecanique/Hexaedre/Hexa_cm27pti.h
View file

@ -132,7 +132,7 @@ class Hexa_cm27pti : public HexaMemb
{ return ((ElFrontiere*) (new FrontQuadLine(tab,ddelem)));};
// VARIABLES PRIVEES :
// place memoire commune a tous les elements TriaMembL1
// place memoire commune a tous les elements Hexa_cm27pti
static HexaMemb::DonnComHexa * doCoHexa_cm27pti;
// idem mais pour les indicateurs qui servent pour l'initialisation
static HexaMemb::UneFois uneFois;

2
Elements/Mecanique/Hexaedre/Hexa_cm64pti.cc
View file

@ -50,7 +50,7 @@ Hexa_cm64pti::ConsHexa_cm64pti Hexa_cm64pti::consHexa_cm64pti;
// constructeur des nombres spécifiques à la classe
Hexa_cm64pti::NombresConstruireHexa_cm64pti::NombresConstruireHexa_cm64pti()
Hexa_cm64pti::NombresConstruireHexa_cm64pti::NombresConstruireHexa_cm64pti()
{ nbne = 8; // le nombre de noeud de l'élément
nbneS = 4; // le nombre de noeud des facettes
nbneA = 2; // le nombre de noeud des aretes

2
Elements/Mecanique/Hexaedre/Hexa_cm64pti.h
View file

@ -132,7 +132,7 @@ class Hexa_cm64pti : public HexaMemb
{ return ((ElFrontiere*) (new FrontQuadLine(tab,ddelem)));};
// VARIABLES PRIVEES :
// place memoire commune a tous les elements TriaMembL1
// place memoire commune a tous les elements Hexa_cm64pti
static HexaMemb::DonnComHexa * doCoHexa_cm64pti;
// idem mais pour les indicateurs qui servent pour l'initialisation
static HexaMemb::UneFois uneFois;

2
Elements/Mecanique/Tetraedre/TetraQ.cc
View file

@ -62,7 +62,7 @@ TetraQ::NombresConstruireTetraQ::NombresConstruireTetraQ()
nbiS = 3; // le nombre de point d'intégration pour le calcul de second membre surfacique
nbiA = 2; // le nombre de point d'intégration pour le calcul de second membre linéique
nbiMas = 15; // le nombre de point d'intégration pour le calcul de la matrice masse
nbiHour = 0; // le nombre de point d'intégration un blocage d'hourglass
nbiHour = 0; // le nombre de point d'intégration un blocage d'hourglass
};
// =========================== constructeurs ==================

18
General/Projet.cc
View file

@ -110,7 +110,18 @@
};
// destructeur
Projet::~Projet ()
{ if (paraGlob != NULL) delete paraGlob; // parametres globaux
{ // fermeture du fichier base info si nécessaire
if (algori != NULL)
if (algori->Active_sauvegarde())
entreePrinc->Fermeture_base_info();
int nbAlgo=tabAlgo.Taille();
for (int i=2;i<=nbAlgo;i++)
if (tabAlgo(i)!= NULL)
if (tabAlgo(i)->Active_sauvegarde())
entreePrinc->Fermeture_base_info();
entreePrinc->Fermeture_base_info();
if (paraGlob != NULL) delete paraGlob; // parametres globaux
if (entreePrinc != NULL) delete entreePrinc; // acces a la lecture du fichier principal
if (lesMaillages != NULL) delete lesMaillages; // description des maillages
if (algori != NULL) delete algori; // algorithme de calcul
@ -124,13 +135,8 @@
if (lescontacts != NULL) delete lescontacts; // le contact eventuel
if (resultats != NULL) delete resultats; // sortie des resultats
if (varExpor != NULL) delete varExpor; // définition des variables a exporter
int nbAlgo=tabAlgo.Taille();
for (int i=2;i<=nbAlgo;i++)
if (tabAlgo(i)!= NULL) delete tabAlgo(i);
// fermeture du fichier base info si nécessaire
if (algori != NULL)
if (algori->Active_sauvegarde())
entreePrinc->Fermeture_base_info();
};
// définition d'un fichier de commandes

33
General/herezh.cc
View file

@ -222,6 +222,25 @@ int main (int argc, const char * argv[]) {
#ifdef UTILISATION_MPI
// --- mise en route de la parallèlisation
// int *flag1, *flag2;
// MPI_Initialized(flag1);
// if (*flag1)
// {MPI_Finalized(flag2);
// if (*flag2)
// {MPI_Finalize();
// cout << "\n MPI n'est pas fermé, on l'arrete !! avant de recommencer ! ";
// }
// }
// int flag;
//
// flag = 0;
// MPI_Finalized(&flag);
// if (flag)
// {
// printf("MPI_Finalized returned true before MPI_Init.\n");
// return -1;
// }
mpi::environment env;
// def global d'un communicator
mpi::communicator world;
@ -237,12 +256,12 @@ int main (int argc, const char * argv[]) {
gethostname(hostname, sizeof(hostname));
printf("PID %d on %s ready for attach\n", getpid(), hostname);
fflush(stdout);
cout << "\n entrer quelque chose pour continuer : ";
string toto;
cin >> toto;
// cout << "\n entrer quelque chose pour continuer : ";
// string toto;
// cin >> toto;
// while (0 == i)
// sleep(5);
while (0 == i)
sleep(5);
}
#endif
@ -577,5 +596,7 @@ catch ( ... )
cout << " =============================================================";
cout << endl;
};
#ifdef UTILISATION_MPI
MPI_Finalize();
#endif
};

25
Lecture/utilLecture2.cc
View file

@ -198,7 +198,7 @@ void UtilLecture::Ouverture_base_info(string type_entree)
};
#ifndef UTILISATION_MPI
};
}
}
#else
// #ifdef UTILISATION_MPI
@ -224,8 +224,14 @@ void UtilLecture::Ouverture_base_info(string type_entree)
if (ent_PI != NULL) {ent_PI->close();ent_PI = NULL;};
streampos debut_increment(0);
#else
if (ent_MPI_PI != MPI_FILE_NULL)
{MPI_File_close(&ent_MPI_PI);ent_MPI_PI = MPI_FILE_NULL;};
if(num_cpu_en_cours_BI == 0)
// seule le proc 0 gère le fichier PI
{if (ent_MPI_PI != MPI_FILE_NULL)
{MPI_File_close(&ent_MPI_PI);};
}
// pour tous les proc on met la variable de fichier à NULL
// ce qui est utile pour les tests à suivre
ent_MPI_PI = MPI_FILE_NULL;
MPI_Offset debut_increment(0);
#endif
// on efface les positions actuelles
@ -334,7 +340,7 @@ void UtilLecture::Ouverture_base_info(string type_entree)
{liste_posi_BI.clear();
int taille = inter.size();
for (int i=0;i<taille;i++)
{Position_BI truc(inter[i].num_incr,inter[i].position);
{Position_BI truc(inter[i].position,inter[i].num_incr);
liste_posi_BI.push_back(truc);
};
};
@ -443,7 +449,7 @@ void UtilLecture::Fermeture_base_info()
ent_BI = NULL;
if(ent_PI != NULL) delete ent_PI;
ent_PI = NULL;
};
};
if (sort_BI != NULL)
{// cas du fichier ouvert en écriture
delete sort_BI;
@ -464,7 +470,7 @@ void UtilLecture::Fermeture_base_info()
// fermeture du fichier
delete sort_PI;
sort_PI = NULL;
};
};
};
#else
lecture_MPI_BI_en_cours = 0; // on ne peut plus utiliser Nouvelle_enreg_MPI_BI
@ -477,7 +483,8 @@ void UtilLecture::Fermeture_base_info()
{ // cas du fichier ouvert en lecture
MPI_File_close(&ent_MPI_BI);
ent_MPI_BI=MPI_FILE_NULL;indic_ent_MPI_BI = 1;
MPI_File_close(&ent_MPI_PI);
if (proc_en_cours==0)
MPI_File_close(&ent_MPI_PI);
ent_MPI_PI=MPI_FILE_NULL;indic_ent_MPI_PI = 1;
};
if (sort_MPI_BI != MPI_FILE_NULL)
@ -510,7 +517,9 @@ void UtilLecture::Fermeture_base_info()
};
};
// fermeture du fichier
MPI_File_close(&sort_MPI_PI);indic_ent_MPI_PI = 1;
if (proc_en_cours==0)
MPI_File_close(&sort_MPI_PI);
indic_ent_MPI_PI = 1;
sort_MPI_PI=MPI_FILE_NULL;
};
// le broadcast sur un fichier mpi ne fonctionne pas car a priori non supporté comme structure

480
Maillage/LesMaillages2.cc
View file

@ -47,6 +47,14 @@ using namespace std; //introduces namespace std
#include "CharUtil.h"
#include "TypeQuelconqueParticulier.h"
#ifdef UTILISATION_MPI
#include "mpi.h"
#include <boost/mpi.hpp>
#include <boost/serialization/list.hpp>
namespace mpi = boost::mpi;
#endif
//#ifndef SYSTEM_MAC_OS_X_unix
// #include "Frontier.h"
//#endif
@ -2038,7 +2046,13 @@ void LesMaillages::CreationMaillageSFE() // on passe en revue les différents m
bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <Condilineaire> >& tab_condCLL
,TroisEntiers& nouvelles_largeur_en_ddl
,const Nb_assemb* nb_casAssemb,bool sans_changement_num_noeud)
{ // pour effectuer la renumérotation il est nécessaire de créer un tableau global de tous les noeuds et
{
#ifdef UTILISATION_MPI
int num_proc = ParaGlob::Monde()->rank();
// tous les proc passent ici mais seul le proc 0 affiche
#endif
// pour effectuer la renumérotation il est nécessaire de créer un tableau global de tous les noeuds et
// de tous les éléments, de manière à pouvoir les gérer en même temps
// a1) on calcul les nombres maxi
int nb_noeud = 0; int nb_element = 0;
@ -2055,7 +2069,7 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
LesMaillages::CreeElemFront(); // on crée les éléments frontières
// b) on crée les tableaux
Tableau <Noeud *> t_noe(nb_noeud); // le tableau global de noeuds
Tableau <Noeud *> t_noe(nb_noeud); // le tableau global de noeuds: ne change pas après l'affectation qui suit
Tableau <int > t_oldNumNoeud(nb_noeud); // tableau des anciens numéros de noeuds
Tableau<Element *> t_elem(nb_element); // le tableau global des éléments
// c) on rempli les tableaux en changeant les numéros des noeuds (pour avoir une seule numérotation)
@ -2077,6 +2091,57 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
};
}; // on encapsule pour isoler les variables numGlobNoeud et numGlobEle qui ne
// doivent exister que dans la boucle
// //------------debug ---------
// #ifdef UTILISATION_MPI
// {
// if (ParaGlob::Monde()->rank() == 0)
// {// on va demander successivement à tous les process d'afficher les nnuméros de pointeur d'assemblage
// // d'abord le proc 0
// cout << "\n début :: proc 0 : debug LesMaillages::Renumerotation "
// << " num_noeud= " << nb_noeud;
//
// for (int i=1;i<=nb_noeud;i++)
// cout << "\n proc 0: pointeur d'assemblage indice tableau i="<<i<<" : pointeur "<<t_noe(i)->PosiAssemb(nb_casAssemb->n)
// << ", num_noeud " << t_noe(i)->Num_noeud();
// cout << flush;
// // il s'agit d'un procédé séquentiel,
// // NB: je pense que c'est plus rapide et plus sûr de passer par le .info
// // pour construire et remplir dans chaque process la structure de stockage, que de le faire
// // en passant les données via mpi entre le master et les sous_process
// int nb_process = ParaGlob::Monde()->size();
// // NB: le process 0 c'est le main
// for (int i=1;i<nb_process;i++) // < absolu, donc le max c'est nb_process-1
// { // on envoie un signal de démarrage au process i
// int mess = i;
// ParaGlob::Monde()->send(i, 100001, mess);
// // et on attend du process i un signal de fin d'exécution
// std::string msg;
// ParaGlob::Monde()->recv(i, 2+100001, msg);
// // gestion d'erreur éventuelle
// if (msg == "erreur_en_lecture")
// // arrêt du traitement
// Sortie(1);
// };
// }
// else
// {std::string msg;
// int mess;
// ParaGlob::Monde()->recv(0, 100001, mess);
// if (mess==num_proc)
// {cout << "\n début:: proc"<<num_proc<<" : debug LesMaillages::Renumerotation "
// << " num_noeud= " << nb_noeud;
// for (int i=1;i<=nb_noeud;i++)
// cout << "\n proc "<<num_proc<<": pointeur d'assemblage indice tableau i="<<i<<" : "<<t_noe(i)->PosiAssemb(nb_casAssemb->n)
// << ", num_noeud " << t_noe(i)->Num_noeud();
// }
// cout << flush;
// // on envoie à 0 le message de fin de lecture
// ParaGlob::Monde()->send(0, 2+100001, std::string("OK"));
// };
// // arrivé ici tous les process ont sortie la numérotation d'assemblage
// }
// #endif
// //------------ fin debug ---------
// avant tout changement on calcul la largeur initiale due aux conditions linéaires
// celle-ci n'est valide que dans le cas où tous les noeuds ont des numéros différents
@ -2092,6 +2157,10 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
if ((ParaGlob::NiveauImpression() > 4)
|| ((nb_casAssemb == NULL)&&(ParaGlob::NiveauImpression() > 0))
)
#ifdef UTILISATION_MPI
if (num_proc == 0)
// tous les proc passent ici mais seul le proc 0 affiche
#endif
{ cout << "\n pour l'ensemble des conditions linaires: via une numerotation unique pour tous les maillages, "
<< " la 1/2 largeur de bande en noeud initiale est "
<< largeur_initiale_CLL << flush;
@ -2103,10 +2172,38 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
Tableau < LaLIST_io <Noeud* > > t_voisin; // def du tableau des voisins des noeuds
list < list < Maillage::Noeud_degre > > lis_descent; // stockage des descendants
bool calcul_ok = false; // init par défaut
Tableau <Noeud*> tab_N_final_final;// ne sert que pour le cas nb_casAssemb != NULL
Tableau <Noeud* > tab_N_final;
#ifdef UTILISATION_MPI
// std::vector<int> vect_tab_N_final_final(nb_noeud); // pour le transfert
DeuxEntiers indic_phase1;
std::array<int,6> indic_result; // ""
// std::vector<int> vect_finalNumNoeud(nb_noeud); // tableau des numéros de noeuds finaux
std::list<int > li_newNumNoeud; // list des nouveaux numéros de noeuds
std::list<int > li_num_tab_N_final;
// std::vector<vector<int> > std_vector_t_nv_num(nbMaillageTotal);
// for (int iml=1; iml<= nbMaillageTotal;iml++)
// {int taille = tabMaillage(iml)->Nombre_noeud();
// std_vector_t_nv_num[iml-1].resize(taille); // init
// };
// tous les proc passent ici mais seul le proc 0 calcule la nouvelle numérotation
if (num_proc == 0)
{
#endif
Noeud* noe_dep = Maillage::Point_de_depart(t_elem,t_noe,tt_noeud_front,t_voisin,lis_descent,tab_condCLL,calcul_ok);
if (calcul_ok) // on ne continue que si c'est ok
{// on appelle l'algorithme de Cuthill Mac Kee
Tableau <Noeud* > tab_N_final = Maillage::Cuthill_Mac_Kee(nb_noeud,noe_dep,t_voisin,lis_descent);
{
//------- début de la partie qui sera absente dans le cas des proc != 0 -----------------
// on appelle l'algorithme de Cuthill Mac Kee
tab_N_final = Maillage::Cuthill_Mac_Kee(nb_noeud,noe_dep,t_voisin,lis_descent);
#ifdef UTILISATION_MPI
// les numéros pointés par tab_N_final changent mais pas les éléments pointés
// et ici les numéros de noeuds n'ont pas encore changés
// donc tab_N_final(i) pointe sur toe(tab_N_final(i)->Num_noeud())
for (int inoe=1;inoe <= nb_noeud; inoe++)
li_num_tab_N_final.push_back(tab_N_final(inoe)->Num_noeud()); // pour le transfert
#endif
// --- maintenant on regarde l'évolution de la largeur de bande en noeud
// tout d'abord la largeur initiale
int largeur_initiale = Maillage::LargeurBandeEnNoeuds(t_elem);
@ -2140,8 +2237,8 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
for (int j=1;j<= taille;j++)
largeur_Cuthill_inverse_CLL=MaX(largeur_Cuthill_inverse_CLL,condCLL(j).DiffMaxiNumeroNoeud());
};
if ((ParaGlob::NiveauImpression() > 3)
|| ((nb_casAssemb == NULL)&&(ParaGlob::NiveauImpression() > 0))
if ( (ParaGlob::NiveauImpression() > 3)
|| ((nb_casAssemb == NULL)&&(ParaGlob::NiveauImpression() > 0))
)
{ cout << "\n $$ Premiere etape: optimisation sur l'ensemble des maillages sous forme d'un seul groupe $$ ";
cout << "\n pour l'ensemble des maillages: 1/2 largeur de bande en noeud, initiale= " << largeur_initiale
@ -2200,17 +2297,117 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
//// noe->Change_num_noeud(num);
//// };
};
};
// on calcule si demandé, la largeur de bande en ddl qui résulte de la nouvelle numérotation
#ifdef UTILISATION_MPI
indic_phase1.un = calcul_ok;
indic_phase1.deux = nouvelle_numerotation;
// dans le cas // on sauvegarde la numérotation dans les noeuds qui a éventuellement changé
// en fonction du parcours de l'algo précédent
for (int inoe=1;inoe <= nb_noeud; inoe++)
li_newNumNoeud.push_back(t_noe(inoe)->Num_noeud()); // pour le transfert
};
broadcast(*ParaGlob::Monde(),indic_phase1,0);
broadcast(*ParaGlob::Monde(), li_newNumNoeud, 0);
broadcast(*ParaGlob::Monde(), li_num_tab_N_final, 0);
if (num_proc != 0)
{calcul_ok=indic_phase1.un;
nouvelle_numerotation = indic_phase1.deux;
};
#endif
//------ à partir d'ici, on retrouve un cheminement de même type dans les proc i != 0 -------------
if (calcul_ok)
{ // on calcule si demandé, la largeur de bande en ddl qui résulte de la nouvelle numérotation
// avant de changer les numéros de noeuds
// et la mise à jour des pointeurs d'assemblages
Tableau <Noeud*> tab_N_final_final;// ne sert que pour le cas nb_casAssemb != NULL
if (nouvelle_numerotation && (nb_casAssemb != NULL))
{ // on garde en mémoire la numérotation des noeuds, dans l'ordre de tab_N_final
// car on ne connait pas exactement le cheminement précédent de ce qui est retenue au final
tab_N_final_final.Change_taille(nb_noeud);
for (int i=1;i<=nb_noeud;i++)
tab_N_final_final(tab_N_final(i)->Num_noeud()) = tab_N_final(i);
#ifdef UTILISATION_MPI
// les proc i reconstruisent le tableau tab_N_final_final à partir des infos
// récupérées du proc 0
if (num_proc != 0)
// on met la numérotation comme elle est dans le cas du proc 0
{
{// on remet la numérotation initiale dans noe
for (int ia=1;ia <= nb_noeud; ia++)
t_noe(ia)->Change_num_noeud(t_oldNumNoeud(ia));
// on reconstruit tab_N_final
std::list<int>::iterator il,ilfin = li_num_tab_N_final.end();
int i=1;tab_N_final.Change_taille(nb_noeud);
for (il = li_num_tab_N_final.begin();il != ilfin;il++,i++)
tab_N_final(i) = t_noe(*il);
}
{// on met les num de noeuds via toe
std::list<int>::iterator il,ilfin = li_newNumNoeud.end();
int i=1;
for (il = li_newNumNoeud.begin();il != ilfin;il++,i++)
t_noe(i)->Change_num_noeud(*il);
};
}
#endif
tab_N_final_final.Change_taille(nb_noeud);
for (int i=1;i<=nb_noeud;i++)
tab_N_final_final(tab_N_final(i)->Num_noeud()) = tab_N_final(i);
};
// //------------debug ---------
// #ifdef UTILISATION_MPI
// {
// if (ParaGlob::Monde()->rank() == 0)
// {
// cout << "\n rebouclage :: proc 0 : debug LesMaillages::Renumerotation "
// << " num_noeud= " << nb_noeud << "tab_N_final_final(i) ";
//
// for (int i=1;i<=nb_noeud;i++)
// cout << "\n proc 0: tab_N_final_final("<<i<<") : num_noeud= "<<tab_N_final_final(i)->Num_noeud()
// <<", t_noe("<<i<<") : num_noeud= " <<t_noe(i)->Num_noeud()
// <<", tab_N_final("<<i<<") : num_noeud= " <<tab_N_final(i)->Num_noeud()
// ;
// cout << flush;
// // il s'agit d'un procédé séquentiel,
// int nb_process = ParaGlob::Monde()->size();
// // NB: le process 0 c'est le main
// for (int i=1;i<nb_process;i++) // < absolu, donc le max c'est nb_process-1
// { // on envoie un signal de démarrage au process i
// int mess = i;
// ParaGlob::Monde()->send(i, 300001, mess);
// // et on attend du process i un signal de fin d'exécution
// std::string msg;
// ParaGlob::Monde()->recv(i, 2+300001, msg);
// // gestion d'erreur éventuelle
// if (msg == "erreur_en_lecture")
// // arrêt du traitement
// Sortie(1);
// };
// }
// else
// {std::string msg;
// int mess;
// ParaGlob::Monde()->recv(0, 300001, mess);
// if (mess==num_proc)
// {cout << "\n rebouclage :: proc "<<num_proc <<" : debug LesMaillages::Renumerotation "
// << " num_noeud= " << nb_noeud << "tab_N_final_final(i) ";
// for (int i=1;i<=nb_noeud;i++)
// cout << "\n i="<<i<<" : proc "<<num_proc<<" : " << tab_N_final_final(i)->Num_noeud()
// <<", t_noe("<<i<<") : num_noeud= " <<t_noe(i)->Num_noeud()
// <<", tab_N_final("<<i<<") : num_noeud= " <<tab_N_final(i)->Num_noeud()
// ;
// }
// cout << flush;
// // on envoie à 0 le message de fin de lecture
// ParaGlob::Monde()->send(0, 2+300001, std::string("OK"));
// };
// }
// #endif
// //------------ fin debug ---------
if (nouvelle_numerotation && (nb_casAssemb != NULL))
{
// on met à jour les pointeurs d'assemblage en suivant le nouvel ordre de noeud
MiseAJourPointeurAssemblage_interne(*nb_casAssemb,tab_N_final_final,false);
// on calcul la largeur finale
@ -2243,10 +2440,9 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
cout << "\n $$$ ==>> opti. glob. numerot. $$$ "
<< " 1/2 larg. ddl ==> " << demi
<< " larg. totale ==> " << total;
//cout << "\n entrer une valeur pour continuer ";
//int toto; cin >> toto;
};
// dans le cas d'une nouvelle numérotation + dans le cas où on veut un changement
// de numérotation effectif dans les noeuds
// ->> introduction de la nouvelle numérotation dans les noeuds et mise à jour des reférences
@ -2296,6 +2492,14 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
////--- fin debug
t_nv_num(noe->Num_Mail())(t_oldNumNoeud(ia))=noe->Num_noeud();
};
// #ifdef UTILISATION_MPI
// // on sauvegarde t_nv_num dans un std::vector<int> pour le transmette au proc i
// for (int iml=1; iml<= nbMaillageTotal;iml++)
// {int taille = tabMaillage(iml)->Nombre_noeud();
// for (int i=0;i<taille;i++)
// std_vector_t_nv_num[iml-1][i]=t_nv_num(iml)(i+1);
// };
// #endif
// 2) maintenant on change les références
for (int idmail=1;idmail<=nbMaillageTotal;idmail++)
lesRef.Mise_a_jour_ref_noeud(t_nv_num(idmail),idmail);
@ -2320,7 +2524,6 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
// on met une information sur la largeur de bande nouvelle, en noeud,
// qui découle de la nouvelle numérotation (et non de l'assemblage)
{
int largeur_finale_CLL = 0; // init
for (int i = 1; i<= taille_tab_cll;i++)
{ Tableau <Condilineaire>& condCLL = tab_condCLL(i);
@ -2332,8 +2535,6 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
{ cout << "\n pour l'ensemble des conditions linaires: la 1/2 largeur de bande en noeud, finale est "
<< largeur_finale_CLL << flush;
};
// non c'est débile, car on n'a pas fait de nouvelle numérotation en ddl, donc cela ne sert à rien de les imprimer
// et au niveau de la numérotation en noeud, c'est déja visualisé
@ -2385,9 +2586,6 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
<< flush;
*/
}
else // sinon c'est le cas où on veut changer les pointeurs d'assemblage
{// deuxième partie pour les pointeurs d'assemblage:
@ -2409,18 +2607,22 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
{MiseAJourTableau_t_i_n(*nb_casAssemb,tab_N_final_final);
};
};
}
}
else
{// on remet néanmoins l'ancienne numérotation, car elle a changé
int nbN = t_noe.Taille();
for (int i=1;i<=nbN;i++)
t_noe(i)->Change_num_noeud(t_oldNumNoeud(i));
if (ParaGlob::NiveauImpression() >= 3)
cout << "\n $$$ au final numerot. idem $$$ " << flush;
nouvelle_numerotation = false;
calcul_ok = true;
};
{// on remet néanmoins l'ancienne numérotation, car elle a changé
int nbN = t_noe.Taille();
for (int i=1;i<=nbN;i++)
t_noe(i)->Change_num_noeud(t_oldNumNoeud(i));
if (ParaGlob::NiveauImpression() >= 3)
cout << "\n $$$ au final numerot. idem $$$ " << flush;
nouvelle_numerotation = false;
calcul_ok = true;
};
////------------debug ---------
//cout << "\n proc 0 : debug LesMaillages::Renumerotation ";
//for (int i=1;i<=nb_noeud;i++)
// cout << "\n i= "<<i << ", " << t_noe(i)->Num_noeud();
////--------- fin debug
}
else
{// si Maillage::Point_de_depart n'a pas fonctionné correctement il faut remettre l'ancienne numérotation
@ -2430,6 +2632,222 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
for (int nue =1; nue<= nb_noeud; nue++)
t_noe(nue)->Change_num_noeud(t_oldNumNoeud(nue));
};
/*
#ifdef UTILISATION_MPI
// préparation du transfert
indic_result[0] = nouvelles_largeur_en_ddl.un;
indic_result[1] = nouvelles_largeur_en_ddl.deux;
indic_result[2] = nouvelles_largeur_en_ddl.trois;
indic_result[3] = sans_changement_num_noeud;
indic_result[4] = calcul_ok;
indic_result[5] = nouvelle_numerotation;
// for (int inoe=1;inoe <= nb_noeud; inoe++)
// vect_finalNumNoeud[inoe-1]= t_noe(inoe)->Num_noeud(); // pour le transfert
};
broadcast(*ParaGlob::Monde(), indic_result, 0);
// broadcast(*ParaGlob::Monde(), vect_tab_N_final_final, 0);
// broadcast(*ParaGlob::Monde(), li_tab_N_final_final, 0);
// broadcast(*ParaGlob::Monde(), std_vector_t_nv_num, 0);
// broadcast(*ParaGlob::Monde(), vect_finalNumNoeud, 0);
if (num_proc != 0)
{calcul_ok = indic_result[4];
if (calcul_ok)
{// on met la numérotation comme elle est dans le cas du proc 0
{ std::list<int>::iterator il,ilfin = li_newNumNoeud.end();
int i=1;
for (il = li_newNumNoeud.begin();il != ilfin;il++,i++)
{t_noe(i)->Change_num_noeud(*il);
};
};
// on refabrique le tableau tab_N_final_final
{tab_N_final_final.Change_taille(nb_noeud);
for (int i=0;i<nb_noeud;i++)
tab_N_final_final(i+1) = t_noe(t_noe(i+1)->Num_noeud());
// tab_N_final_final(i+1) = t_noe(vect_tab_N_final_final[i]);
};
//-------- debug ---------
cout << "\n rebouclage :: proc "<<num_proc <<" : debug LesMaillages::Renumerotation "
<< " num_noeud= " << nb_noeud << "tab_N_final_final(i) ";
for (int i=1;i<=nb_noeud;i++)
cout << "\n i="<<i<<" : proc "<<num_proc<<" : " << tab_N_final_final(i)->Num_noeud();
//--------- fin debug ---------
// on récupère les résultats du proc 0 les résultats globaux
nouvelles_largeur_en_ddl.un = indic_result[0];
nouvelles_largeur_en_ddl.deux = indic_result[1];
nouvelles_largeur_en_ddl.trois = indic_result[2];
sans_changement_num_noeud = indic_result[3];
nouvelle_numerotation = indic_result[5];
// ------ on suit le même type de cheminement que pour le proc 0 ----
// modif dans les maillages
if (nouvelle_numerotation && (nb_casAssemb != NULL))
// on met à jour les pointeurs d'assemblage en suivant le nouvel ordre de noeud
MiseAJourPointeurAssemblage_interne(*nb_casAssemb,tab_N_final_final,false);
// dans le cas d'une nouvelle numérotation + dans le cas où on veut un changement
// de numérotation effectif dans les noeuds
// ->> introduction de la nouvelle numérotation dans les noeuds et mise à jour des reférences
if ((nouvelle_numerotation) && (!sans_changement_num_noeud))
// il faut donc redéfinir une numérotation pour chaque maillage. Celle-ci
// ne sera pas aussi optimum que dans le cas d'un seul maillage, mais elle devrait
// être meilleure
// -- un tableau d'indice qui donne le nouveau numéro en cours pour chaque maillage
{ Tableau<int> num_noeu_par_maillage(nbMaillageTotal,0);
// un nouveau tableau intermédiaire tel que le noeud t_noe_ordonnee(i), a le numéro i
Tableau <Noeud *> t_noe_ordonnee(nb_noeud); // le tableau global de noeuds
for (int ia=1;ia <= nb_noeud; ia++)
{ Noeud* noe = t_noe(ia); // pour simplifier
t_noe_ordonnee(noe->Num_noeud()) = noe;
};
// si nouvelle numérotation est vrai, on parcourt le tableau et on renumérote à la volée
// la méthode revient à compresser la numérotation pour chaque maillage de manière a
// rester dans les limites du nombre de noeud pour chaque maillage
for (int ia=1;ia <= nb_noeud; ia++)
{ Noeud* noe = t_noe_ordonnee(ia); // pour simplifier
int num_mail = noe->Num_Mail();
num_noeu_par_maillage(num_mail)++;
noe->Change_num_noeud(num_noeu_par_maillage(num_mail));
};
// Maintenant on s'occupe des références et de la numérotation définitive
// si on a introduit une nouvelle numérotation
// -- on s'occupe des numéros de référence
// 1) on définit un tableau par maillage qui contient les nouveaux numéros
// t_nv_num(j)(i) est pour le maillage j, le nouveau numéro du noeud
// qui avait auparavant le numéro "i"
Tableau <Tableau <int> > t_nv_num(nbMaillageTotal); // nouveau num/ au ancien
for (int iml=1; iml<= nbMaillageTotal;iml++)
t_nv_num(iml).Change_taille(tabMaillage(iml)->Nombre_noeud()); // init
for (int ia=1;ia <= nb_noeud; ia++)
{ Noeud* noe = t_noe(ia); // pour simplifier, on utilise t_noe et non t_noe_ordonnee
// car ensuite on utilise t_oldNumNoeud qui suit le même ordre que t_noe
// //--debug
// cout << "\n debug LesMaillages::Renumerotation( "
// << "\n noe->Num_Mail()= "<<noe->Num_Mail() <<", ia= "<< ia
// << " noe->Num_noeud()= "<<noe->Num_noeud()
// << " t_oldNumNoeud(ia)= "<< t_oldNumNoeud(ia) << flush;
////--- fin debug
t_nv_num(noe->Num_Mail())(t_oldNumNoeud(ia))=noe->Num_noeud();
};
// // pour les proc i on utilise le tableau transmis
// for (int iml=1; iml<= nbMaillageTotal;iml++)
// {int taille = tabMaillage(iml)->Nombre_noeud();
// for (int i=0;i<taille;i++)
// t_nv_num(iml)(i+1) = std_vector_t_nv_num[iml-1][i];
// };
// 2) maintenant on change les références
for (int idmail=1;idmail<=nbMaillageTotal;idmail++)
lesRef.Mise_a_jour_ref_noeud(t_nv_num(idmail),idmail);
// --- on reconstruit les tableaux de pointeurs de noeuds dans chaque maillage
// a) on crée un tableau intermédiaire de tous les tableaux de noeuds
Tableau <Tableau <Noeud *> *> t_t_noeud(nbMaillageTotal);
for (int iml=1; iml<= nbMaillageTotal;iml++)
t_t_noeud(iml) = &(tabMaillage(iml)->Tab_noeud()); // init
// b) on le remplit
for (int ia=1;ia <= nb_noeud; ia++)
{ Noeud* noe = t_noe_ordonnee(ia); // pour simplifier
(*t_t_noeud(noe->Num_Mail()))(noe->Num_noeud()) = noe;
};
};
// éventuellement deuxième étape concernant le changement des pointeurs d'assemblage
if (nouvelle_numerotation)
{if (nb_casAssemb != NULL) // cas où on veut changer les pointeurs d'assemblage
{// deuxième partie pour les pointeurs d'assemblage:
// on doit mettre à jour le tableau t_i_n pour les pointeurs d'assemblage
// concernant uniquement les numéros de noeuds
// --> deux cas suivant que l'on ne veut pas enregistrer la nouvelle numérotation
// des noeuds ou non
if (sans_changement_num_noeud)
{ // mise à jour des numéros de noeud, on revient aux numéros initiaux
// on revient au numéro initiaux
for (int i=1;i<=nb_noeud;i++)
t_noe(i)->Change_num_noeud(t_oldNumNoeud(i));
// pour chaque noeud, tab_N_final(i) correspond au noeud qui avait le numéro i ancien
// et qui a maintenant le numéro tab_N_final(i)->Num_noeud()
// mise à jour de t_i_n
MiseAJourTableau_t_i_n(*nb_casAssemb,tab_N_final_final);
}
else
{MiseAJourTableau_t_i_n(*nb_casAssemb,tab_N_final_final);
};
};
}
else
{// on remet néanmoins l'ancienne numérotation, car elle a changé
int nbN = t_noe.Taille();
for (int i=1;i<=nbN;i++)
t_noe(i)->Change_num_noeud(t_oldNumNoeud(i));
nouvelle_numerotation = false;
calcul_ok = true;
};
////------------debug ---------
//cout << "\n proc 0 : debug LesMaillages::Renumerotation ";
//for (int i=1;i<=nb_noeud;i++)
// cout << "\n i= "<<i << ", " << t_noe(i)->Num_noeud();
////--------- fin debug
}; // fin du test if (num_proc != 0)
}
#endif
*/
////------------debug ---------
//#ifdef UTILISATION_MPI
//
// if (ParaGlob::Monde()->rank() == 0)
// {// on va demander successivement à tous les process d'afficher les nnuméros de pointeur d'assemblage
// // d'abord le proc 0
// cout << "\n proc 0 : fin debug LesMaillages::Renumerotation ";
//
// for (int i=1;i<=nb_noeud;i++)
// cout << "\n proc 0: pointeur assemblage à la fin i="<<i<<" : "<<t_noe(i)->PosiAssemb(nb_casAssemb->n)
// << ", num_noeud " << t_noe(i)->Num_noeud();
// // il s'agit d'un procédé séquentiel,
// // NB: je pense que c'est plus rapide et plus sûr de passer par le .info
// // pour construire et remplir dans chaque process la structure de stockage, que de le faire
// // en passant les données via mpi entre le master et les sous_process
// int nb_process = ParaGlob::Monde()->size();
// // NB: le process 0 c'est le main
// for (int i=1;i<nb_process;i++) // < absolu, donc le max c'est nb_process-1
// { // on envoie un signal de démarrage au process i
// int mess=i;
// ParaGlob::Monde()->send(i, 100006,mess); // et on attend du process i un signal de fin d'exécution
// std::string msg;
// ParaGlob::Monde()->recv(i, 2+100007, msg);
// // gestion d'erreur éventuelle
// if (msg == "erreur_en_lecture")
// // arrêt du traitement
// Sortie(1);
// };
// }
// else
// {std::string msg;
// int mess;
// ParaGlob::Monde()->recv(0, 100006, mess);
// if (mess==num_proc)
// {cout << "\n proc"<<num_proc<<" : fin LesMaillages::Renumerotation ";
// for (int i=1;i<=nb_noeud;i++)
// cout << "\n proc "<<num_proc<< ": pointeur assemblage à la fin i= "<<i<<" : "<<t_noe(i)->PosiAssemb(nb_casAssemb->n)
// << ", num_noeud " << t_noe(i)->Num_noeud();
// }
// // on envoie à 0 le message de fin de lecture
// ParaGlob::Monde()->send(0, 2+100007, std::string("OK"));
// };
// // arrivé ici tous les process ont sortie la numérotation d'assemblage
//// ----- debug ---
// cout << flush;
////--- fin debug
// ParaGlob::Monde()->barrier();
//#endif
////------------ fin debug ---------
// retour
return (calcul_ok && nouvelle_numerotation);

2
Parametres/EnteteParaGlob.h
View file

@ -41,7 +41,7 @@
EnumLangue ParaGlob::langueHZ = FRANCAIS; // langue utilisée pour les entrées sorties
int ParaGlob::nbComposantesTenseur = 1; // nombre de composantes par defaut a 1
int ParaGlob::nivImpression = 2; // niveau d'impression
string ParaGlob::nbVersion = "7.049" ; // numéro de version du logiciel
string ParaGlob::nbVersion = "7.050" ; // numéro de version du logiciel
string ParaGlob::NbVersionsurfichier = ""; // numéro de version lue en entrée fichier
int ParaGlob::nb_diggit_double_calcul= 17; // nombre de chiffre significatifs utilisé pour
// l'affichage des double précision pour l'archivage

6
References/LesReferences.cc
View file

@ -538,7 +538,7 @@ const Reference& LesReferences::Trouve(const string & st1,const string* nom_mail
// nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i"
// non_referencer(i) : = true signifie qu'il ne faut plus tenir compte de ce noeud
// = false indique qu'il continue d'être actif
void LesReferences::Mise_a_jour_ref_noeud(Tableau <int >& nv_tab,int num_mail,Tableau <bool>& non_referencer)
void LesReferences::Mise_a_jour_ref_noeud(const Tableau <int >& nv_tab,int num_mail,Tableau <bool>& non_referencer)
{ bool fr = ParaGlob::Francais(); // pour simplifier
// on vérifie le numéro de maillage
if ((num_mail < 0) || (num_mail > t_mapDeRef.Taille()))
@ -614,7 +614,7 @@ void LesReferences::Mise_a_jour_ref_noeud(Tableau <int >& nv_tab,int num_mail,Ta
// mise à jour des références de noeud, dans le cas où les numéros de noeuds ont changés
//2) cas où on considère tous les noeuds
// nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i"
void LesReferences::Mise_a_jour_ref_noeud(Tableau <int >& nv_tab,int num_mail)
void LesReferences::Mise_a_jour_ref_noeud(const Tableau <int >& nv_tab,int num_mail)
{ bool fr = ParaGlob::Francais(); // pour simplifier
// on vérifie le numéro de maillage
if ((num_mail < 0) || (num_mail > t_mapDeRef.Taille()))
@ -662,7 +662,7 @@ void LesReferences::Mise_a_jour_ref_noeud(Tableau <int >& nv_tab,int num_mail)
// nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i"
// non_referencer(i) : = true signifie qu'il ne faut plus tenir compte de cet élément
// = false indique qu'il continue d'être actif
void LesReferences::Mise_a_jour_ref_element(Tableau <int >& nv_tab,int num_mail,Tableau <bool>& non_referencer)
void LesReferences::Mise_a_jour_ref_element(const Tableau <int >& nv_tab,int num_mail,Tableau <bool>& non_referencer)
{ bool fr = ParaGlob::Francais(); // pour simplifier
// on vérifie le numéro de maillage
if ((num_mail < 0) || (num_mail > t_mapDeRef.Taille()))

6
References/LesReferences.h
View file

@ -185,17 +185,17 @@ class LesReferences
// nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i"
// non_referencer(i) : = true signifie qu'il ne faut plus tenir compte de ce noeud
// = false indique qu'il continue d'être actif
void Mise_a_jour_ref_noeud(Tableau <int >& nv_tab,int num_mail,Tableau <bool>& non_referencer);
void Mise_a_jour_ref_noeud(const Tableau <int >& nv_tab,int num_mail,Tableau <bool>& non_referencer);
//2) cas où on considère tous les noeuds
// nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i"
void Mise_a_jour_ref_noeud(Tableau <int >& nv_tab,int num_mail);
void Mise_a_jour_ref_noeud(const Tableau <int >& nv_tab,int num_mail);
// mise à jour des références d'élément, dans le cas où les numéros d'élément ont changés
//1) cas où l'on supprime éventuellement des éléments de la référence, qui ne sont plus référencé
// nv_tab est tel que : nv_tab(i) est le nouveau numéro qui avait auparavant le numéro "i"
// non_referencer(i) : = true signifie qu'il ne faut plus tenir compte de cet élément
// = false indique qu'il continue d'être actif
void Mise_a_jour_ref_element(Tableau <int >& nv_tab,int num_mail,Tableau <bool>& non_referencer);
void Mise_a_jour_ref_element(const Tableau <int >& nv_tab,int num_mail,Tableau <bool>& non_referencer);
// mise à jour du numéro de maillage d'une référence
void Mise_a_jour_num_maillage_ref(const string nom_ref, int old_num_maill, int new_num_maill)

45
contact/ElContact.cc
View file

@ -2097,6 +2097,13 @@ int ElContact::Actualisation()
#ifdef UTILISATION_MPI
// dans le cas // on ne continue que si la frontière est relative à un élément associé au cpu
Element & elem11 = *((*ta)(i)->PtEI()); // l'element qui contiend la frontiere
//---debug
if ((*ta)(i)->NumUnique() == 0)
{cout << "\n *** debug erreur ElContact::Actualisation "
<< ", num unique nul !! ";
(*ta)(i)->Affiche(1);
}
//--fin debug
// on ne continue que si l'élément est concerné
if (ParaGlob::param->Element_concerner(elem11.Num_maillage(),elem11.Num_elt_const()) )
{
@ -2138,13 +2145,15 @@ int ElContact::Actualisation()
// on commence par sauvegarder (*ta)(i) en créant une copie
Front* newelfront = new Front(*((*ta)(i)));
////----- debug
//if (newelfront->NumUnique()==0)
// {cout << "\ndebug Elcontact::Actualisation , ***** NumUnique est nulle !! erreur ";
// cout << "\n (*ta)(i)->Unique() = "<<(*ta)(i)->NumUnique();
// }
////----- fin debug
// Libere(); // on supprime le elfront actuel, donc le tableau ta
// //----- debug
// #ifdef UTILISATION_MPI
// if (newelfront->NumUnique()==0)
// {cout << "\ndebug Elcontact::Actualisation , ***** NumUnique est nulle !! erreur ";
// cout << "\n (*ta)(i)->Unique() = "<<(*ta)(i)->NumUnique();
// }
// #endif
// //----- fin debug
Libere(); // on supprime le elfront actuel, donc le tableau ta
// on ne peut pas supprimer le elfront, car il est également pointé par elfront_t
// du coup ce sera fait dans la méthode ElContact::TdtversT()
elfront = newelfront; // on récupére le nouvelle élément créé
@ -2189,6 +2198,14 @@ int ElContact::Actualisation()
{cout << " --> nevez ";
elfront->Affiche(1);
};
// //----- debug
// #ifdef UTILISATION_MPI
// if (newelfront->NumUnique()==0)
// {cout << "\ndebug Elcontact::Actualisation , ***** NumUnique est nulle !! erreur ";
// cout << "\n (*ta)(i)->Unique() = "<<(*ta)(i)->NumUnique();
// }
// #endif
// //----- fin debug
Construction_TabNoeud(); // on reconstruit le tableau de noeud global
nb_change_frontiere++; // on incrémente
intersec = 2;
@ -2231,6 +2248,14 @@ int ElContact::Actualisation()
{cout << " --> nevez ";
elfront->Affiche(1);
};
// //----- debug
// #ifdef UTILISATION_MPI
// if (newelfront->NumUnique()==0)
// {cout << "\ndebug Elcontact::Actualisation , ***** NumUnique est nulle !! erreur ";
// cout << "\n (*ta)(i)->Unique() = "<<(*ta)(i)->NumUnique();
// }
// #endif
// //----- fin debug
Construction_TabNoeud(); // on reconstruit le tableau de noeud global
nb_change_frontiere++; // on incrémente
@ -2298,6 +2323,12 @@ int ElContact::Actualisation()
{ bool mitoyen_valider = false;
#ifdef UTILISATION_MPI
//---debug
if ((*ta)(i)->NumUnique() == 0)
{cout << "\n *** debug erreur ElContact::Actualisation "
<< ", num unique nul !! ";
(*ta)(i)->Affiche(1);
}
// dans le cas // on ne continue que si la frontière est relative à un élément associé au cpu
Element & elem11 = *((*ta)(i)->PtEI()); // l'element qui contiend la frontiere
// on ne continue que si l'élément est concerné

316
contact/LesContacts.cc
View file

@ -235,8 +235,9 @@ void LesContacts::Init_contact(LesMaillages& lesMail
#ifdef UTILISATION_MPI
// on sauvegarde un pointeur sur les maillages
lesMaille = &lesMail;
int num_proc = ParaGlob::Monde()->rank();
if (ParaGlob::Monde()->rank() == 0)
if (num_proc == 0)
#endif
if (niveau_commentaire_lescontacts > 4)
cout << "\n -- LesContacts::Init_contact: ";
@ -268,7 +269,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
// on vérifie pour l'instant que c'est bien une fonction de grandeurs globales
if (pt_fonct->NbVariable_locale() != 0) // cas où il n'y a pas que des variables globales
#ifdef UTILISATION_MPI
{if (ParaGlob::Monde()->rank() == 0)
{if (num_proc == 0)
#endif
{ cout << "\n *** erreur dans la definition de la fonction nD de pilotage "
<< " du type de contact 4 : " << nom_fct4
@ -281,7 +282,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
#endif
else if (pt_fonct->NbComposante() > 2)
#ifdef UTILISATION_MPI
{if (ParaGlob::Monde()->rank() == 0)
{if (num_proc == 0)
#endif
{ cout << "\n *** erreur dans la definition de la fonction nD de pilotage "
<< " du type de contact 4 : " << nom_fct4
@ -297,7 +298,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
}
else
#ifdef UTILISATION_MPI
{if (ParaGlob::Monde()->rank() == 0)
{if (num_proc == 0)
#endif
{ cout << "\n *** erreur dans la definition de la fonction nD de pilotage "
<< " du type de contact 4 , le nom : " << nom_fct4
@ -336,7 +337,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
nbmailMaitre = ntmail-(nb_mail_Esclave-nbmailautocontact); // def du nombre de maillage maitres
// dans le cas d'auto-contact, on vérifie la cohérence
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
if (num_proc == 0)
#endif
if (nbmailautocontact != 0)
{if ((nbmailautocontact <1) || (nbmailautocontact > nb_mail_Esclave))
@ -355,7 +356,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
// on récupère le tableau indice
indice = ind;
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
if (num_proc == 0)
#endif
if (niveau_commentaire_lescontacts >2 )
cout << "\n >>>> Information : Initialisation du contact: ";
@ -387,7 +388,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
tesN_collant(ii)(1)(itai) = 0; // pas de contact collant car le contact est non restreint
};
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
if (num_proc == 0)
#endif
if (niveau_commentaire_lescontacts >2 )
cout << "\n mail. esclave "<<ii<<" : "<<taille << " noeuds esclaves pour contact ";
@ -404,7 +405,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
for (iMi = (*listFrontiere(jf)).begin();iMi != iMifin; iMi++)
lis_fronta.push_back((*iMi));
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
if (num_proc == 0)
#endif
if (niveau_commentaire_lescontacts >2 )
cout << "\n mail. maitre "<<ilistfront<<" : "<<lis_fronta.size()
@ -417,7 +418,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
list <Quatre_string_un_entier>::iterator il,ilfin=nom_ref_zone_contact.end();
int nb_zone = nom_ref_zone_contact.size();
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
if (num_proc == 0)
#endif
if (niveau_commentaire_lescontacts >2 )
cout << "\n --> nombre de zone de contact: " << nb_zone;
@ -435,7 +436,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
const Reference & ref = lesRef.Trouve((*il).nom2,nom_mail_noe);
// on continue que si c'est une référence de noeud
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
if (num_proc == 0)
#endif
if (ref.Indic() != 1)
{ // ce n'est pas normal -> message d'erreur
@ -470,7 +471,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
tesN_collant(intot)(izone)(no_dans_ref)= (*il).n;
}; // -- fin de la boucle sur les noeuds de la référence
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
if (num_proc == 0)
#endif
if (niveau_commentaire_lescontacts >2 )
cout << "\n maillage esclave "<<intot<< " : zone de contact: " << izone
@ -480,7 +481,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
}; // -- fin de la boucle sur intot c-a-d les maillages esclave
// message d'erreur si la zone n'a pas été définie
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
if (num_proc == 0)
#endif
if (!zone_definie)
{ cout << "\n *** erreur dans la construction de la zone de contact "<<izone
@ -516,7 +517,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
// on regarde si la référence existe
string nom_ref = (*il).nom4;
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
if (num_proc == 0)
#endif
if (!lesRef.Existe(nom_ref,nom_mail_face))
{ cout << "\n *** erreur la reference "<< nom_ref;
@ -574,7 +575,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
// ici la frontière peut-être n'importe quoi: point, arête, surface
// on vérifie que ce ne sont pas des ref Indic 5 ou 6 ou plus ou 1 ou 2
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
if (num_proc == 0)
#endif
{ cout << "\n *** erreur la reference de zone de frontiere de contact n'est pas "
<< " une reference acceptable ! "
@ -628,7 +629,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
}; //-- fin de la boucle sur les maillages maîtres
// petit message si nécessaire
#ifdef UTILISATION_MPI
if (ParaGlob::Monde()->rank() == 0)
if (num_proc == 0)
#endif
if (niveau_commentaire_lescontacts >2 ) //&& (list_fronta.size() > 0))
{ for (int i=1;i<= nb_zone;i++) // boucle sur les références de zone_contact
@ -659,7 +660,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
if (ta != NULL) // cas où il y a des éléments voisins !
{ const Tableau <Front*>& taa = *ta; // pour simplifier
int ta_taille = ta->Taille();
// Tableau <Front*> inter(ta_taille);// un tableau inter de travail
LaLIST_io <Front*> newmitoyen;// les mitoyens qui sont locaux
LaLIST_io <Front*> list_inter;
for (int i=1; i <= ta_taille; i++)
// on récupère l'élément ad hoc
@ -667,7 +668,7 @@ void LesContacts::Init_contact(LesMaillages& lesMail
if (froon == NULL)
// on n'a pas trouvé de front dans la même zone, on prépare la suppression dans les mitoyens
// on ne supprime pas tout de suite car cela va invalider la boucle actuelle
list_inter.push_back(taa(i));
{list_inter.push_back(taa(i));}
// if (froon != NULL)
// {list_inter.push_back(froon); } //inter(i)=froon;}
// modif pas de else car les mitoyens proviennent initialement de la liste générale venant de LesMaillages
@ -677,6 +678,9 @@ void LesContacts::Init_contact(LesMaillages& lesMail
// << " on n'a pas trouve dans la zone de contact une frontiere adequate : arret ";
// Sortie(1);
// };
else
// ok; donc froon est une frontière de la liste gérée localement on remplace dans mitoyen
newmitoyen.push_back(froon);
};
// maintenant on supprime éventuellement
if (list_inter.size())
@ -684,8 +688,10 @@ void LesContacts::Init_contact(LesMaillages& lesMail
for (iol=list_inter.begin();iol != iolfin;iol++)
fronta.SuppressionMitoyen(*iol);
};
// // on peut maintenant remplacer le tableau de mitoyen
// fronta.DefMitoyen(inter);
// on peut maintenant remplacer le tableau de mitoyen
Tableau <Front*> tabnewmitoyen;
tabnewmitoyen.Init_from_list(newmitoyen);
fronta.DefMitoyen(tabnewmitoyen);
};
};
};
@ -745,35 +751,75 @@ void LesContacts::Init_contact(LesMaillages& lesMail
};
};
};
// //--- debug
// {cout << "\n debug : LesContacts::Init_contact ";
// for (int i=1;i<=nbmailMaitre;i++)
// { for (int j=1;j<=nb_zone;j++)
// { LaLIST_io <Front> & list_fronta = (t_listFront(i)(j)); // pour simplifier
// LaLIST_io <Front>::iterator il,ilfin = list_fronta.end();
// for (il = list_fronta.begin();il != ilfin; il++)
// {if ((*il).NumUnique() == 0)
// cout << "\n debug : LesContacts::Init_contact "
// << " ***** erreur numunique == 0 !!" ;
// // maintenant on s'occupe des mitoyens
// {Front & fronta = (*il); // pour simplifier
// const Tableau <Front*>* ta = fronta.TabMitoyen(); // récup des mitoyens
// if (ta != NULL) // cas où il y a des éléments voisins !
// { const Tableau <Front*>& taa = *ta; // pour simplifier
// int ta_taille = ta->Taille();
// for (int i=1; i <= ta_taille; i++)
// {if (taa(i)->NumUnique() == 0)
// cout << "\n debug : LesContacts::Init_contact "
// << " ***** erreur dans les mitoyens : numunique == 0 !!" ;
// };
// };
// };
//
// };
// };
// };
// }
// //-- fin debug
//--- debug
#ifdef MISE_AU_POINT
{//cout << "\n debug : LesContacts::Init_contact ";
// la suite est redondante mais c'est pour voir où ça coince
for (int i=1;i<=nbmailMaitre;i++)
{ for (int j=1;j<=nb_zone;j++)
{ LaLIST_io <Front> & list_fronta = (t_listFront(i)(j)); // pour simplifier
LaLIST <Front>::iterator iM,iMfin=list_fronta.end();
for (iM = list_fronta.begin();iM != iMfin; iM++) // boucle sur les frontières enregistrées
{Front & fronta = (*iM); // pour simplifier
const Tableau <Front*>* ta = fronta.TabMitoyen(); // récup des mitoyens
if (ta != NULL) // cas où il y a des éléments voisins !
{ const Tableau <Front*>& taa = *ta; // pour simplifier
int ta_taille = ta->Taille();
LaLIST_io <Front*> list_inter;
for (int i=1; i <= ta_taille; i++)
// on récupère l'élément ad hoc
{Front* froon = Front_de_meme_origine(taa(i),j);
if (froon == NULL)
{cout << "\n debug : LesContacts::Init_contact ";
cout << "\n erreur on ne devrait pas arriver ici !! ";
}
else
{if (froon->NumUnique() == 0)
{cout << "\n debug : LesContacts::Init_contact ";
cout << "\n debug : LesContacts::Init_contact "
<< " ***** erreur numunique == 0 !!" ;
}
if (taa(i)->NumUnique() == 0)
{cout << "\n debug : LesContacts::Init_contact ";
cout << "\n debug : LesContacts::Init_contact "
<< " ***** erreur numunique == 0 !!" ;
}
}
};
};
};
};
};
for (int i=1;i<=nbmailMaitre;i++)
{ for (int j=1;j<=nb_zone;j++)
{ LaLIST_io <Front> & list_fronta = (t_listFront(i)(j)); // pour simplifier
LaLIST_io <Front>::iterator il,ilfin = list_fronta.end();
for (il = list_fronta.begin();il != ilfin; il++)
{if ((*il).NumUnique() == 0)
cout << "\n debug : LesContacts::Init_contact "
<< " ***** erreur numunique == 0 !!" ;
// maintenant on s'occupe des mitoyens
{Front & fronta = (*il); // pour simplifier
const Tableau <Front*>* ta = fronta.TabMitoyen(); // récup des mitoyens
if (ta != NULL) // cas où il y a des éléments voisins !
{ const Tableau <Front*>& taa = *ta; // pour simplifier
int ta_taille = ta->Taille();
for (int i=1; i <= ta_taille; i++)
{if (taa(i)->NumUnique() == 0)
cout << "\n debug : LesContacts::Init_contact "
<< " ***** erreur dans les mitoyens : numunique == 0 !!" ;
};
};
};
};
};
};
}
#endif
//-- fin debug
#endif
@ -915,7 +961,7 @@ bool LesContacts::DefElemCont(double dep_max)
// on met à jour le déplacement maxi toléré pour la classe ElContact
double coef_mult_dep_max = 2.; // comme un noeud peut se déplacer de dep_max et que l'on
double dep_max_pratique = coef_mult_dep_max * dep_max;
// peut avoir la cible "et" le noeud qui se déplace de dep_max, on doit considérer 2*dep_max
// on peut avoir la cible "et" le noeud qui se déplace de dep_max, on doit considérer 2*dep_max
// on met à jour le déplacement maxi pour la class
ElContact::Change_dep_max(dep_max_pratique);
int nb_zone = MaX(1,nom_ref_zone_contact.size());
@ -1037,12 +1083,14 @@ bool LesContacts::DefElemCont(double dep_max)
if (plus_en_avant)
// on teste alors plus précisemment
{// constitution d'un element de contact intermediaire
// NB: le front initial est choisit identique au front
ElContact elcont(&(*iM),tesc(inesc),fct_nD_contact,&(*iM),tesN_col(inesc));
elcont.Num_zone_contact()=j_zone; // affectation du numéro de zone
elcont.Change_lissage_normale(lissage_de_la_normale(j_zone)); // affectation du lissage
#ifdef UTILISATION_MPI
// on attribue au front de l'élément de contact, le numéro unique utilisable pour le tableau pointe_t_listFront
elcont.Elfront()->ChangeNumUnique((*iM).NumUnique());
elcont.Elfront_initiale()->ChangeNumUnique((*iM).NumUnique());
#endif
// calcul du contact, et translation (éventuelle) du noeud sur la surface si le contact existe
bool init_inter = true; // on est en phase d'initialisation
@ -1209,11 +1257,12 @@ bool LesContacts::DefElemCont(double dep_max)
{
if (niveau_commentaire_lescontacts > 4) // ==> LesContacts::
#else
if (niveau_commentaire_lescontacts > 2) // ==> LesContacts::
if (niveau_commentaire_lescontacts > 4) // ==> LesContacts::
#endif
{
{Calcul_Nb_contact_actif();
#ifdef UTILISATION_MPI
cout << "\n proc " << proc_en_cours
cout << "\n >>>>>> proc " << proc_en_cours
#else
cout << "\n"
#endif
@ -1222,15 +1271,24 @@ bool LesContacts::DefElemCont(double dep_max)
cout <<", "<< listContact_nouveau_tatdt.size() << " nouveau(x) ";
if (listContact_efface_tatdt.size())
cout <<", "<<listContact_efface_tatdt.size() << " effacement(s) ";
cout << ", nb_contact_actif= " << nb_contact_actif << flush;
if (niveau_commentaire_lescontacts > 5)
{LaLIST<ElContact>::iterator ipp,ippfin=listContact.end();
for (ipp=listContact.begin();ipp != ippfin; ipp++)
{(*ipp).Affiche(2);};
cout << " fin liste ";
};
cout << flush;
};
#ifdef UTILISATION_MPI
};
if (proc_en_cours != 0) // on transmet à proc 0
{temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
Calcul_Nb_contact_actif();
// pour cela on va utiliser un conteneur intermédiaire
QuatreEntiers inter_entiers(retour,listContact.size(),listContact_nouveau_tatdt.size(),listContact_efface_tatdt.size());
CinqEntiers inter_entiers(retour,listContact.size(),listContact_nouveau_tatdt.size(),listContact_efface_tatdt.size(),nb_contact_actif);
// on transmet les infos au proc 0
mpi::request reqs1 = ParaGlob::Monde()->isend(0, 61, inter_entiers);
// on attend pas
@ -1240,36 +1298,50 @@ bool LesContacts::DefElemCont(double dep_max)
{// l'objectif ici est de récupérer les infos
tempsContact.Arret_du_comptage(); // fin cpu
int nb_contact=0;int nb_new_contact = 0;int nb_efface_contact = 0; // que l'on va cumuler
int nb_actif=0;
int nb_proc_terminer = 0; // permettra de terminer
while (nb_proc_terminer < (ParaGlob::Monde()->size()-1))
{ // on récupère un résultat de cpu i
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
QuatreEntiers inter_entiers;
CinqEntiers inter_entiers;
mpi::request reqs1 = ParaGlob::Monde()->irecv(mpi::any_source, 61, inter_entiers );
reqs1.wait(); // on attend que le conteneur soit rempli
// on cumule
nb_contact += inter_entiers.deux;
nb_new_contact += inter_entiers.trois;
nb_efface_contact += inter_entiers.quatre;
nb_actif += inter_entiers.cinq;
if (inter_entiers.un) // si un seul des retour s est bon on passe à true
retour = true;
nb_proc_terminer++; // on prend en compte que l'on a récupéré un conteneur
};
if (niveau_commentaire_lescontacts > 2) // ==> LesContacts::
if (niveau_commentaire_lescontacts > 2) // ==> LesContacts::
{cout << "\n apres Def Elem Cont: "<< nb_contact << " elem contact ";
if ( nb_new_contact)
cout <<", "<< nb_new_contact << " nouveau(x) ";
if (nb_efface_contact)
cout <<", "<<nb_efface_contact << " effacement(s) ";
cout << flush;
cout << ", nb_contact_actif= " << nb_actif << flush;
};
};
// il faut que tous les proc aient le retour global, car le retour sert dans l'algo général
broadcast(*ParaGlob::Monde(), retour, 0);
// #else
// Calcul_Nb_contact_actif();
// if (niveau_commentaire_lescontacts > 2) // ==> LesContacts::
// {cout << "\n apres Def Elem Cont: "<< nb_contact << " elem contact ";
// if ( nb_new_contact)
// cout <<", "<< nb_new_contact << " nouveau(x) ";
// if (nb_efface_contact)
// cout <<", "<<nb_efface_contact << " effacement(s) ";
// cout << ", nb_contact_actif= " << nb_contact_actif << flush;
// };
#endif
tempsContact.Arret_du_comptage(); // fin cpu
@ -1711,12 +1783,14 @@ bool LesContacts::Nouveau(double dep_max)
};
// on ne continue que s'il n'existe pas d'élément de contact du même type
if (creation)
{ ElContact elcont(&(*iM),tesc(inesc),fct_nD_contact,&(*iM));
{ // NB: le front initial est choisit identique au front
ElContact elcont(&(*iM),tesc(inesc),fct_nD_contact,&(*iM));
elcont.Num_zone_contact()=j_zone; // affectation du numéro de zone
elcont.Change_lissage_normale(lissage_de_la_normale(j_zone)); // affectation du lissage
#ifdef UTILISATION_MPI
// on attribue au front de l'élément de contact, le numéro unique utilisable pour le tableau pointe_t_listFront
elcont.Elfront()->ChangeNumUnique((*iM).NumUnique());
elcont.Elfront_initiale()->ChangeNumUnique((*iM).NumUnique());
#endif
// vérification que l'on a bien les frontières bien connectées
@ -1821,7 +1895,7 @@ bool LesContacts::Nouveau(double dep_max)
#endif
{
#ifdef UTILISATION_MPI
cout << "\n proc " << proc_en_cours
cout << "\n >>>> proc " << proc_en_cours
#else
cout << "\n "
#endif
@ -1831,6 +1905,7 @@ bool LesContacts::Nouveau(double dep_max)
<< " nouveau(x) ";
if (listContact_efface_tatdt.size())
cout <<", "<<listContact_efface_tatdt.size() << " effactement(s) ";
cout << ", nb_contact_actif= " << nb_contact_actif << flush;
};
if (niveau_commentaire_lescontacts > 4)
// on va lister les éléments de contact
@ -1863,9 +1938,11 @@ bool LesContacts::Nouveau(double dep_max)
#ifdef UTILISATION_MPI
if (proc_en_cours != 0) // on transmet à proc 0
{temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
Calcul_Nb_contact_actif();
// pour cela on va utiliser un conteneur intermédiaire
QuatreEntiers inter_entiers(retour,listContact.size(),listContact_nouveau_tatdt.size(),listContact_efface_tatdt.size());
CinqEntiers inter_entiers(retour,listContact.size(),listContact_nouveau_tatdt.size()
,listContact_efface_tatdt.size(),nb_contact_actif);
// on transmet les infos au proc 0
mpi::request reqs1 = ParaGlob::Monde()->isend(0, 62, inter_entiers);
// on attend pas
@ -1875,18 +1952,20 @@ bool LesContacts::Nouveau(double dep_max)
{// l'objectif ici est de récupérer les infos
tempsContact.Arret_du_comptage(); // fin cpu
int nb_contact=0;int nb_new_contact = 0;int nb_efface_contact = 0; // que l'on va cumuler
int nb_actif=0;
int nb_proc_terminer = 0; // permettra de terminer
while (nb_proc_terminer < (ParaGlob::Monde()->size()-1))
{ // on récupère un résultat de cpu i
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
QuatreEntiers inter_entiers;
CinqEntiers inter_entiers;
mpi::request reqs1 = ParaGlob::Monde()->irecv(mpi::any_source, 62, inter_entiers );
reqs1.wait(); // on attend que le conteneur soit rempli
// on cumule
nb_contact += inter_entiers.deux;
nb_new_contact += inter_entiers.trois;
nb_efface_contact += inter_entiers.quatre;
nb_actif += inter_entiers.cinq;
if (inter_entiers.un) // si un seul des retour s est bon on passe à true
retour = true;
@ -1900,11 +1979,23 @@ bool LesContacts::Nouveau(double dep_max)
cout <<", "<< nb_new_contact << " nouveau(x) ";
if (nb_efface_contact)
cout <<", "<<nb_efface_contact << " effacement(s) ";
cout << ", nb_contact_actif= " << nb_actif << flush;
cout << flush;
};
};
// il faut que tous les proc aient le retour global, car le retour sert dans l'algo général
broadcast(*ParaGlob::Monde(), retour, 0);
// #else
// Calcul_Nb_contact_actif();
// if (niveau_commentaire_lescontacts > 3) // ==> LesContacts::
// {cout << "\n en fin de LesContacts::Nouveau: bilan: "<< nb_contact << " elem(s) contact ";
// if ( nb_new_contact)
// cout <<", "<< nb_new_contact << " nouveau(x) ";
// if (nb_efface_contact)
// cout <<", "<<nb_efface_contact << " effacement(s) ";
// cout << ", nb_contact_actif= " << nb_contact_actif << flush;
// cout << flush;
// };
#endif
@ -2391,6 +2482,58 @@ bool LesContacts::Actualisation(int choix)
{
tempsContact.Mise_en_route_du_comptage(); // def deb compt
bool retour = false; // init par défaut
#ifdef UTILISATION_MPI
//--- debug
/* {cout << "\n debug : début LesContacts::Actualisation ";
int nb_zone = MaX(1,nom_ref_zone_contact.size());
for (int i=1;i<=nbmailMaitre;i++)
{ for (int j=1;j<=nb_zone;j++)
{ LaLIST_io <Front> & list_fronta = (t_listFront(i)(j)); // pour simplifier
LaLIST_io <Front>::iterator il,ilfin = list_fronta.end();
for (il = list_fronta.begin();il != ilfin; il++)
{if ((*il).NumUnique() == 0)
cout << "\n debug : LesContacts::Actualisation "
<< " ***** erreur numunique == 0 !!" ;
// maintenant on s'occupe des mitoyens
{Front & fronta = (*il); // pour simplifier
const Tableau <Front*>* ta = fronta.TabMitoyen(); // récup des mitoyens
if (ta != NULL) // cas où il y a des éléments voisins !
{ const Tableau <Front*>& taa = *ta; // pour simplifier
int ta_taille = ta->Taille();
for (int i=1; i <= ta_taille; i++)
{if (taa(i)->NumUnique() == 0)
cout << "\n debug : LesContacts::Actualisation "
<< " ***** erreur dans les mitoyens : numunique == 0 !!" ;
};
};
};
};
};
};
LaLIST <ElContact>::iterator iE,iEfin=listContact.end();
for (iE = listContact.begin(); iE !=iEfin; iE++)//,iden++)
// on vérifie les frontières: le num unique
{Front * elfront = (*iE).Elfront();
if (elfront->NumUnique() == 0)
cout << "\n debug : LesContacts::Actualisation "
<< " ***** erreur numunique == 0 !!" ;
const Tableau <Front*>* ta = elfront->TabMitoyen();
if (ta != NULL) // cas où il y a des éléments voisins !
{ const Tableau <Front*>& taa = *ta; // pour simplifier
int ta_taille = ta->Taille();
for (int i=1; i <= ta_taille; i++)
{if (taa(i)->NumUnique() == 0)
cout << "\n debug : LesContacts::Actualisation "
<< " ***** erreur dans les mitoyens : numunique == 0 !!" ;
};
};
}
} */
//-- fin debug
#endif
#ifdef UTILISATION_MPI
int proc_en_cours = ParaGlob::Monde()->rank();
if (proc_en_cours != 0)
@ -2637,6 +2780,36 @@ bool LesContacts::Actualisation(int choix)
#ifdef UTILISATION_MPI
// il faut que tous les proc aient le retour global, car le retour sert dans l'algo général
broadcast(*ParaGlob::Monde(), retour, 0);
//--- debug
#ifdef MISE_AU_POINT
{//cout << "\n debug : LesContacts::Actualisation ";
int nb_zone = MaX(1,nom_ref_zone_contact.size());
for (int i=1;i<=nbmailMaitre;i++)
{ for (int j=1;j<=nb_zone;j++)
{ LaLIST_io <Front> & list_fronta = (t_listFront(i)(j)); // pour simplifier
LaLIST_io <Front>::iterator il,ilfin = list_fronta.end();
for (il = list_fronta.begin();il != ilfin; il++)
{if ((*il).NumUnique() == 0)
cout << "\n debug : LesContacts::Actualisation "
<< " ***** erreur numunique == 0 !!" ;
// maintenant on s'occupe des mitoyens
Front & fronta = (*il); // pour simplifier
const Tableau <Front*>* ta = fronta.TabMitoyen(); // récup des mitoyens
if (ta != NULL) // cas où il y a des éléments voisins !
{ const Tableau <Front*>& taa = *ta; // pour simplifier
int ta_taille = ta->Taille();
for (int i=1; i <= ta_taille; i++)
{if (taa(i)->NumUnique() == 0)
cout << "\n debug : LesContacts::Actualisation "
<< " ***** erreur dans les mitoyens : numunique == 0 !!" ;
};
};
};
};
};
}
#endif
//-- fin debug
#endif
// retour
@ -2824,13 +2997,26 @@ void LesContacts::CalculReaction(Vecteur& residu,bool& decol,const Nb_assemb& ca
if (niveau_commentaire_lescontacts > 5)
{if ((contact_type==1)||(contact_type==3))
{cout << "\n LesContacts::CalculReaction >> Details: residu totale = contact + CL + F_int (noeud:" << noe->Num_noeud()
<< " maillage:"<< noe->Num_Mail() << ")\nR=" << force << " gapTDT= " << (*iE).Gaptdt()
<< "\n dont F_contact= "<< (*iE).Force_contact() ;
{
#ifdef UTILISATION_MPI
cout << "\n proc " << proc_en_cours<<": "
#else
cout << "\n"
#endif
<< " LesContacts::CalculReaction >> Details: residu totale = contact + CL + F_int (noeud:" << noe->Num_noeud()
<< " maillage:"<< noe->Num_Mail() << ")\nR=" << force << " gapTDT= " << (*iE).Gaptdt()
<< "\n dont F_contact= "<< (*iE).Force_contact() ;
cout << "\n noeud: coor_tdt: "<<noe->Coord2() <<"\n delta: "<<(noe->Coord2()-noe->Coord1());
}
else if ((contact_type == 2) || (contact_type == 4)|| (contact_type == 41)|| (contact_type == 42))
{cout << "\n LesContacts::CalculReaction >> Details: F_contact (noeud:" << noe->Num_noeud()
{
#ifdef UTILISATION_MPI
cout << "\n proc " << proc_en_cours<<": "
#else
cout << "\n"
#endif
<< " LesContacts::CalculReaction >> Details: F_contact (noeud:" << noe->Num_noeud()
// 19 juin 2018 << " maillage:"<< noe->Num_Mail() << ")\nF=" << force << " gapTDT= " << (*iE).Gaptdt() ;
<< " maillage:"<< noe->Num_Mail() << ")\nForce= " << (*iE).Force_contact()
<< " gapTDT= " << (*iE).Gaptdt() ;

26
contact/LesContacts_2.cc
View file

@ -44,9 +44,9 @@
// idem au niveau de l'élément
template <class T>
void LesContacts::Lec_base_info_LesContacts(istream& ent
,T& instance // l'instance qui permet d'appeler les pointeurs de fonctions
,Noeud& (T::*RecupNoeud)(int i, int j) const
,Element& (T::*RecupElement_LesMaille)(int i, int j) const)
,T& instance // l'instance qui permet d'appeler les pointeurs de fonctions
,Noeud& (T::*RecupNoeud)(int i, int j) const
,Element& (T::*RecupElement_LesMaille)(int i, int j) const)
{
bool mono_proc_on_lit_un_BI_multiProc = false;
int taille=0; // taille par défaut
@ -120,7 +120,7 @@ void LesContacts::Lec_base_info_LesContacts(istream& ent
listContact.erase(iiE); // efface l'element
};
};
Tableau <int> compteur_inesc(nb_mail_Esclave,1); // compteur de compteur de noeuds esclaves
Tableau <int> compteur_inesc(nb_mail_Esclave,1); // compteur de compteur de noeuds esclaves
// on initialise la liste des éléments en contact
// listContact.clear(); // comme on redémarre, on efface la situation actuelle
@ -163,7 +163,7 @@ void LesContacts::Lec_base_info_LesContacts(istream& ent
// le nombre de maillages esclave et en auto-contact, peut-être redéfinit lors d'un restart
// donc n'est pas sauvegardé
if (numMail_esclave <= nb_mail_Esclave)
{ Noeud& no = (instance.*RecupNoeud)(numMail_esclave, numNoeud_esclave); // ""
{ Noeud& no = (instance.*RecupNoeud)(numMail_esclave, numNoeud_esclave); // ""
// --- création de la frontière
Element& elem = (instance.*RecupElement_LesMaille)(numMail_element,num_element);
ElFrontiere* elfr;
@ -270,6 +270,19 @@ void LesContacts::Lec_base_info_LesContacts(istream& ent
// dans le cas // on ne continue que si l'élément de contact est relatif à un élément associé au cpu
if ((ParaGlob::param->Element_concerner(numMail_element,num_element )))
#endif
{// on s'occupe d'abord de la frontière initiale
if (trouver_0)
{// on met à jour les mitoyens pour froont_0
// definition des elements mitoyens à partir du front enregistré qui lui contient les mitoyens
// qui ont été créé à l'initialisation
if (froant_0->TabMitoyen() != NULL)
courant.Elfront_initiale()->DefMitoyen(*(froant_0->TabMitoyen()));
#ifdef UTILISATION_MPI
// on attribue au front de l'élément de contact, le numéro unique utilisable pour le tableau pointe_t_listFront
courant.Elfront_initiale()->ChangeNumUnique(froant_0->NumUnique());
#endif
};
// puis la frontière courante
if (trouver)
{// on met à jour les mitoyens
// definition des elements mitoyens à partir du front enregistré qui lui contient les mitoyens
@ -306,7 +319,8 @@ void LesContacts::Lec_base_info_LesContacts(istream& ent
tesN_encontact(numMail_esclave)[(*ipp).Esclave()].push_front(listContact.begin());
};
};
} // fin de l'ajout d'un élément de contact
};
} // fin de l'ajout d'un élément de contact
else
{if (ParaGlob::NiveauImpression() > 0)
cout << "\n *** attention, le maillage "<<numMail_esclave<<" n'est plus esclave !"

29
contact/LesContacts_3.cc
View file

@ -2012,6 +2012,15 @@ DeuxDoubles LesContacts::Forces_contact_maxi(bool affiche)
if (iTmax != ilbegin ){cout << "\n maxi F_T : "; (*iTmax).Affiche(1);};
cout << "\n ";
}
#endif
////-------- debug ------
// cout << "\n debug LesContacts::Forces_contact_maxi( ";
// {if (iNmin != ilbegin ){cout << "\n mini F_N : "; (*iNmin).Affiche(0);};
// if (iNmax != ilbegin ){cout << "\n maxi F_N : "; (*iNmax).Affiche(0);};
// if (iTmax != ilbegin ){cout << "\n maxi F_T : "; (*iTmax).Affiche(0);};
// cout << "\n ";
// }
////-------- fin debug ------
// cout << "\n contact: reaction ==> F_N max " << retour.un << " F_T max " << retour.deux;
// if (niveau_commentaire_lescontacts > 6)
@ -2024,7 +2033,6 @@ DeuxDoubles LesContacts::Forces_contact_maxi(bool affiche)
// if (iTmax != itbegin) {cout << "\n F_T max: "; (*iTmax).Affiche(1);};
// cout << "\n";
// };
#endif
tempsContact.Arret_du_comptage(); // fin cpu
}
#ifdef UTILISATION_MPI
@ -3203,11 +3211,30 @@ Front* LesContacts::Front_de_meme_origine(Front* fro, int zone) const
xinter.n[0] = (*il).Esclave()->Num_Mail(); xinter.n[1] = (*il).Esclave()->Num_noeud();
v_interProc_contact_actif(rang) = xinter.x;rang++;
xinter.n[0] = (*il).Elfront()->NumUnique(); xinter.n[1] = (*il).Const_Num_zone_contact();
//---debug
#ifdef MISE_AU_POINT
if (xinter.n[0] == 0)
{cout << "\n *** debug erreur LesContacts::Mise_a_jour_liste_contacts_actif_interProc "
<< " proc "<< proc_en_cours << ", num unique nul !! ";
(*il).Affiche(1);
}
#endif
//--fin debug
v_interProc_contact_actif(rang) = xinter.x;rang++;
xinter.n[0] = (*il).Lissage_normale(); xinter.n[1] = (*il).Collant();
v_interProc_contact_actif(rang) = xinter.x;rang++;
xinter.n[0] = (*il).Elfront_initiale()->NumUnique(); xinter.n[1] = 0; // xinter.n[1] ne sert pas ici
v_interProc_contact_actif(rang) = xinter.x;rang++;
//---debug
#ifdef MISE_AU_POINT
if (xinter.n[0] == 0)
{cout << "\n *** debug erreur LesContacts::Mise_a_jour_liste_contacts_actif_interProc "
<< " proc "<< proc_en_cours << ", num unique _zero est nul !! ";
(*il).Affiche(1);
}
#endif
//--fin debug
};
// on transmet à proc 0

1098
tenseurs_mai99/Coordonnees/Coordonnee.cc
View file

File diff suppressed because it is too large Load diff

38
tenseurs_mai99/Coordonnees/Coordonnee.h
View file

@ -132,8 +132,10 @@ class Coordonnee
// constructeur fonction d'une adresse memoire ou sont stockee les coordonnees
// et d'une dimension ( l'existance de la place mémoire est a la charge
// de l'utilisateur et ne sera pas détruite par le destructeur.)
// de même il n'y aura pas de redimentionnement possible
*/
Coordonnee (int dimension,double* t);
// Constructeur fonction d'un vecteur qui doit avoir une dim = 1 ou 2 ou 3
// on supprime car il y a plein de conversion n'ont explicite, le mieux est d'utiliser
// l'opérateur Vect(), qui permet "explicitement" de créer un coordonnée et ensuite d'utiliser
@ -145,19 +147,21 @@ class Coordonnee
//// Construit(const Vecteur& vec);
/// Constructeur de copie
// mais là on construit systématiquement un vrai coordonnée
// même si c.memoire est faux, car on ne veut pas que plusieur
// coordonnée pointes sur les mêmes valeurs, sans précautions supplémentaires
Coordonnee (const Coordonnee& c);
/// DESTRUCTEUR :
// dans le cas où la mémoire n'est pas gérée localement -> aucune action
virtual ~Coordonnee ();
// METHODES :
/*! \brief
// fonction équivalente au constructeur: changement pour une place externe via un pointeur
// ( l'existance de la place mémoire est a la charge
// de l'utilisateur et ne sera pas détruite par le destructeur.)
*/
void Change_place(int dimension,double* t);
// // fonction équivalente au constructeur: changement pour une place externe via un pointeur
// // ( l'existance de la place mémoire est a la charge
// // de l'utilisateur et ne sera pas détruite par le destructeur.)
// void Change_place(int dimension,double* t);
// changement des coordonnees
// rapide si c'est la même dimension !!
@ -170,7 +174,10 @@ class Coordonnee
/// Renvoie le nombre de coordonnees
virtual int Dimension () const ;
/// Desallocation de la place memoire allouee
/// uniquement dans le cas où la mémoire est gérée localement
/// sinon aucune action
virtual void Libere ();
/// Renvoie la ieme coordonnee
virtual double& operator() (int i);
@ -194,7 +201,7 @@ class Coordonnee
/// Surcharge de l'operateur -=
void operator-= (const Coordonnee& c);
/// Surcharge de l'operateur *=
void operator*= (double val);
virtual void operator*= (double val);
/// Surcharge de l'operateur * : multiplication de coordonnees par un scalaire
Coordonnee operator* (double val) const;
/// Surcharge de l'operateur * : produit scalaire entre coordonnees
@ -234,6 +241,7 @@ class Coordonnee
// changement de la dimension
// dans le cas d'une nouvelle dimension inferieur on supprime les dernieres coord
// dans le cas d'une dimension superieur, on ajoute des coord initialisees a zero
// NB: possible uniquement si la mémoire est gérée localement
*/
virtual void Change_dim(int dim);
/// création d'un Vecteur équivalent
@ -366,6 +374,7 @@ class CoordonneeH
CoordonneeH (const CoordonneeH& c);
/// DESTRUCTEUR :
// dans le cas où la mémoire n'est pas gérée localement -> aucune action
virtual ~CoordonneeH ();
// METHODES :
@ -380,7 +389,10 @@ class CoordonneeH
/// Renvoie le nombre de coordonnees
virtual int Dimension () const ;
/// Desallocation de la place memoire allouee
/// Desallocation de la place memoire allouee
/// uniquement dans le cas où la mémoire est gérée localement
/// sinon aucune action
virtual void Libere ();
/// Renvoie la ieme coordonnee
virtual double& operator() (int i);
@ -441,6 +453,7 @@ class CoordonneeH
// changement de la dimension
// dans le cas d'une nouvelle dimension inferieur on supprime les dernieres coord
// dans le cas d'une dimension superieur, on ajoute des coord initialisees a zero
// NB: possible uniquement si la mémoire est gérée localement
*/
virtual void Change_dim(int dim);
/// création d'un Vecteur équivalent
@ -559,6 +572,7 @@ class CoordonneeB
CoordonneeB (const CoordonneeB& c);
/// DESTRUCTEUR :
// dans le cas où la mémoire n'est pas gérée localement -> aucune action
virtual ~CoordonneeB ();
// METHODES :
@ -574,7 +588,10 @@ class CoordonneeB
/// Renvoie le nombre de coordonnees
virtual int Dimension () const ;
/// Desallocation de la place memoire allouee
/// Desallocation de la place memoire allouee
/// uniquement dans le cas où la mémoire est gérée localement
/// sinon aucune action
virtual void Libere ();
/// Renvoie la ieme coordonnee
virtual double& operator() (int i);
@ -637,6 +654,7 @@ class CoordonneeB
// changement de la dimension
// dans le cas d'une nouvelle dimension inferieur on supprime les dernieres coord
// dans le cas d'une dimension superieur, on ajoute des coord initialisees a zero
// NB: possible uniquement si la mémoire est gérée localement
*/
virtual void Change_dim(int dim);
/// conversion en Vecteur
@ -696,7 +714,7 @@ class CoordonneeB
protected :
short int dim;
bool memoire; // indique s'il y a allocation ou pas
bool memoire; // indique s'il y a allocation ou pas
double* coord;
// Constructeur inline qui ne fait rien
CoordonneeB (bool ):dim (-1) , coord (NULL),memoire(true) {};

211
tenseurs_mai99/Coordonnees/Coordonnee1.cc
View file

@ -51,8 +51,8 @@ using namespace std; //introduces namespace std
#endif
Coordonnee1::Coordonnee1 () :
Coordonnee(1,coord1)
{ coord1[0] = 0.;
};
{ coord1[0] = 0.;
};
// Constructeur suivant un booleen
// quelque soit la valeur du booleen il n'y a pas initialisation des coordonnées
@ -69,8 +69,8 @@ Coordonnee1::Coordonnee1 (bool ):
#endif
Coordonnee1::Coordonnee1 (double x):
Coordonnee(1,coord1)
// Constructeur pour un point a deux dimensions
{ coord1[0]=x;
// Constructeur pour un point a une dimension
{ coord1[0]=x;
};
// constructeur fonction d'une adresse memoire ou sont stockee les coordonnees
@ -82,7 +82,7 @@ Coordonnee1::Coordonnee1 (double x):
Coordonnee1::Coordonnee1 (double* t):
Coordonnee(1,coord1)
{ coord1[0]=t[0];
};
};
// Constructeur de copie
#ifndef MISE_AU_POINT
@ -99,13 +99,13 @@ Coordonnee1::Coordonnee1 (const Coordonnee1& c):
#endif
Coordonnee1::Coordonnee1 (const Coordonnee& c):
Coordonnee(1,coord1)
{
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 1)
{ cout << "\nErreur la dimension de c est différente de 1 !! !\n";
cout << "Coordonnee1::Coordonnee1 (const Coordonnee& c) \n";
Sortie(1);
}
if (c.Dimension () != 1)
{ cout << "\nErreur la dimension de c " << c.Dimension() << " est différente de 1 !! !\n";
cout << "Coordonnee1::Coordonnee1 (const Coordonnee& c) \n";
Sortie(1);
}
#endif
coord1[0]=c(1);
};
@ -116,24 +116,27 @@ Coordonnee1::Coordonnee1 (const Coordonnee& c):
#endif
Coordonnee1::~Coordonnee1 ()
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
coord=NULL;
#endif
#ifdef MISE_AU_POINT
// memoire étant false on met coord à 0
// ceci étant, l'objet étant détruit, coord ne sert pas ensuite
// donc ce n'est pas utile dans une version rapide
coord=NULL;
#endif
};
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1::Libere ()
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee1::Libere () \n";
Sortie(1);
#endif
};
//// Desallocation de la place memoire allouee
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee1::Libere ()
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee1::Libere () \n";
// Sortie(1);
// #endif
// };
// Renvoie le nombre de coordonnees
@ -143,90 +146,90 @@ void Coordonnee1::Libere ()
int Coordonnee1::Dimension () const
{ return 1; };
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1::Change_dim(int )
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee1::Change_dim(int dimen) \n";
Sortie(1);
#endif
};
//// changement de la dimension
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee1::Change_dim(int )
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee1::Change_dim(int dimen) \n";
// Sortie(1);
// #endif
// };
// Surcharge de l'operateur = : realise l'affectation entre deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1& Coordonnee1::operator= (const Coordonnee1& c)
{ coord1[0]=c.coord1[0];
return (*this);
{ coord1[0]=c.coord1[0];
return (*this);
};
// Surcharge de l'operateur - : renvoie l'oppose d'un point
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1 Coordonnee1::operator- () const
{ return Coordonnee1(-coord1[0]);
};
{ return Coordonnee1(-coord1[0]);
};
// Surcharge de l'operateur - : realise la soustraction des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1 Coordonnee1::operator- (const Coordonnee1& c) const
{ return Coordonnee1(coord1[0]-c.coord1[0]);
};
{ return Coordonnee1(coord1[0]-c.coord1[0]);
};
// Surcharge de l'operateur + : realise l'addition des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1 Coordonnee1::operator+ (const Coordonnee1& c) const
{ return Coordonnee1(coord1[0]+c.coord1[0]);
};
{ return Coordonnee1(coord1[0]+c.coord1[0]);
};
// Surcharge de l'operateur +=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1::operator+= (const Coordonnee1& c)
{ coord1[0]+=c.coord1[0];
};
{ coord1[0]+=c.coord1[0];
};
// Surcharge de l'operateur -=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1::operator-= (const Coordonnee1& c)
{ coord1[0]-=c.coord1[0];
};
{ coord1[0]-=c.coord1[0];
};
// Surcharge de l'operateur *=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1::operator*= (double val)
{ coord1[0]*=val;
};
{ coord1[0]*=val;
};
// Surcharge de l'operateur * : multiplication de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1 Coordonnee1::operator* (double val) const
{
return Coordonnee1(val*coord1[0]);
};
{
return Coordonnee1(val*coord1[0]);
};
// Surcharge de l'operateur * : produit scalaire entre coordonnees
#ifndef MISE_AU_POINT
inline
@ -251,7 +254,7 @@ Coordonnee1 Coordonnee1::operator/ (double val) const
#endif
return Coordonnee1(coord1[0] / val);
};
// Surcharge de l'operateur /= : division de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
@ -275,20 +278,20 @@ void Coordonnee1::operator/= (double val)
inline
#endif
int Coordonnee1::operator== (const Coordonnee1& c) const
{ if (c.coord1[0]!=coord1[0])
return 0;
else
return 1;
};
{ if (c.coord1[0]!=coord1[0])
return 0;
else
return 1;
};
// mise a zero des coordonnées
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1::Zero()
{ coord1[0] = 0.;
};
{ coord1[0] = 0.;
};
// Calcul de la norme euclidienne des composantes du point
#ifndef MISE_AU_POINT
inline
@ -312,7 +315,7 @@ Coordonnee1& Coordonnee1::Normer ()
*this /= norme;
return *this ;
};
// somme de tous les composantes
#ifndef MISE_AU_POINT
inline
@ -335,35 +338,35 @@ double Coordonnee1::Somme() const
// sortie du schemaXML: en fonction de enu
void Coordonnee1::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu)
{
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** Coordonnee dim 1 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_1\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 1: elements: "
<< "\n 1 reel "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" type=\"xs:double\" />"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** Coordonnee dim 1 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_1\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 1: elements: "
<< "\n 1 reel "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" type=\"xs:double\" />"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
default: sort << "\n SchemaXML: cas non pris en compte " ;
};
};
};
#endif

74
tenseurs_mai99/Coordonnees/Coordonnee1.h
View file

@ -62,6 +62,8 @@
* BUT: Les classes Coordonnee1 servent a la localisation dans l'espace
* 1D des objets tels que les noeuds ou les points. Ces classes
* dérivent des Classes génériques Coordonnee.
* Particularité: contrairement aux Coordonnees génériques, ici la dimension est fixe
* et ne peut pas varier.
* \author Gérard Rio
* \version 1.0
* \date 23/01/97
@ -123,22 +125,22 @@ class Coordonnee1 : public Coordonnee
/// Renvoie le nombre de coordonnees
int Dimension () const ;
/*! \brief
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
*/
void Libere ();
// /*! \brief
// // Desallocation de la place memoire allouee
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, ou plutôt qui n'a aucun effet car la mémoire est figée
// */
// void Libere ();
// Renvoie le nombre de coordonnees
//int Dimension () const ;
/*! \brief
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici, affiche un message d'erreur
*/
void Change_dim(int dim);
// /*! \brief
// // changement de la dimension
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, affiche un message d'erreur
// */
// void Change_dim(int dim);
/// Surcharge de l'operateur = : realise l'affectation entre deux points
Coordonnee1& operator= (const Coordonnee1& c);
@ -265,22 +267,22 @@ class Coordonnee1H : public CoordonneeH
/// Renvoie le nombre de coordonnees
int Dimension () const ;
/*! \brief
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
*/
void Libere ();
// /*! \brief
// // Desallocation de la place memoire allouee
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, ou plutôt qui n'a aucun effet car la mémoire est figée
// */
// void Libere ();
// Renvoie le nombre de coordonnees
//int Dimension () const ;
/*! \brief
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici, affiche un message d'erreur
*/
void Change_dim(int dim);
// /*! \brief
// // changement de la dimension
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, affiche un message d'erreur
// */
// void Change_dim(int dim);
/// Surcharge de l'operateur = : realise l'affectation entre deux points
Coordonnee1H& operator= (const Coordonnee1H& c);
@ -408,22 +410,22 @@ class Coordonnee1B : public CoordonneeB
/// Renvoie le nombre de coordonnees
int Dimension () const ;
/*! \brief
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
*/
void Libere ();
// /*! \brief
// // Desallocation de la place memoire allouee
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, ou plutôt qui n'a aucun effet car la mémoire est figée
// */
// void Libere ();
// Renvoie le nombre de coordonnees
//int Dimension () const ;
/*! \brief
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici, affiche un message d'erreur
*/
void Change_dim(int dim);
// /*! \brief
// // changement de la dimension
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, affiche un message d'erreur
// */
// void Change_dim(int dim);
/// Surcharge de l'operateur = : realise l'affectation entre deux points
Coordonnee1B& operator= (const Coordonnee1B& c);

218
tenseurs_mai99/Coordonnees/Coordonnee1B.cc
View file

@ -70,7 +70,7 @@ Coordonnee1B::Coordonnee1B (bool ):
Coordonnee1B::Coordonnee1B (double x):
CoordonneeB(1,coord1)
// Constructeur pour un point a deux dimensions
{ coord1[0]=x;
{ coord1[0]=x;
};
// constructeur fonction d'une adresse memoire ou sont stockee les coordonnees
@ -82,7 +82,7 @@ Coordonnee1B::Coordonnee1B (double x):
Coordonnee1B::Coordonnee1B (double* t):
CoordonneeB(1,coord1)
{ coord1[0]=t[0];
};
};
// Constructeur de copie
#ifndef MISE_AU_POINT
@ -99,13 +99,13 @@ Coordonnee1B::Coordonnee1B (const Coordonnee1B& c):
#endif
Coordonnee1B::Coordonnee1B (const CoordonneeB& c):
CoordonneeB(1,coord1)
{
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 1)
{ cout << "\nErreur la dimension de c est différente de 1 !! !\n";
cout << "Coordonnee1B::Coordonnee1B (const Coordonnee& c) \n";
Sortie(1);
}
if (c.Dimension () != 1)
{ cout << "\nErreur la dimension de c est différente de 1 !! !\n";
cout << "Coordonnee1B::Coordonnee1B (const Coordonnee& c) \n";
Sortie(1);
}
#endif
coord1[0]=c(1);
};
@ -120,20 +120,20 @@ Coordonnee1B::~Coordonnee1B ()
coord=NULL;
#endif
};
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1B::Libere ()
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee1B::Libere () \n";
Sortie(1);
#endif
};
//// Desallocation de la place memoire allouee
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee1B::Libere ()
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee1B::Libere () \n";
// Sortie(1);
// #endif
// };
// Renvoie le nombre de coordonnees
@ -143,105 +143,105 @@ void Coordonnee1B::Libere ()
int Coordonnee1B::Dimension () const
{ return 1; };
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1B::Change_dim(int )
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee1B::Change_dim(int dimen) \n";
Sortie(1);
#endif
};
//// changement de la dimension
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee1B::Change_dim(int )
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee1B::Change_dim(int dimen) \n";
// Sortie(1);
// #endif
// };
// Surcharge de l'operateur = : realise l'affectation entre deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1B& Coordonnee1B::operator= (const Coordonnee1B& c)
{ coord1[0]=c.coord1[0];
return (*this);
{ coord1[0]=c.coord1[0];
return (*this);
};
// Surcharge de l'operateur - : renvoie l'oppose d'un point
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1B Coordonnee1B::operator- () const
{ return Coordonnee1B(-coord1[0]);
};
{ return Coordonnee1B(-coord1[0]);
};
// Surcharge de l'operateur - : realise la soustraction des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1B Coordonnee1B::operator- (const Coordonnee1B& c) const
{ return Coordonnee1B(coord1[0]-c.coord1[0]);
};
{ return Coordonnee1B(coord1[0]-c.coord1[0]);
};
// Surcharge de l'operateur + : realise l'addition des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1B Coordonnee1B::operator+ (const Coordonnee1B& c) const
{ return Coordonnee1B(coord1[0]+c.coord1[0]);
};
{ return Coordonnee1B(coord1[0]+c.coord1[0]);
};
// Surcharge de l'operateur +=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1B::operator+= (const Coordonnee1B& c)
{ coord1[0]+=c.coord1[0];
};
{ coord1[0]+=c.coord1[0];
};
// Surcharge de l'operateur -=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1B::operator-= (const Coordonnee1B& c)
{ coord1[0]-=c.coord1[0];
};
{ coord1[0]-=c.coord1[0];
};
// Surcharge de l'operateur *=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1B::operator*= (double val)
{ coord1[0]*=val;
};
{ coord1[0]*=val;
};
// Surcharge de l'operateur * : multiplication de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1B Coordonnee1B::operator* (double val) const
{
return Coordonnee1B(val*coord1[0]);
};
{
return Coordonnee1B(val*coord1[0]);
};
// Surcharge de l'operateur * : produit scalaire entre coordonnees
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee1B::operator* (const Coordonnee1H& c) const
{ return ( coord1[0] * c.coord1[0] );
{ return ( coord1[0] * c.coord1[0] );
};
// produit scalaire entre coordonnees covariantes et covariantes
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee1B::ScalBB(const Coordonnee1B& c) const
{ return ( coord1[0] * c.coord1[0] );
{ return ( coord1[0] * c.coord1[0] );
};
@ -250,7 +250,7 @@ double Coordonnee1B::ScalBB(const Coordonnee1B& c) const
inline
#endif
Coordonnee1B Coordonnee1B::operator/ (double val) const
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
@ -260,19 +260,19 @@ Coordonnee1B Coordonnee1B::operator/ (double val) const
#endif
return Coordonnee1B(coord1[0] / val);
};
// Surcharge de l'operateur /= : division de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1B::operator/= (double val)
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee1B::operator/= (double val) " << endl;
Sortie (1);
}
}
#endif
coord1[0]/=val;
};
@ -284,26 +284,26 @@ void Coordonnee1B::operator/= (double val)
inline
#endif
int Coordonnee1B::operator== (const Coordonnee1B& c) const
{ if (c.coord1[0]!=coord1[0])
return 0;
else
return 1;
};
{ if (c.coord1[0]!=coord1[0])
return 0;
else
return 1;
};
// mise a zero des coordonnées
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1B::Zero()
{ coord1[0] = 0.;
};
{ coord1[0] = 0.;
};
// Calcul de la norme euclidienne des composantes du point
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee1B::Norme () const
{ return sqrt( coord1[0] * coord1[0] );
{ return sqrt( coord1[0] * coord1[0] );
};
// norme le vecteur coordonnée
#ifndef MISE_AU_POINT
@ -316,12 +316,12 @@ Coordonnee1B& Coordonnee1B::Normer ()
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee1B::Normer () " << endl;
Sortie (1);
}
}
#endif
*this /= norme;
return *this ;
*this /= norme;
return *this ;
};
// somme de tous les composantes
#ifndef MISE_AU_POINT
inline
@ -329,7 +329,7 @@ Coordonnee1B& Coordonnee1B::Normer ()
double Coordonnee1B::Somme() const
{
return coord1[0] ;
};
};
// Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees
#ifndef MISE_AU_POINT
@ -345,35 +345,35 @@ double Coordonnee1B::Somme() const
// sortie du schemaXML: en fonction de enu
void Coordonnee1B::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu)
{
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** CoordonneeB dim 1 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_1B\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 1: elements: "
<< "\n 1 reel "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" type=\"xs:double\" />"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** CoordonneeB dim 1 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_1B\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 1: elements: "
<< "\n 1 reel "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" type=\"xs:double\" />"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
default: sort << "\n SchemaXML: cas non pris en compte " ;
};
};
};
#endif

270
tenseurs_mai99/Coordonnees/Coordonnee1H.cc
View file

@ -51,8 +51,8 @@ using namespace std; //introduces namespace std
#endif
Coordonnee1H::Coordonnee1H () :
CoordonneeH(1,coord1)
{ coord1[0] = 0.;
};
{ coord1[0] = 0.;
};
// Constructeur suivant un booleen
// quelque soit la valeur du booleen il n'y a pas initialisation des coordonnées
@ -62,16 +62,16 @@ Coordonnee1H::Coordonnee1H () :
#endif
Coordonnee1H::Coordonnee1H (bool ):
CoordonneeH(1,coord1)
{ };
{ };
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1H::Coordonnee1H (double x):
CoordonneeH(1,coord1)
// Constructeur pour un point a deux dimensions
{ coord1[0]=x;
};
// Constructeur pour un point a deux dimensions
{ coord1[0]=x;
};
// constructeur fonction d'une adresse memoire ou sont stockee les coordonnees
// et d'une dimension ( l'existance de la place mémoire est a la charge
@ -82,7 +82,7 @@ Coordonnee1H::Coordonnee1H (double x):
Coordonnee1H::Coordonnee1H (double* t):
CoordonneeH(1,coord1)
{ coord1[0]=t[0];
};
};
// Constructeur de copie
#ifndef MISE_AU_POINT
@ -90,8 +90,8 @@ Coordonnee1H::Coordonnee1H (double* t):
#endif
Coordonnee1H::Coordonnee1H (const Coordonnee1H& c):
CoordonneeH(1,coord1)
{ coord1[0]=c.coord1[0];
};
{ coord1[0]=c.coord1[0];
};
// Constructeur de copie pour une instance indiférenciée
#ifndef MISE_AU_POINT
@ -99,41 +99,41 @@ Coordonnee1H::Coordonnee1H (const Coordonnee1H& c):
#endif
Coordonnee1H::Coordonnee1H (const CoordonneeH& c):
CoordonneeH(1,coord1)
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 1)
{ cout << "\nErreur la dimension de c est différente de 1 !! !\n";
cout << "Coordonnee1H::Coordonnee1H (const Coordonnee& c) \n";
Sortie(1);
}
#endif
coord1[0]=c(1);
};
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 1)
{ cout << "\nErreur la dimension de c est différente de 1 !! !\n";
cout << "Coordonnee1H::Coordonnee1H (const Coordonnee& c) \n";
Sortie(1);
}
#endif
coord1[0]=c(1);
};
// DESTRUCTEUR :
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1H::~Coordonnee1H ()
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
coord=NULL;
#endif
};
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1H::Libere ()
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee1H::Libere () \n";
Sortie(1);
#endif
};
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
coord=NULL;
#endif
};
//// Desallocation de la place memoire allouee
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee1H::Libere ()
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee1H::Libere () \n";
// Sortie(1);
// #endif
// };
// Renvoie le nombre de coordonnees
@ -143,105 +143,105 @@ void Coordonnee1H::Libere ()
int Coordonnee1H::Dimension () const
{ return 1; };
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1H::Change_dim(int )
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee1H::Change_dim(int dimen) \n";
Sortie(1);
#endif
};
//// changement de la dimension
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee1H::Change_dim(int )
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee1H::Change_dim(int dimen) \n";
// Sortie(1);
// #endif
// };
// Surcharge de l'operateur = : realise l'affectation entre deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1H& Coordonnee1H::operator= (const Coordonnee1H& c)
{ coord1[0]=c.coord1[0];
return (*this);
};
{ coord1[0]=c.coord1[0];
return (*this);
};
// Surcharge de l'operateur - : renvoie l'oppose d'un point
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1H Coordonnee1H::operator- () const
{ return Coordonnee1H(-coord1[0]);
};
{ return Coordonnee1H(-coord1[0]);
};
// Surcharge de l'operateur - : realise la soustraction des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1H Coordonnee1H::operator- (const Coordonnee1H& c) const
{ return Coordonnee1H(coord1[0]-c.coord1[0]);
};
{ return Coordonnee1H(coord1[0]-c.coord1[0]);
};
// Surcharge de l'operateur + : realise l'addition des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1H Coordonnee1H::operator+ (const Coordonnee1H& c) const
{ return Coordonnee1H(coord1[0]+c.coord1[0]);
};
{ return Coordonnee1H(coord1[0]+c.coord1[0]);
};
// Surcharge de l'operateur +=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1H::operator+= (const Coordonnee1H& c)
{ coord1[0]+=c.coord1[0];
};
{ coord1[0]+=c.coord1[0];
};
// Surcharge de l'operateur -=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1H::operator-= (const Coordonnee1H& c)
{ coord1[0]-=c.coord1[0];
};
{ coord1[0]-=c.coord1[0];
};
// Surcharge de l'operateur *=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1H::operator*= (double val)
{ coord1[0]*=val;
};
{ coord1[0]*=val;
};
// Surcharge de l'operateur * : multiplication de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1H Coordonnee1H::operator* (double val) const
{
return Coordonnee1H(val*coord1[0]);
};
{
return Coordonnee1H(val*coord1[0]);
};
// Surcharge de l'operateur * : produit scalaire entre coordonnees
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee1H::operator* (const Coordonnee1B& c) const
{ return ( coord1[0] * c.coord1[0] );
{ return ( coord1[0] * c.coord1[0] );
};
// produit scalaire entre coordonnees contravariantes et contravariantes
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee1H::ScalHH(const Coordonnee1H& c) const
{ return ( coord1[0] * c.coord1[0] );
{ return ( coord1[0] * c.coord1[0] );
};
@ -250,28 +250,28 @@ double Coordonnee1H::ScalHH(const Coordonnee1H& c) const
inline
#endif
Coordonnee1H Coordonnee1H::operator/ (double val) const
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee1H::operator/ (double val) " << endl;
Sortie (1);
}
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee1H::operator/ (double val) " << endl;
Sortie (1);
}
#endif
return Coordonnee1H(coord1[0] / val);
return Coordonnee1H(coord1[0] / val);
};
// Surcharge de l'operateur /= : division de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1H::operator/= (double val)
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee1H::operator/= (double val) " << endl;
Sortie (1);
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee1H::operator/= (double val) " << endl;
Sortie (1);
}
#endif
coord1[0]/=val;
@ -284,44 +284,44 @@ void Coordonnee1H::operator/= (double val)
inline
#endif
int Coordonnee1H::operator== (const Coordonnee1H& c) const
{ if (c.coord1[0]!=coord1[0])
return 0;
else
return 1;
};
{ if (c.coord1[0]!=coord1[0])
return 0;
else
return 1;
};
// mise a zero des coordonnées
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee1H::Zero()
{ coord1[0] = 0.;
};
{ coord1[0] = 0.;
};
// Calcul de la norme euclidienne des composantes du point
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee1H::Norme () const
{ return sqrt( coord1[0] * coord1[0] );
{ return sqrt( coord1[0] * coord1[0] );
};
// norme le vecteur coordonnée
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1H& Coordonnee1H::Normer ()
{ double norme = this->Norme();
{ double norme = this->Norme();
#ifdef MISE_AU_POINT
if(Dabs(norme) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee1H::Normer () " << endl;
Sortie (1);
}
}
#endif
*this /= norme;
return *this ;
};
*this /= norme;
return *this ;
};
// somme de tous les composantes
#ifndef MISE_AU_POINT
inline
@ -329,7 +329,7 @@ Coordonnee1H& Coordonnee1H::Normer ()
double Coordonnee1H::Somme() const
{
return coord1[0] ;
};
};
// Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees
#ifndef MISE_AU_POINT
@ -344,39 +344,39 @@ double Coordonnee1H::Somme() const
// sortie du schemaXML: en fonction de enu
void Coordonnee1H::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu)
{
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** CoordonneeH dim 1 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_1H\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 1: elements: "
<< "\n 1 reel "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" type=\"xs:double\" />"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** CoordonneeH dim 1 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_1H\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 1: elements: "
<< "\n 1 reel "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" type=\"xs:double\" />"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
default: cout << "\n *** attention cas non pris en compte pour le moment "
<< " XML_TYPE_GLOBAUX= "<<XML_TYPE_GLOBAUX
<< " Coordonnee1H::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) "
<< endl;
};
};
};

277
tenseurs_mai99/Coordonnees/Coordonnee2.cc
View file

@ -51,8 +51,8 @@ using namespace std; //introduces namespace std
#endif
Coordonnee2::Coordonnee2 () :
Coordonnee(2,coord2)
{ coord2[0] = 0.;coord2[1] = 0.;
};
{ coord2[0] = 0.;coord2[1] = 0.;
};
// Constructeur suivant un booleen
// quelque soit la valeur du booleen il n'y a pas initialisation des coordonnées
@ -62,7 +62,7 @@ Coordonnee2::Coordonnee2 () :
#endif
Coordonnee2::Coordonnee2 (bool ):
Coordonnee(2,coord2)
{ };
{ };
#ifndef MISE_AU_POINT
inline
@ -70,9 +70,9 @@ Coordonnee2::Coordonnee2 (bool ):
Coordonnee2::Coordonnee2 (double x,double y):
Coordonnee(2,coord2)
// Constructeur pour un point a deux dimensions
{ coord2[0]=x;
coord2[1]=y;
};
{ coord2[0]=x;
coord2[1]=y;
};
// constructeur fonction d'une adresse memoire ou sont stockee les coordonnees
// et d'une dimension ( l'existance de la place mémoire est a la charge
@ -83,8 +83,8 @@ Coordonnee2::Coordonnee2 (double x,double y):
Coordonnee2::Coordonnee2 (double* t):
Coordonnee(2,coord2)
{ coord2[0]=t[0];
coord2[1]=t[1];
};
coord2[1]=t[1];
};
// Constructeur de copie
#ifndef MISE_AU_POINT
@ -92,8 +92,8 @@ Coordonnee2::Coordonnee2 (double* t):
#endif
Coordonnee2::Coordonnee2 (const Coordonnee2& c):
Coordonnee(2,coord2)
{ coord2[0]=c.coord2[0];coord2[1]=c.coord2[1];
};
{ coord2[0]=c.coord2[0];coord2[1]=c.coord2[1];
};
// Constructeur de copie pour une instance indiférenciée
#ifndef MISE_AU_POINT
@ -101,41 +101,41 @@ Coordonnee2::Coordonnee2 (const Coordonnee2& c):
#endif
Coordonnee2::Coordonnee2 (const Coordonnee& c):
Coordonnee(2,coord2)
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 2)
{ cout << "\nErreur la dimension de c est différente de 2 !! !\n";
cout << "Coordonnee2::Coordonnee2 (const Coordonnee& c) \n";
Sortie(1);
}
#endif
coord2[0]=c(1);coord2[1]=c(2);
};
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 2)
{ cout << "\nErreur la dimension de c est différente de 2 !! !\n";
cout << "Coordonnee2::Coordonnee2 (const Coordonnee& c) \n";
Sortie(1);
}
#endif
coord2[0]=c(1);coord2[1]=c(2);
};
// DESTRUCTEUR :
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2::~Coordonnee2 ()
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
coord=NULL;
#endif
};
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2::Libere ()
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee2::Libere () \n";
Sortie(1);
#endif
};
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
coord=NULL;
#endif
};
//// Desallocation de la place memoire allouee
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee2::Libere ()
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee2::Libere () \n";
// Sortie(1);
// #endif
// };
// Renvoie le nombre de coordonnees
@ -143,100 +143,99 @@ void Coordonnee2::Libere ()
inline
#endif
int Coordonnee2::Dimension () const
{ return 2; };
{ return 2; };
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2::Change_dim(int )
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee2::Change_dim(int dimen) \n";
Sortie(1);
#endif
};
//// changement de la dimension
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee2::Change_dim(int )
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee2::Change_dim(int dimen) \n";
// Sortie(1);
// #endif
// };
// Surcharge de l'operateur = : realise l'affectation entre deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2& Coordonnee2::operator= (const Coordonnee2& c)
{ coord2[0]=c.coord2[0];coord2[1]=c.coord2[1];
return (*this);
{ coord2[0]=c.coord2[0];coord2[1]=c.coord2[1];
return (*this);
};
// Surcharge de l'operateur - : renvoie l'oppose d'un point
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2 Coordonnee2::operator- () const
{ return Coordonnee2(-coord2[0],-coord2[1]);
};
{ return Coordonnee2(-coord2[0],-coord2[1]);
};
// Surcharge de l'operateur - : realise la soustraction des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2 Coordonnee2::operator- (const Coordonnee2& c) const
{ return Coordonnee2(coord2[0]-c.coord2[0],coord2[1]-c.coord2[1]);
};
{ return Coordonnee2(coord2[0]-c.coord2[0],coord2[1]-c.coord2[1]);
};
// Surcharge de l'operateur + : realise l'addition des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2 Coordonnee2::operator+ (const Coordonnee2& c) const
{ return Coordonnee2(coord2[0]+c.coord2[0],coord2[1]+c.coord2[1]);
};
{ return Coordonnee2(coord2[0]+c.coord2[0],coord2[1]+c.coord2[1]);
};
// Surcharge de l'operateur +=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2::operator+= (const Coordonnee2& c)
{ coord2[0]+=c.coord2[0];
coord2[1]+=c.coord2[1];
};
{ coord2[0]+=c.coord2[0];
coord2[1]+=c.coord2[1];
};
// Surcharge de l'operateur -=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2::operator-= (const Coordonnee2& c)
{ coord2[0]-=c.coord2[0];
coord2[1]-=c.coord2[1];
};
{ coord2[0]-=c.coord2[0];
coord2[1]-=c.coord2[1];
};
// Surcharge de l'operateur *=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2::operator*= (double val)
{ coord2[0]*=val;coord2[1]*=val;
};
{ coord2[0]*=val;coord2[1]*=val;
};
// Surcharge de l'operateur * : multiplication de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2 Coordonnee2::operator* (double val) const
{
return Coordonnee2(val*coord2[0],val*coord2[1]);
};
{
return Coordonnee2(val*coord2[0],val*coord2[1]);
};
// Surcharge de l'operateur * : produit scalaire entre coordonnees
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee2::operator* (const Coordonnee2& c) const
{ return ( coord2[0] * c.coord2[0] + coord2[1] * c.coord2[1] );
{ return ( coord2[0] * c.coord2[0] + coord2[1] * c.coord2[1] );
};
@ -245,29 +244,29 @@ double Coordonnee2::operator* (const Coordonnee2& c) const
inline
#endif
Coordonnee2 Coordonnee2::operator/ (double val) const
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2::operator/ (double val) " << endl;
Sortie (1);
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2::operator/ (double val) " << endl;
Sortie (1);
}
#endif
return Coordonnee2(coord2[0] / val,coord2[1] / val);
return Coordonnee2(coord2[0] / val,coord2[1] / val);
};
// Surcharge de l'operateur /= : division de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2::operator/= (double val)
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2::operator/= (double val) " << endl;
Sortie (1);
}
}
#endif
coord2[0]/=val;coord2[1]/=val;
};
@ -279,51 +278,51 @@ void Coordonnee2::operator/= (double val)
inline
#endif
int Coordonnee2::operator== (const Coordonnee2& c) const
{ if ((c.coord2[0]!=coord2[0]) || (c.coord2[1]!=coord2[1]))
return 0;
else
return 1;
};
{ if ((c.coord2[0]!=coord2[0]) || (c.coord2[1]!=coord2[1]))
return 0;
else
return 1;
};
// mise a zero des coordonnées
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2::Zero()
{ coord2[0] = 0.;coord2[1] = 0.;
};
{ coord2[0] = 0.;coord2[1] = 0.;
};
// Calcul de la norme euclidienne des composantes du point
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee2::Norme () const
{ return sqrt( coord2[0] * coord2[0] + coord2[1] * coord2[1] );
{ return sqrt( coord2[0] * coord2[0] + coord2[1] * coord2[1] );
};
// norme le vecteur coordonnée
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2& Coordonnee2::Normer ()
{ double norme = this->Norme();
{ double norme = this->Norme();
#ifdef MISE_AU_POINT
if(Dabs(norme) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2::Normer () " << endl;
Sortie (1);
}
}
#endif
*this /= norme;
return *this ;
*this /= norme;
return *this ;
};
// somme de tous les composantes
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee2::Somme() const
{ return ( coord2[0] + coord2[1] );
};
};
/*// Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees
#ifndef MISE_AU_POINT
@ -338,45 +337,45 @@ double Coordonnee2::Somme() const
// sortie du schemaXML: en fonction de enu
void Coordonnee2::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu)
{
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** Coordonnee dim 2 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_2\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 2: elements: "
<< "\n 2 reels "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" >"
<< "\n <xs:simpleType>"
<< "\n <xs:restriction base=\"liste_de_reels\">"
<< "\n <xs:minLength value=\"2\" />"
<< "\n <xs:maxLength value=\"2\" />"
<< "\n </xs:restriction>"
<< "\n </xs:simpleType>"
<< "\n </xs:element>"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** Coordonnee dim 2 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_2\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 2: elements: "
<< "\n 2 reels "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" >"
<< "\n <xs:simpleType>"
<< "\n <xs:restriction base=\"liste_de_reels\">"
<< "\n <xs:minLength value=\"2\" />"
<< "\n <xs:maxLength value=\"2\" />"
<< "\n </xs:restriction>"
<< "\n </xs:simpleType>"
<< "\n </xs:element>"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
default: cout << "\n *** attention cas non pris en compte pour le moment "
<< " XML_TYPE_GLOBAUX= "<<XML_TYPE_GLOBAUX
<< " Coordonnee2::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) "
<< endl;
};
};
};

60
tenseurs_mai99/Coordonnees/Coordonnee2.h
View file

@ -61,6 +61,8 @@
* BUT: Les classes Coordonnee1 servent a la localisation dans l'espace
* 2D des objets tels que les noeuds ou les points. Ces classes
* dérivent des Classes génériques Coordonnee.
* Particularité: contrairement aux Coordonnees génériques, ici la dimension est fixe
* et ne peut pas varier.
* \author Gérard Rio
* \version 1.0
* \date 23/01/97
@ -122,19 +124,19 @@ class Coordonnee2 : public Coordonnee
/// Renvoie le nombre de coordonnees
int Dimension () const ;
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
void Libere ();
// // Desallocation de la place memoire allouee
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, ou plutôt qui n'a aucun effet car la mémoire est figée
// void Libere ();
// Renvoie le nombre de coordonnees
//int Dimension () const ;
/*! \brief
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici, affiche un message d'erreur */
void Change_dim(int dim);
// /*! \brief
// // changement de la dimension
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, affiche un message d'erreur */
// void Change_dim(int dim);
/// Surcharge de l'operateur = : realise l'affectation entre deux points
Coordonnee2& operator= (const Coordonnee2& c);
@ -257,20 +259,20 @@ class Coordonnee2H : public CoordonneeH
/// Renvoie le nombre de coordonnees
int Dimension () const ;
/*! \brief
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici */
void Libere ();
// /*! \brief
// // Desallocation de la place memoire allouee
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, ou plutôt qui n'a aucun effet car la mémoire est figée
// void Libere ();
// Renvoie le nombre de coordonnees
//int Dimension () const ;
/*! \brief
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici, affiche un message d'erreur */
void Change_dim(int dim);
// /*! \brief
// // changement de la dimension
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, affiche un message d'erreur */
// void Change_dim(int dim);
/// Surcharge de l'operateur = : realise l'affectation entre deux points
Coordonnee2H& operator= (const Coordonnee2H& c);
@ -392,20 +394,20 @@ class Coordonnee2B : public CoordonneeB
/// Renvoie le nombre de coordonnees
int Dimension () const ;
/*! \brief
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici */
void Libere ();
// /*! \brief
// // Desallocation de la place memoire allouee
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, ou plutôt qui n'a aucun effet car la mémoire est figée
// void Libere ();
// Renvoie le nombre de coordonnees
//int Dimension () const ;
/*! \brief
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici, affiche un message d'erreur */
void Change_dim(int dim);
// /*! \brief
// // changement de la dimension
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, affiche un message d'erreur */
// void Change_dim(int dim);
/// Surcharge de l'operateur = : realise l'affectation entre deux points
Coordonnee2B& operator= (const Coordonnee2B& c);

302
tenseurs_mai99/Coordonnees/Coordonnee2B.cc
View file

@ -51,8 +51,8 @@ using namespace std; //introduces namespace std
#endif
Coordonnee2B::Coordonnee2B () :
CoordonneeB(2,coord2)
{ coord2[0] = 0.;coord2[1] = 0.;
};
{ coord2[0] = 0.;coord2[1] = 0.;
};
// Constructeur suivant un booleen
// quelque soit la valeur du booleen il n'y a pas initialisation des coordonnées
@ -62,17 +62,17 @@ Coordonnee2B::Coordonnee2B () :
#endif
Coordonnee2B::Coordonnee2B (bool ):
CoordonneeB(2,coord2)
{ };
{ };
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2B::Coordonnee2B (double x,double y):
CoordonneeB(2,coord2)
// Constructeur pour un point a deux dimensions
{ coord2[0]=x;
coord2[1]=y;
};
//Constructeur pour un point a deux dimensions
{ coord2[0]=x;
coord2[1]=y;
};
// constructeur fonction d'une adresse memoire ou sont stockee les coordonnees
// et d'une dimension ( l'existance de la place mémoire est a la charge
@ -83,8 +83,8 @@ Coordonnee2B::Coordonnee2B (double x,double y):
Coordonnee2B::Coordonnee2B (double* t):
CoordonneeB(2,coord2)
{ coord2[0]=t[0];
coord2[1]=t[1];
};
coord2[1]=t[1];
};
// Constructeur de copie
#ifndef MISE_AU_POINT
@ -92,8 +92,8 @@ Coordonnee2B::Coordonnee2B (double* t):
#endif
Coordonnee2B::Coordonnee2B (const Coordonnee2B& c):
CoordonneeB(2,coord2)
{ coord2[0]=c.coord2[0];coord2[1]=c.coord2[1];
};
{ coord2[0]=c.coord2[0];coord2[1]=c.coord2[1];
};
// Constructeur de copie pour une instance indiférenciée
#ifndef MISE_AU_POINT
@ -101,41 +101,41 @@ Coordonnee2B::Coordonnee2B (const Coordonnee2B& c):
#endif
Coordonnee2B::Coordonnee2B (const CoordonneeB& c):
CoordonneeB(2,coord2)
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 2)
{ cout << "\nErreur la dimension de c est différente de 2 !! !\n";
cout << "Coordonnee2B::Coordonnee2B (const Coordonnee& c) \n";
Sortie(1);
}
#endif
coord2[0]=c(1);coord2[1]=c(2);
};
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 2)
{ cout << "\nErreur la dimension de c est différente de 2 !! !\n";
cout << "Coordonnee2B::Coordonnee2B (const Coordonnee& c) \n";
Sortie(1);
}
#endif
coord2[0]=c(1);coord2[1]=c(2);
};
// DESTRUCTEUR :
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2B::~Coordonnee2B ()
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
coord=NULL;
#endif
};
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2B::Libere ()
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee2B::Libere () \n";
Sortie(1);
#endif
};
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
coord=NULL;
#endif
};
//// Desallocation de la place memoire allouee
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee2B::Libere ()
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee2B::Libere () \n";
// Sortie(1);
// #endif
// };
// Renvoie le nombre de coordonnees
@ -143,108 +143,108 @@ void Coordonnee2B::Libere ()
inline
#endif
int Coordonnee2B::Dimension () const
{ return 2; };
{ return 2; };
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2B::Change_dim(int )
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee2B::Change_dim(int dimen) \n";
Sortie(1);
#endif
};
//// changement de la dimension
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee2B::Change_dim(int )
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee2B::Change_dim(int dimen) \n";
// Sortie(1);
// #endif
// };
// Surcharge de l'operateur = : realise l'affectation entre deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2B& Coordonnee2B::operator= (const Coordonnee2B& c)
{ coord2[0]=c.coord2[0];coord2[1]=c.coord2[1];
return (*this);
};
{ coord2[0]=c.coord2[0];coord2[1]=c.coord2[1];
return (*this);
};
// Surcharge de l'operateur - : renvoie l'oppose d'un point
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2B Coordonnee2B::operator- () const
{ return Coordonnee2B(-coord2[0],-coord2[1]);
};
{ return Coordonnee2B(-coord2[0],-coord2[1]);
};
// Surcharge de l'operateur - : realise la soustraction des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2B Coordonnee2B::operator- (const Coordonnee2B& c) const
{ return Coordonnee2B(coord2[0]-c.coord2[0],coord2[1]-c.coord2[1]);
};
{ return Coordonnee2B(coord2[0]-c.coord2[0],coord2[1]-c.coord2[1]);
};
// Surcharge de l'operateur + : realise l'addition des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2B Coordonnee2B::operator+ (const Coordonnee2B& c) const
{ return Coordonnee2B(coord2[0]+c.coord2[0],coord2[1]+c.coord2[1]);
};
{ return Coordonnee2B(coord2[0]+c.coord2[0],coord2[1]+c.coord2[1]);
};
// Surcharge de l'operateur +=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2B::operator+= (const Coordonnee2B& c)
{ coord2[0]+=c.coord2[0];
coord2[1]+=c.coord2[1];
};
{ coord2[0]+=c.coord2[0];
coord2[1]+=c.coord2[1];
};
// Surcharge de l'operateur -=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2B::operator-= (const Coordonnee2B& c)
{ coord2[0]-=c.coord2[0];
coord2[1]-=c.coord2[1];
};
{ coord2[0]-=c.coord2[0];
coord2[1]-=c.coord2[1];
};
// Surcharge de l'operateur *=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2B::operator*= (double val)
{ coord2[0]*=val;coord2[1]*=val;
};
{ coord2[0]*=val;coord2[1]*=val;
};
// Surcharge de l'operateur * : multiplication de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2B Coordonnee2B::operator* (double val) const
{
return Coordonnee2B(val*coord2[0],val*coord2[1]);
};
{
return Coordonnee2B(val*coord2[0],val*coord2[1]);
};
// Surcharge de l'operateur * : produit scalaire entre coordonnees
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee2B::operator* (const Coordonnee2H& c) const
{ return ( coord2[0] * c.coord2[0] + coord2[1] * c.coord2[1] );
{ return ( coord2[0] * c.coord2[0] + coord2[1] * c.coord2[1] );
};
// produit scalaire entre coordonnees covariantes et covariantes
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee2B::ScalBB(const Coordonnee2B& c) const
{ return ( coord2[0] * c.coord2[0] + coord2[1] * c.coord2[1] );
{ return ( coord2[0] * c.coord2[0] + coord2[1] * c.coord2[1] );
};
// Surcharge de l'operateur / : division de coordonnees par un scalaire
@ -252,29 +252,29 @@ double Coordonnee2B::ScalBB(const Coordonnee2B& c) const
inline
#endif
Coordonnee2B Coordonnee2B::operator/ (double val) const
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2B::operator/ (double val) " << endl;
Sortie (1);
}
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2B::operator/ (double val) " << endl;
Sortie (1);
}
#endif
return Coordonnee2B(coord2[0] / val,coord2[1] / val);
return Coordonnee2B(coord2[0] / val,coord2[1] / val);
};
// Surcharge de l'operateur /= : division de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2B::operator/= (double val)
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2B::operator/= (double val) " << endl;
Sortie (1);
}
}
#endif
coord2[0]/=val;coord2[1]/=val;
};
@ -286,59 +286,59 @@ void Coordonnee2B::operator/= (double val)
inline
#endif
int Coordonnee2B::operator== (const Coordonnee2B& c) const
{ if ((c.coord2[0]!=coord2[0]) || (c.coord2[1]!=coord2[1]))
return 0;
else
return 1;
};
{ if ((c.coord2[0]!=coord2[0]) || (c.coord2[1]!=coord2[1]))
return 0;
else
return 1;
};
// mise a zero des coordonnées
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2B::Zero()
{ coord2[0] = 0.;coord2[1] = 0.;
};
{ coord2[0] = 0.;coord2[1] = 0.;
};
// Calcul de la norme euclidienne des composantes du point
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee2B::Norme () const
{ return sqrt( coord2[0] * coord2[0] + coord2[1] * coord2[1] );
{ return sqrt( coord2[0] * coord2[0] + coord2[1] * coord2[1] );
};
// norme le vecteur coordonnée
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2B& Coordonnee2B::Normer ()
{ double norme = this->Norme();
{ double norme = this->Norme();
#ifdef MISE_AU_POINT
if(Dabs(norme) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2B::Normer () " << endl;
Sortie (1);
if(Dabs(norme) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2B::Normer () " << endl;
Sortie (1);
}
#endif
*this /= norme;
return *this ;
};
#endif
*this /= norme;
return *this ;
};
// somme de tous les composantes
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee2B::Somme() const
{ return ( coord2[0] + coord2[1] );
};
};
#ifndef MISE_AU_POINT
inline
#endif
// calcul du déterminant de deux vecteurs coordonnées
double Coordonnee2B::Determinant2B( const Coordonnee2B & v1, const Coordonnee2B & v2)
{ return v1.coord2[0] * v2.coord2[1] - v1.coord2[1] * v2.coord2[0];
};
};
/* // Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees
#ifndef MISE_AU_POINT
@ -352,45 +352,45 @@ double Coordonnee2B::Determinant2B( const Coordonnee2B & v1, const Coordonnee2B
// sortie du schemaXML: en fonction de enu
void Coordonnee2B::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu)
{
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** CoordonneeB dim 2 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_2B\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 2: elements: "
<< "\n 2 reels "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" >"
<< "\n <xs:simpleType>"
<< "\n <xs:restriction base=\"liste_de_reels\">"
<< "\n <xs:minLength value=\"2\" />"
<< "\n <xs:maxLength value=\"2\" />"
<< "\n </xs:restriction>"
<< "\n </xs:simpleType>"
<< "\n </xs:element>"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** CoordonneeB dim 2 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_2B\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 2: elements: "
<< "\n 2 reels "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" >"
<< "\n <xs:simpleType>"
<< "\n <xs:restriction base=\"liste_de_reels\">"
<< "\n <xs:minLength value=\"2\" />"
<< "\n <xs:maxLength value=\"2\" />"
<< "\n </xs:restriction>"
<< "\n </xs:simpleType>"
<< "\n </xs:element>"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
default: cout << "\n *** attention cas non pris en compte pour le moment "
<< " XML_TYPE_GLOBAUX= "<<XML_TYPE_GLOBAUX
<< " Coordonnee2B::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) "
<< endl;
};
};
};

302
tenseurs_mai99/Coordonnees/Coordonnee2H.cc
View file

@ -51,8 +51,8 @@ using namespace std; //introduces namespace std
#endif
Coordonnee2H::Coordonnee2H () :
CoordonneeH(2,coord2)
{ coord2[0] = 0.;coord2[1] = 0.;
};
{ coord2[0] = 0.;coord2[1] = 0.;
};
// Constructeur suivant un booleen
// quelque soit la valeur du booleen il n'y a pas initialisation des coordonnées
@ -62,7 +62,7 @@ Coordonnee2H::Coordonnee2H () :
#endif
Coordonnee2H::Coordonnee2H (bool ):
CoordonneeH(2,coord2)
{ };
{ };
#ifndef MISE_AU_POINT
inline
@ -70,9 +70,9 @@ Coordonnee2H::Coordonnee2H (bool ):
Coordonnee2H::Coordonnee2H (double x,double y):
CoordonneeH(2,coord2)
// Constructeur pour un point a deux dimensions
{ coord2[0]=x;
coord2[1]=y;
};
{ coord2[0]=x;
coord2[1]=y;
};
// constructeur fonction d'une adresse memoire ou sont stockee les coordonnees
// et d'une dimension ( l'existance de la place mémoire est a la charge
@ -83,8 +83,8 @@ Coordonnee2H::Coordonnee2H (double x,double y):
Coordonnee2H::Coordonnee2H (double* t):
CoordonneeH(2,coord2)
{ coord2[0]=t[0];
coord2[1]=t[1];
};
coord2[1]=t[1];
};
// Constructeur de copie
#ifndef MISE_AU_POINT
@ -92,8 +92,8 @@ Coordonnee2H::Coordonnee2H (double* t):
#endif
Coordonnee2H::Coordonnee2H (const Coordonnee2H& c):
CoordonneeH(2,coord2)
{ coord2[0]=c.coord2[0];coord2[1]=c.coord2[1];
};
{ coord2[0]=c.coord2[0];coord2[1]=c.coord2[1];
};
// Constructeur de copie pour une instance indiférenciée
#ifndef MISE_AU_POINT
@ -101,41 +101,41 @@ Coordonnee2H::Coordonnee2H (const Coordonnee2H& c):
#endif
Coordonnee2H::Coordonnee2H (const CoordonneeH& c):
CoordonneeH(2,coord2)
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 2)
{ cout << "\nErreur la dimension de c est différente de 2 !! !\n";
cout << "Coordonnee2H::Coordonnee2H (const Coordonnee& c) \n";
Sortie(1);
}
#endif
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 2)
{ cout << "\nErreur la dimension de c est différente de 2 !! !\n";
cout << "Coordonnee2H::Coordonnee2H (const Coordonnee& c) \n";
Sortie(1);
}
#endif
coord2[0]=c(1);coord2[1]=c(2);
};
};
// DESTRUCTEUR :
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2H::~Coordonnee2H ()
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
coord=NULL;
#endif
};
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2H::Libere ()
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee2H::Libere () \n";
Sortie(1);
#endif
};
#endif
};
//// Desallocation de la place memoire allouee
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee2H::Libere ()
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee2H::Libere () \n";
// Sortie(1);
// #endif
// };
// Renvoie le nombre de coordonnees
@ -143,102 +143,102 @@ void Coordonnee2H::Libere ()
inline
#endif
int Coordonnee2H::Dimension () const
{ return 2; };
{ return 2; };
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2H::Change_dim(int )
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee2H::Change_dim(int dimen) \n";
Sortie(1);
#endif
};
//// changement de la dimension
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee2H::Change_dim(int )
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee2H::Change_dim(int dimen) \n";
// Sortie(1);
// #endif
// };
// Surcharge de l'operateur = : realise l'affectation entre deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2H& Coordonnee2H::operator= (const Coordonnee2H& c)
{ coord2[0]=c.coord2[0];coord2[1]=c.coord2[1];
return (*this);
};
{ coord2[0]=c.coord2[0];coord2[1]=c.coord2[1];
return (*this);
};
// Surcharge de l'operateur - : renvoie l'oppose d'un point
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2H Coordonnee2H::operator- () const
{ return Coordonnee2H(-coord2[0],-coord2[1]);
};
{ return Coordonnee2H(-coord2[0],-coord2[1]);
};
// Surcharge de l'operateur - : realise la soustraction des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2H Coordonnee2H::operator- (const Coordonnee2H& c) const
{ return Coordonnee2H(coord2[0]-c.coord2[0],coord2[1]-c.coord2[1]);
};
{ return Coordonnee2H(coord2[0]-c.coord2[0],coord2[1]-c.coord2[1]);
};
// Surcharge de l'operateur + : realise l'addition des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2H Coordonnee2H::operator+ (const Coordonnee2H& c) const
{ return Coordonnee2H(coord2[0]+c.coord2[0],coord2[1]+c.coord2[1]);
};
{ return Coordonnee2H(coord2[0]+c.coord2[0],coord2[1]+c.coord2[1]);
};
// Surcharge de l'operateur +=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2H::operator+= (const Coordonnee2H& c)
{ coord2[0]+=c.coord2[0];
coord2[1]+=c.coord2[1];
};
{ coord2[0]+=c.coord2[0];
coord2[1]+=c.coord2[1];
};
// Surcharge de l'operateur -=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2H::operator-= (const Coordonnee2H& c)
{ coord2[0]-=c.coord2[0];
coord2[1]-=c.coord2[1];
};
{ coord2[0]-=c.coord2[0];
coord2[1]-=c.coord2[1];
};
// Surcharge de l'operateur *=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2H::operator*= (double val)
{ coord2[0]*=val;coord2[1]*=val;
};
{ coord2[0]*=val;coord2[1]*=val;
};
// Surcharge de l'operateur * : multiplication de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2H Coordonnee2H::operator* (double val) const
{
return Coordonnee2H(val*coord2[0],val*coord2[1]);
};
{
return Coordonnee2H(val*coord2[0],val*coord2[1]);
};
// Surcharge de l'operateur * : produit scalaire entre coordonnees
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee2H::operator* (const Coordonnee2B& c) const
{ return ( coord2[0] * c.coord2[0] + coord2[1] * c.coord2[1] );
{ return ( coord2[0] * c.coord2[0] + coord2[1] * c.coord2[1] );
};
// produit scalaire entre coordonnees contravariantes et contravariantes
#ifndef MISE_AU_POINT
inline
@ -252,28 +252,28 @@ double Coordonnee2H::ScalHH(const Coordonnee2H& c) const
inline
#endif
Coordonnee2H Coordonnee2H::operator/ (double val) const
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2H::operator/ (double val) " << endl;
Sortie (1);
}
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2H::operator/ (double val) " << endl;
Sortie (1);
}
#endif
return Coordonnee2H(coord2[0] / val,coord2[1] / val);
return Coordonnee2H(coord2[0] / val,coord2[1] / val);
};
// Surcharge de l'operateur /= : division de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2H::operator/= (double val)
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2H::operator/= (double val) " << endl;
Sortie (1);
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2H::operator/= (double val) " << endl;
Sortie (1);
}
#endif
coord2[0]/=val;coord2[1]/=val;
@ -286,51 +286,51 @@ void Coordonnee2H::operator/= (double val)
inline
#endif
int Coordonnee2H::operator== (const Coordonnee2H& c) const
{ if ((c.coord2[0]!=coord2[0]) || (c.coord2[1]!=coord2[1]))
return 0;
else
return 1;
};
{ if ((c.coord2[0]!=coord2[0]) || (c.coord2[1]!=coord2[1]))
return 0;
else
return 1;
};
// mise a zero des coordonnées
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee2H::Zero()
{ coord2[0] = 0.;coord2[1] = 0.;
};
{ coord2[0] = 0.;coord2[1] = 0.;
};
// Calcul de la norme euclidienne des composantes du point
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee2H::Norme () const
{ return sqrt( coord2[0] * coord2[0] + coord2[1] * coord2[1] );
{ return sqrt( coord2[0] * coord2[0] + coord2[1] * coord2[1] );
};
// norme le vecteur coordonnée
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee2H& Coordonnee2H::Normer ()
{ double norme = this->Norme();
{ double norme = this->Norme();
#ifdef MISE_AU_POINT
if(Dabs(norme) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2H::Normer () " << endl;
Sortie (1);
}
if(Dabs(norme) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee2H::Normer () " << endl;
Sortie (1);
}
#endif
*this /= norme;
return *this ;
};
*this /= norme;
return *this ;
};
// somme de tous les composantes
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee2H::Somme() const
{ return ( coord2[0] + coord2[1] );
};
};
/* // Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees
#ifndef MISE_AU_POINT
@ -344,45 +344,45 @@ double Coordonnee2H::Somme() const
// sortie du schemaXML: en fonction de enu
void Coordonnee2H::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu)
{
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** CoordonneeH dim 2 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_2H\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 2: elements: "
<< "\n 2 reels "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" >"
<< "\n <xs:simpleType>"
<< "\n <xs:restriction base=\"liste_de_reels\">"
<< "\n <xs:minLength value=\"2\" />"
<< "\n <xs:maxLength value=\"2\" />"
<< "\n </xs:restriction>"
<< "\n </xs:simpleType>"
<< "\n </xs:element>"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
default: cout << "\n *** attention cas non pris en compte pour le moment "
<< " XML_TYPE_GLOBAUX= "<<XML_TYPE_GLOBAUX
<< " Coordonnee2H::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) "
<< endl;
};
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** CoordonneeH dim 2 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_2H\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 2: elements: "
<< "\n 2 reels "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" >"
<< "\n <xs:simpleType>"
<< "\n <xs:restriction base=\"liste_de_reels\">"
<< "\n <xs:minLength value=\"2\" />"
<< "\n <xs:maxLength value=\"2\" />"
<< "\n </xs:restriction>"
<< "\n </xs:simpleType>"
<< "\n </xs:element>"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
default: cout << "\n *** attention cas non pris en compte pour le moment "
<< " XML_TYPE_GLOBAUX= "<<XML_TYPE_GLOBAUX
<< " Coordonnee2H::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) "
<< endl;
};
};

310
tenseurs_mai99/Coordonnees/Coordonnee3.cc
View file

@ -51,8 +51,8 @@ using namespace std; //introduces namespace std
#endif
Coordonnee3::Coordonnee3 () :
Coordonnee(3,coord3)
{ coord3[0] = 0.;coord3[1] = 0.;coord3[2] = 0.;
};
{ coord3[0] = 0.;coord3[1] = 0.;coord3[2] = 0.;
};
// Constructeur suivant un booleen
// quelque soit la valeur du booleen il n'y a pas initialisation des coordonnées
@ -62,7 +62,7 @@ Coordonnee3::Coordonnee3 () :
#endif
Coordonnee3::Coordonnee3 (bool ):
Coordonnee(3,coord3)
{ };
{ };
#ifndef MISE_AU_POINT
inline
@ -70,10 +70,10 @@ Coordonnee3::Coordonnee3 (bool ):
Coordonnee3::Coordonnee3 (double x,double y,double z):
Coordonnee(3,coord3)
// Constructeur pour un point a trois dimensions
{ coord3[0]=x;
coord3[1]=y;
coord3[2]=z;
};
{ coord3[0]=x;
coord3[1]=y;
coord3[2]=z;
};
// constructeur fonction d'une adresse memoire ou sont stockee les coordonnees
// et d'une dimension ( l'existance de la place mémoire est a la charge
@ -84,9 +84,9 @@ Coordonnee3::Coordonnee3 (double x,double y,double z):
Coordonnee3::Coordonnee3 (double* t):
Coordonnee(3,coord3)
{ coord3[0]=t[0];
coord3[1]=t[1];
coord3[2]=t[2];
};
coord3[1]=t[1];
coord3[2]=t[2];
};
// Constructeur de copie
#ifndef MISE_AU_POINT
@ -94,8 +94,8 @@ Coordonnee3::Coordonnee3 (double* t):
#endif
Coordonnee3::Coordonnee3 (const Coordonnee3& c):
Coordonnee(3,coord3)
{ coord3[0]=c.coord3[0];coord3[1]=c.coord3[1];coord3[2]=c.coord3[2];
};
{ coord3[0]=c.coord3[0];coord3[1]=c.coord3[1];coord3[2]=c.coord3[2];
};
// Constructeur de copie pour une instance indiférenciée
#ifndef MISE_AU_POINT
@ -103,42 +103,42 @@ Coordonnee3::Coordonnee3 (const Coordonnee3& c):
#endif
Coordonnee3::Coordonnee3 (const Coordonnee& c):
Coordonnee(3,coord3)
{
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 3)
{ cout << "\nErreur la dimension de c est différente de 3 !! !\n";
cout << "Coordonnee3::Coordonnee3 (const Coordonnee& c) \n";
Sortie(1);
}
if (c.Dimension () != 3)
{ cout << "\nErreur la dimension de c est différente de 3 !! !\n";
cout << "Coordonnee3::Coordonnee3 (const Coordonnee& c) \n";
Sortie(1);
}
#endif
coord3[0]=c(1);coord3[1]=c(2);
coord3[2]=c(3);
};
coord3[0]=c(1);coord3[1]=c(2);
coord3[2]=c(3);
};
// DESTRUCTEUR :
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3::~Coordonnee3 ()
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
coord=NULL;
#endif
};
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3::Libere ()
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee3::Libere () \n";
Sortie(1);
#endif
};
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
coord=NULL;
#endif
};
//// Desallocation de la place memoire allouee
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee3::Libere ()
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee3::Libere () \n";
// Sortie(1);
// #endif
// };
// Renvoie le nombre de coordonnees
@ -146,108 +146,108 @@ void Coordonnee3::Libere ()
inline
#endif
int Coordonnee3::Dimension () const
{ return 3; };
{ return 3; };
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3::Change_dim(int )
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee3::Change_dim(int dimen) \n";
Sortie(1);
#endif
};
//// changement de la dimension
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee3::Change_dim(int )
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee3::Change_dim(int dimen) \n";
// Sortie(1);
// #endif
// };
// Surcharge de l'operateur = : realise l'affectation entre deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3& Coordonnee3::operator= (const Coordonnee3& c)
{ coord3[0]=c.coord3[0];coord3[1]=c.coord3[1];coord3[2]=c.coord3[2];
return (*this);
};
{ coord3[0]=c.coord3[0];coord3[1]=c.coord3[1];coord3[2]=c.coord3[2];
return (*this);
};
// Surcharge de l'operateur - : renvoie l'oppose d'un point
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3 Coordonnee3::operator- () const
{ return Coordonnee3(-coord3[0],-coord3[1],-coord3[2]);
};
{ return Coordonnee3(-coord3[0],-coord3[1],-coord3[2]);
};
// Surcharge de l'operateur - : realise la soustraction des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3 Coordonnee3::operator- (const Coordonnee3& c) const
{ return Coordonnee3(coord3[0]-c.coord3[0],coord3[1]-c.coord3[1],
coord3[2]-c.coord3[2]);
};
{ return Coordonnee3(coord3[0]-c.coord3[0],coord3[1]-c.coord3[1],
coord3[2]-c.coord3[2]);
};
// Surcharge de l'operateur + : realise l'addition des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3 Coordonnee3::operator+ (const Coordonnee3& c) const
{ return Coordonnee3(coord3[0]+c.coord3[0],coord3[1]+c.coord3[1],
coord3[2]+c.coord3[2]);
};
{ return Coordonnee3(coord3[0]+c.coord3[0],coord3[1]+c.coord3[1],
coord3[2]+c.coord3[2]);
};
// Surcharge de l'operateur +=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3::operator+= (const Coordonnee3& c)
{ coord3[0]+=c.coord3[0];
coord3[1]+=c.coord3[1];
coord3[2]+=c.coord3[2];
};
{ coord3[0]+=c.coord3[0];
coord3[1]+=c.coord3[1];
coord3[2]+=c.coord3[2];
};
// Surcharge de l'operateur -=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3::operator-= (const Coordonnee3& c)
{ coord3[0]-=c.coord3[0];
coord3[1]-=c.coord3[1];
coord3[2]-=c.coord3[2];
};
{ coord3[0]-=c.coord3[0];
coord3[1]-=c.coord3[1];
coord3[2]-=c.coord3[2];
};
// Surcharge de l'operateur *=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3::operator*= (double val)
{ coord3[0]*=val;coord3[1]*=val;coord3[2]*=val;
};
{ coord3[0]*=val;coord3[1]*=val;coord3[2]*=val;
};
// Surcharge de l'operateur * : multiplication de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3 Coordonnee3::operator* (double val) const
{ /*double ta[3];
ta[0] = val*coord3[0];
ta[1] = val*coord3[1];
ta[2] = val*coord3[2]; */
return Coordonnee3(val*coord3[0],val*coord3[1],val*coord3[2]);
// return Coordonnee3(ta);
};
{ /*double ta[3];
ta[0] = val*coord3[0];
ta[1] = val*coord3[1];
ta[2] = val*coord3[2]; */
return Coordonnee3(val*coord3[0],val*coord3[1],val*coord3[2]);
// return Coordonnee3(ta);
};
// Surcharge de l'operateur * : produit scalaire entre coordonnees
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee3::operator* (const Coordonnee3& c) const
{ return ( coord3[0] * c.coord3[0] + coord3[1] * c.coord3[1] +
{ return ( coord3[0] * c.coord3[0] + coord3[1] * c.coord3[1] +
coord3[2] * c.coord3[2] );
};
@ -257,23 +257,23 @@ double Coordonnee3::operator* (const Coordonnee3& c) const
inline
#endif
Coordonnee3 Coordonnee3::operator/ (double val) const
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee3::operator/ (double val) " << endl;
Sortie (1);
}
}
#endif
return Coordonnee3(coord3[0] / val,coord3[1] / val,coord3[2] / val);
return Coordonnee3(coord3[0] / val,coord3[1] / val,coord3[2] / val);
};
// Surcharge de l'operateur /= : division de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3::operator/= (double val)
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
@ -291,27 +291,27 @@ void Coordonnee3::operator/= (double val)
inline
#endif
int Coordonnee3::operator== (const Coordonnee3& c) const
{ if ((c.coord3[0]!=coord3[0]) || (c.coord3[1]!=coord3[1])
|| (c.coord3[2]!=coord3[2]))
return 0;
else
return 1;
};
{ if ((c.coord3[0]!=coord3[0]) || (c.coord3[1]!=coord3[1])
|| (c.coord3[2]!=coord3[2]))
return 0;
else
return 1;
};
// mise a zero des coordonnées
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3::Zero()
{ coord3[0] = 0.;coord3[1] = 0.;coord3[2] = 0.;
};
{ coord3[0] = 0.;coord3[1] = 0.;coord3[2] = 0.;
};
// Calcul de la norme euclidienne des composantes du point
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee3::Norme () const
{ return sqrt( coord3[0] * coord3[0] + coord3[1] * coord3[1] +
{ return sqrt( coord3[0] * coord3[0] + coord3[1] * coord3[1] +
coord3[2] * coord3[2] );
};
// norme le vecteur coordonnée
@ -319,18 +319,18 @@ double Coordonnee3::Norme () const
inline
#endif
Coordonnee3& Coordonnee3::Normer ()
{ double norme = this->Norme();
{ double norme = this->Norme();
#ifdef MISE_AU_POINT
if(Dabs(norme) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee3::Normer () " << endl;
Sortie (1);
if(Dabs(norme) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee3::Normer () " << endl;
Sortie (1);
}
#endif
*this /= norme;
return *this ;
};
*this /= norme;
return *this ;
};
// somme de tous les composantes
#ifndef MISE_AU_POINT
inline
@ -338,7 +338,7 @@ Coordonnee3& Coordonnee3::Normer ()
double Coordonnee3::Somme() const
{
return ( coord3[0] + coord3[1] + coord3[2] );
};
};
/* // Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees
#ifndef MISE_AU_POINT
@ -353,45 +353,45 @@ double Coordonnee3::Somme() const
// sortie du schemaXML: en fonction de enu
void Coordonnee3::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu)
{
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** Coordonnee dim 3 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_3\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 3: elements: "
<< "\n 3 reels "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" >"
<< "\n <xs:simpleType>"
<< "\n <xs:restriction base=\"liste_de_reels\">"
<< "\n <xs:minLength value=\"3\" />"
<< "\n <xs:maxLength value=\"3\" />"
<< "\n </xs:restriction>"
<< "\n </xs:simpleType>"
<< "\n </xs:element>"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
default: cout << "\n *** attention cas non pris en compte pour le moment "
<< " XML_TYPE_GLOBAUX= "<<XML_TYPE_GLOBAUX
<< " Coordonnee3::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) "
<< endl;
};
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** Coordonnee dim 3 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_3\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 3: elements: "
<< "\n 3 reels "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" >"
<< "\n <xs:simpleType>"
<< "\n <xs:restriction base=\"liste_de_reels\">"
<< "\n <xs:minLength value=\"3\" />"
<< "\n <xs:maxLength value=\"3\" />"
<< "\n </xs:restriction>"
<< "\n </xs:simpleType>"
<< "\n </xs:element>"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
default: cout << "\n *** attention cas non pris en compte pour le moment "
<< " XML_TYPE_GLOBAUX= "<<XML_TYPE_GLOBAUX
<< " Coordonnee3::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) "
<< endl;
};
};

64
tenseurs_mai99/Coordonnees/Coordonnee3.h
View file

@ -62,9 +62,11 @@
* BUT: Les classes Coordonnee1 servent a la localisation dans l'espace
* 3D des objets tels que les noeuds ou les points. Ces classes
* dérivent des Classes génériques Coordonnee.
* Particularité: contrairement aux Coordonnees génériques, ici la dimension est fixe
* et ne peut pas varier.
* \author Gérard Rio
* \version 1.0
* \date 23/01/97
* \date 23/01/97
* \brief Définition des classes de type Coordonnee3, en coordonnées sans variance (ex: absolues)
* ou en coordonnées locales c'est-à-dire en coordonnées covariantes ou contravariantes. Ces classes sont une spécialisation 3D des classes générales Coordonnee
*
@ -120,20 +122,20 @@ class Coordonnee3 : public Coordonnee
/// Renvoie le nombre de coordonnees
int Dimension () const ;
/*! \brief
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici */
void Libere ();
// /*! \brief
// // Desallocation de la place memoire allouee
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, ou plutôt qui n'a aucun effet car la mémoire est figée
// void Libere ();
// Renvoie le nombre de coordonnees
//int Dimension () const ;
/*! \brief
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici, affiche un message d'erreur */
void Change_dim(int dim);
// /*! \brief
// // changement de la dimension
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, affiche un message d'erreur */
// void Change_dim(int dim);
/// Surcharge de l'operateur = : realise l'affectation entre deux points
Coordonnee3& operator= (const Coordonnee3& c);
@ -256,20 +258,20 @@ class Coordonnee3H : public CoordonneeH
/// Renvoie le nombre de coordonnees
int Dimension () const ;
/*! \brief
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici */
void Libere ();
// /*! \brief
// // Desallocation de la place memoire allouee
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, ou plutôt qui n'a aucun effet car la mémoire est figée
// void Libere ();
// Renvoie le nombre de coordonnees
//int Dimension () const ;
/*! \brief
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici, affiche un message d'erreur */
void Change_dim(int dim);
// /*! \brief
// // changement de la dimension
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, affiche un message d'erreur */
// void Change_dim(int dim);
/// Surcharge de l'operateur = : realise l'affectation entre deux points
Coordonnee3H& operator= (const Coordonnee3H& c);
@ -392,20 +394,20 @@ class Coordonnee3B : public CoordonneeB
/// Renvoie le nombre de coordonnees
int Dimension () const ;
/*! \brief
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici */
void Libere ();
// /*! \brief
// // Desallocation de la place memoire allouee
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, ou plutôt qui n'a aucun effet car la mémoire est figée
// void Libere ();
// Renvoie le nombre de coordonnees
//int Dimension () const ;
/*! \brief
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici, affiche un message d'erreur */
void Change_dim(int dim);
// /*! \brief
// // changement de la dimension
// // fonction définie dans la classe mère générique mais qui n'a pas de
// // sens ici, affiche un message d'erreur */
// void Change_dim(int dim);
/// Surcharge de l'operateur = : realise l'affectation entre deux points
Coordonnee3B& operator= (const Coordonnee3B& c);

318
tenseurs_mai99/Coordonnees/Coordonnee3B.cc
View file

@ -51,8 +51,8 @@ using namespace std; //introduces namespace std
#endif
Coordonnee3B::Coordonnee3B () :
CoordonneeB(3,coord3)
{ coord3[0] = 0.;coord3[1] = 0.;coord3[2] = 0.;
};
{ coord3[0] = 0.;coord3[1] = 0.;coord3[2] = 0.;
};
// Constructeur suivant un booleen
// quelque soit la valeur du booleen il n'y a pas initialisation des coordonnées
@ -62,7 +62,7 @@ Coordonnee3B::Coordonnee3B () :
#endif
Coordonnee3B::Coordonnee3B (bool ):
CoordonneeB(3,coord3)
{ };
{ };
#ifndef MISE_AU_POINT
inline
@ -70,10 +70,10 @@ Coordonnee3B::Coordonnee3B (bool ):
Coordonnee3B::Coordonnee3B (double x,double y,double z):
CoordonneeB(3,coord3)
// Constructeur pour un point a trois dimensions
{ coord3[0]=x;
coord3[1]=y;
coord3[2]=z;
};
{ coord3[0]=x;
coord3[1]=y;
coord3[2]=z;
};
// constructeur fonction d'une adresse memoire ou sont stockee les coordonnees
// et d'une dimension ( l'existance de la place mémoire est a la charge
@ -83,10 +83,10 @@ Coordonnee3B::Coordonnee3B (double x,double y,double z):
#endif
Coordonnee3B::Coordonnee3B (double* t):
CoordonneeB(3,coord3)
{ coord3[0]=t[0];
coord3[1]=t[1];
coord3[2]=t[2];
};
{ coord3[0]=t[0];
coord3[1]=t[1];
coord3[2]=t[2];
};
// Constructeur de copie
#ifndef MISE_AU_POINT
@ -94,8 +94,8 @@ Coordonnee3B::Coordonnee3B (double* t):
#endif
Coordonnee3B::Coordonnee3B (const Coordonnee3B& c):
CoordonneeB(3,coord3)
{ coord3[0]=c.coord3[0];coord3[1]=c.coord3[1];coord3[2]=c.coord3[2];
};
{ coord3[0]=c.coord3[0];coord3[1]=c.coord3[1];coord3[2]=c.coord3[2];
};
// Constructeur de copie pour une instance indiférenciée
#ifndef MISE_AU_POINT
@ -103,42 +103,42 @@ Coordonnee3B::Coordonnee3B (const Coordonnee3B& c):
#endif
Coordonnee3B::Coordonnee3B (const CoordonneeB& c):
CoordonneeB(3,coord3)
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 3)
{ cout << "\nErreur la dimension de c est différente de 3 !! !\n";
cout << "Coordonnee3B::Coordonnee3B (const Coordonnee& c) \n";
Sortie(1);
}
#endif
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 3)
{ cout << "\nErreur la dimension de c est différente de 3 !! !\n";
cout << "Coordonnee3B::Coordonnee3B (const Coordonnee& c) \n";
Sortie(1);
}
#endif
coord3[0]=c(1);coord3[1]=c(2);
coord3[2]=c(3);
};
};
// DESTRUCTEUR :
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3B::~Coordonnee3B ()
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
coord=NULL;
#endif
};
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3B::Libere ()
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee3B::Libere () \n";
Sortie(1);
#endif
};
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
coord=NULL;
#endif
};
//// Desallocation de la place memoire allouee
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee3B::Libere ()
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee3B::Libere () \n";
// Sortie(1);
// #endif
// };
// Renvoie le nombre de coordonnees
@ -146,112 +146,112 @@ void Coordonnee3B::Libere ()
inline
#endif
int Coordonnee3B::Dimension () const
{ return 3; };
{ return 3; };
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3B::Change_dim(int )
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee3B::Change_dim(int dimen) \n";
Sortie(1);
#endif
};
//// changement de la dimension
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee3B::Change_dim(int )
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee3B::Change_dim(int dimen) \n";
// Sortie(1);
// #endif
// };
//
// Surcharge de l'operateur = : realise l'affectation entre deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3B& Coordonnee3B::operator= (const Coordonnee3B& c)
{ coord3[0]=c.coord3[0];coord3[1]=c.coord3[1];coord3[2]=c.coord3[2];
return (*this);
};
{ coord3[0]=c.coord3[0];coord3[1]=c.coord3[1];coord3[2]=c.coord3[2];
return (*this);
};
// Surcharge de l'operateur - : renvoie l'oppose d'un point
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3B Coordonnee3B::operator- () const
{ return Coordonnee3B(-coord3[0],-coord3[1],-coord3[2]);
};
{ return Coordonnee3B(-coord3[0],-coord3[1],-coord3[2]);
};
// Surcharge de l'operateur - : realise la soustraction des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3B Coordonnee3B::operator- (const Coordonnee3B& c) const
{ return Coordonnee3B(coord3[0]-c.coord3[0],coord3[1]-c.coord3[1],
coord3[2]-c.coord3[2]);
};
{ return Coordonnee3B(coord3[0]-c.coord3[0],coord3[1]-c.coord3[1],
coord3[2]-c.coord3[2]);
};
// Surcharge de l'operateur + : realise l'addition des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3B Coordonnee3B::operator+ (const Coordonnee3B& c) const
{ return Coordonnee3B(coord3[0]+c.coord3[0],coord3[1]+c.coord3[1],
coord3[2]+c.coord3[2]);
};
{ return Coordonnee3B(coord3[0]+c.coord3[0],coord3[1]+c.coord3[1],
coord3[2]+c.coord3[2]);
};
// Surcharge de l'operateur +=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3B::operator+= (const Coordonnee3B& c)
{ coord3[0]+=c.coord3[0];
coord3[1]+=c.coord3[1];
coord3[2]+=c.coord3[2];
};
{ coord3[0]+=c.coord3[0];
coord3[1]+=c.coord3[1];
coord3[2]+=c.coord3[2];
};
// Surcharge de l'operateur -=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3B::operator-= (const Coordonnee3B& c)
{ coord3[0]-=c.coord3[0];
coord3[1]-=c.coord3[1];
coord3[2]-=c.coord3[2];
};
{ coord3[0]-=c.coord3[0];
coord3[1]-=c.coord3[1];
coord3[2]-=c.coord3[2];
};
// Surcharge de l'operateur *=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3B::operator*= (double val)
{ coord3[0]*=val;coord3[1]*=val;coord3[2]*=val;
};
{ coord3[0]*=val;coord3[1]*=val;coord3[2]*=val;
};
// Surcharge de l'operateur * : multiplication de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3B Coordonnee3B::operator* (double val) const
{ return Coordonnee3B(val*coord3[0],val*coord3[1],val*coord3[2]);
};
{ return Coordonnee3B(val*coord3[0],val*coord3[1],val*coord3[2]);
};
// Surcharge de l'operateur * : produit scalaire entre coordonnees
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee3B::operator* (const Coordonnee3H& c) const
{ return ( coord3[0] * c.coord3[0] + coord3[1] * c.coord3[1] +
{ return ( coord3[0] * c.coord3[0] + coord3[1] * c.coord3[1] +
coord3[2] * c.coord3[2] );
};
// produit scalaire entre coordonnees covariantes et covariantes
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee3B::ScalBB(const Coordonnee3B& c) const
{ return ( coord3[0] * c.coord3[0] + coord3[1] * c.coord3[1] +
{ return ( coord3[0] * c.coord3[0] + coord3[1] * c.coord3[1] +
coord3[2] * c.coord3[2] );
};
@ -260,17 +260,17 @@ double Coordonnee3B::ScalBB(const Coordonnee3B& c) const
inline
#endif
Coordonnee3B Coordonnee3B::operator/ (double val) const
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee3B::operator/ (double val) " << endl;
Sortie (1);
}
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee3B::operator/ (double val) " << endl;
Sortie (1);
}
#endif
return Coordonnee3B(coord3[0] / val,coord3[1] / val,coord3[2] / val);
return Coordonnee3B(coord3[0] / val,coord3[1] / val,coord3[2] / val);
};
// Surcharge de l'operateur /= : division de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
@ -294,27 +294,27 @@ void Coordonnee3B::operator/= (double val)
inline
#endif
int Coordonnee3B::operator== (const Coordonnee3B& c) const
{ if ((c.coord3[0]!=coord3[0]) || (c.coord3[1]!=coord3[1])
|| (c.coord3[2]!=coord3[2]))
return 0;
else
return 1;
};
{ if ((c.coord3[0]!=coord3[0]) || (c.coord3[1]!=coord3[1])
|| (c.coord3[2]!=coord3[2]))
return 0;
else
return 1;
};
// mise a zero des coordonnées
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3B::Zero()
{ coord3[0] = 0.;coord3[1] = 0.;coord3[2] = 0.;
};
{ coord3[0] = 0.;coord3[1] = 0.;coord3[2] = 0.;
};
// Calcul de la norme euclidienne des composantes du point
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee3B::Norme () const
{ return sqrt( coord3[0] * coord3[0] + coord3[1] * coord3[1] +
{ return sqrt( coord3[0] * coord3[0] + coord3[1] * coord3[1] +
coord3[2] * coord3[2] );
};
// norme le vecteur coordonnée
@ -322,18 +322,18 @@ double Coordonnee3B::Norme () const
inline
#endif
Coordonnee3B& Coordonnee3B::Normer ()
{ double norme = this->Norme();
{ double norme = this->Norme();
#ifdef MISE_AU_POINT
if(Dabs(norme) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee3B::Normer () " << endl;
Sortie (1);
if(Dabs(norme) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee3B::Normer () " << endl;
Sortie (1);
}
#endif
*this /= norme;
return *this ;
};
*this /= norme;
return *this ;
};
// somme de tous les composantes
#ifndef MISE_AU_POINT
inline
@ -341,8 +341,8 @@ Coordonnee3B& Coordonnee3B::Normer ()
double Coordonnee3B::Somme() const
{
return ( coord3[0] + coord3[1] + coord3[2] );
};
};
// calcul du déterminant de trois vecteurs
#ifndef MISE_AU_POINT
inline
@ -352,7 +352,7 @@ double Coordonnee3B::Determinant3B( const Coordonnee3B & v1, const Coordonnee3B
+(v2.coord3[0] * v1.coord3[2] - v1.coord3[0] * v2.coord3[2])* v3.coord3[1]
+(v1.coord3[0] * v2.coord3[1] - v2.coord3[0] * v1.coord3[1])* v3.coord3[2] ) ;
return toto;
};
};
// calcul du produit vectoriel de 2 vecteurs coordonnées
#ifndef MISE_AU_POINT
@ -363,7 +363,7 @@ Coordonnee3H Coordonnee3B::Vectoriel( const Coordonnee3B & v1, const Coordonnee3
(v2.coord3[0] * v1.coord3[2] - v1.coord3[0] * v2.coord3[2]),
(v1.coord3[0] * v2.coord3[1] - v2.coord3[0] * v1.coord3[1]));
return ret;
};
};
/* // Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees
#ifndef MISE_AU_POINT
@ -378,45 +378,45 @@ Coordonnee3H Coordonnee3B::Vectoriel( const Coordonnee3B & v1, const Coordonnee3
// sortie du schemaXML: en fonction de enu
void Coordonnee3B::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu)
{
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** CoordonneeB dim 3 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_3B\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 3: elements: "
<< "\n 3 reels "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" >"
<< "\n <xs:simpleType>"
<< "\n <xs:restriction base=\"liste_de_reels\">"
<< "\n <xs:minLength value=\"3\" />"
<< "\n <xs:maxLength value=\"3\" />"
<< "\n </xs:restriction>"
<< "\n </xs:simpleType>"
<< "\n </xs:element>"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
default: cout << "\n *** attention cas non pris en compte pour le moment "
<< " XML_TYPE_GLOBAUX= "<<XML_TYPE_GLOBAUX
<< " Coordonnee3B::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) "
<< endl;
};
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** CoordonneeB dim 3 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_3B\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 3: elements: "
<< "\n 3 reels "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" >"
<< "\n <xs:simpleType>"
<< "\n <xs:restriction base=\"liste_de_reels\">"
<< "\n <xs:minLength value=\"3\" />"
<< "\n <xs:maxLength value=\"3\" />"
<< "\n </xs:restriction>"
<< "\n </xs:simpleType>"
<< "\n </xs:element>"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
default: cout << "\n *** attention cas non pris en compte pour le moment "
<< " XML_TYPE_GLOBAUX= "<<XML_TYPE_GLOBAUX
<< " Coordonnee3B::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) "
<< endl;
};
};

296
tenseurs_mai99/Coordonnees/Coordonnee3H.cc
View file

@ -51,8 +51,8 @@ using namespace std; //introduces namespace std
#endif
Coordonnee3H::Coordonnee3H () :
CoordonneeH(3,coord3)
{ coord3[0] = 0.;coord3[1] = 0.;coord3[2] = 0.;
};
{ coord3[0] = 0.;coord3[1] = 0.;coord3[2] = 0.;
};
// Constructeur suivant un booleen
// quelque soit la valeur du booleen il n'y a pas initialisation des coordonnées
@ -70,10 +70,10 @@ Coordonnee3H::Coordonnee3H (bool ):
Coordonnee3H::Coordonnee3H (double x,double y,double z):
CoordonneeH(3,coord3)
// Constructeur pour un point a trois dimensions
{ coord3[0]=x;
coord3[1]=y;
coord3[2]=z;
};
{ coord3[0]=x;
coord3[1]=y;
coord3[2]=z;
};
// constructeur fonction d'une adresse memoire ou sont stockee les coordonnees
// et d'une dimension ( l'existance de la place mémoire est a la charge
@ -83,10 +83,10 @@ Coordonnee3H::Coordonnee3H (double x,double y,double z):
#endif
Coordonnee3H::Coordonnee3H (double* t):
CoordonneeH(3,coord3)
{ coord3[0]=t[0];
coord3[1]=t[1];
coord3[2]=t[2];
};
{coord3[0]=t[0];
coord3[1]=t[1];
coord3[2]=t[2];
};
// Constructeur de copie
#ifndef MISE_AU_POINT
@ -94,8 +94,8 @@ Coordonnee3H::Coordonnee3H (double* t):
#endif
Coordonnee3H::Coordonnee3H (const Coordonnee3H& c):
CoordonneeH(3,coord3)
{ coord3[0]=c.coord3[0];coord3[1]=c.coord3[1];coord3[2]=c.coord3[2];
};
{ coord3[0]=c.coord3[0];coord3[1]=c.coord3[1];coord3[2]=c.coord3[2];
};
// Constructeur de copie pour une instance indiférenciée
#ifndef MISE_AU_POINT
@ -103,42 +103,42 @@ Coordonnee3H::Coordonnee3H (const Coordonnee3H& c):
#endif
Coordonnee3H::Coordonnee3H (const CoordonneeH& c):
CoordonneeH(3,coord3)
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 3)
{ cout << "\nErreur la dimension de c est différente de 3 !! !\n";
cout << "Coordonnee3H::Coordonnee3H (const Coordonnee& c) \n";
Sortie(1);
}
#endif
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 3)
{ cout << "\nErreur la dimension de c est différente de 3 !! !\n";
cout << "Coordonnee3H::Coordonnee3H (const Coordonnee& c) \n";
Sortie(1);
}
#endif
coord3[0]=c(1);coord3[1]=c(2);
coord3[2]=c(3);
};
};
// DESTRUCTEUR :
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3H::~Coordonnee3H ()
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
coord=NULL;
#endif
};
// Desallocation de la place memoire allouee
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3H::Libere ()
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee3H::Libere () \n";
Sortie(1);
#endif
};
{ dim = 0; // pour l'appel de ~Coordonnee()
#ifdef MISE_AU_POINT
coord=NULL;
#endif
};
//// Desallocation de la place memoire allouee
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee3H::Libere ()
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee3H::Libere () \n";
// Sortie(1);
// #endif
// };
// Renvoie le nombre de coordonnees
@ -146,112 +146,112 @@ void Coordonnee3H::Libere ()
inline
#endif
int Coordonnee3H::Dimension () const
{ return 3; };
{ return 3; };
// changement de la dimension
// fonction définie dans la classe mère générique mais qui n'a pas de
// sens ici
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3H::Change_dim(int )
{
#ifdef MISE_AU_POINT
cout << "\nErreur cette fonction n'a pas cours !! !\n";
cout << "Coordonnee3H::Change_dim(int dimen) \n";
Sortie(1);
#endif
};
//// changement de la dimension
//// fonction définie dans la classe mère générique mais qui n'a pas de
//// sens ici
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee3H::Change_dim(int )
// {
// #ifdef MISE_AU_POINT
// cout << "\nErreur cette fonction n'a pas cours !! !\n";
// cout << "Coordonnee3H::Change_dim(int dimen) \n";
// Sortie(1);
// #endif
// };
// Surcharge de l'operateur = : realise l'affectation entre deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3H& Coordonnee3H::operator= (const Coordonnee3H& c)
{ coord3[0]=c.coord3[0];coord3[1]=c.coord3[1];coord3[2]=c.coord3[2];
return (*this);
{ coord3[0]=c.coord3[0];coord3[1]=c.coord3[1];coord3[2]=c.coord3[2];
return (*this);
};
// Surcharge de l'operateur - : renvoie l'oppose d'un point
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3H Coordonnee3H::operator- () const
{ return Coordonnee3H(-coord3[0],-coord3[1],-coord3[2]);
};
{ return Coordonnee3H(-coord3[0],-coord3[1],-coord3[2]);
};
// Surcharge de l'operateur - : realise la soustraction des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3H Coordonnee3H::operator- (const Coordonnee3H& c) const
{ return Coordonnee3H(coord3[0]-c.coord3[0],coord3[1]-c.coord3[1],
coord3[2]-c.coord3[2]);
};
{ return Coordonnee3H(coord3[0]-c.coord3[0],coord3[1]-c.coord3[1],
coord3[2]-c.coord3[2]);
};
// Surcharge de l'operateur + : realise l'addition des
// coordonnees de deux points
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3H Coordonnee3H::operator+ (const Coordonnee3H& c) const
{ return Coordonnee3H(coord3[0]+c.coord3[0],coord3[1]+c.coord3[1],
coord3[2]+c.coord3[2]);
};
{ return Coordonnee3H(coord3[0]+c.coord3[0],coord3[1]+c.coord3[1],
coord3[2]+c.coord3[2]);
};
// Surcharge de l'operateur +=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3H::operator+= (const Coordonnee3H& c)
{ coord3[0]+=c.coord3[0];
coord3[1]+=c.coord3[1];
coord3[2]+=c.coord3[2];
};
{ coord3[0]+=c.coord3[0];
coord3[1]+=c.coord3[1];
coord3[2]+=c.coord3[2];
};
// Surcharge de l'operateur -=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3H::operator-= (const Coordonnee3H& c)
{ coord3[0]-=c.coord3[0];
coord3[1]-=c.coord3[1];
coord3[2]-=c.coord3[2];
};
{ coord3[0]-=c.coord3[0];
coord3[1]-=c.coord3[1];
coord3[2]-=c.coord3[2];
};
// Surcharge de l'operateur *=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3H::operator*= (double val)
{ coord3[0]*=val;coord3[1]*=val;coord3[2]*=val;
};
{ coord3[0]*=val;coord3[1]*=val;coord3[2]*=val;
};
// Surcharge de l'operateur * : multiplication de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee3H Coordonnee3H::operator* (double val) const
{ return Coordonnee3H(val*coord3[0],val*coord3[1],val*coord3[2]);
};
{ return Coordonnee3H(val*coord3[0],val*coord3[1],val*coord3[2]);
};
// Surcharge de l'operateur * : produit scalaire entre coordonnees
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee3H::operator* (const Coordonnee3B& c) const
{ return ( coord3[0] * c.coord3[0] + coord3[1] * c.coord3[1] +
{ return ( coord3[0] * c.coord3[0] + coord3[1] * c.coord3[1] +
coord3[2] * c.coord3[2] );
};
// produit scalaire entre coordonnees contravariantes et contravariantes
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee3H::ScalHH(const Coordonnee3H& c) const
{ return ( coord3[0] * c.coord3[0] + coord3[1] * c.coord3[1] +
{ return ( coord3[0] * c.coord3[0] + coord3[1] * c.coord3[1] +
coord3[2] * c.coord3[2] );
};
@ -260,23 +260,23 @@ double Coordonnee3H::ScalHH(const Coordonnee3H& c) const
inline
#endif
Coordonnee3H Coordonnee3H::operator/ (double val) const
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee3H::operator/ (double val) " << endl;
Sortie (1);
}
}
#endif
return Coordonnee3H(coord3[0] / val,coord3[1] / val,coord3[2] / val);
return Coordonnee3H(coord3[0] / val,coord3[1] / val,coord3[2] / val);
};
// Surcharge de l'operateur /= : division de coordonnees par un scalaire
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee3H::operator/= (double val)
{
{
#ifdef MISE_AU_POINT
if(Dabs(val) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
@ -294,12 +294,12 @@ void Coordonnee3H::operator/= (double val)
inline
#endif
int Coordonnee3H::operator== (const Coordonnee3H& c) const
{ if ((c.coord3[0]!=coord3[0]) || (c.coord3[1]!=coord3[1])
|| (c.coord3[2]!=coord3[2]))
return 0;
else
return 1;
};
{ if ((c.coord3[0]!=coord3[0]) || (c.coord3[1]!=coord3[1])
|| (c.coord3[2]!=coord3[2]))
return 0;
else
return 1;
};
// mise a zero des coordonnées
@ -307,15 +307,15 @@ int Coordonnee3H::operator== (const Coordonnee3H& c) const
inline
#endif
void Coordonnee3H::Zero()
{ coord3[0] = 0.;coord3[1] = 0.;coord3[2] = 0.;
};
{ coord3[0] = 0.;coord3[1] = 0.;coord3[2] = 0.;
};
// Calcul de la norme euclidienne des composantes du point
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee3H::Norme () const
{ return sqrt( coord3[0] * coord3[0] + coord3[1] * coord3[1] +
{ return sqrt( coord3[0] * coord3[0] + coord3[1] * coord3[1] +
coord3[2] * coord3[2] );
};
// norme le vecteur coordonnée
@ -323,18 +323,18 @@ double Coordonnee3H::Norme () const
inline
#endif
Coordonnee3H& Coordonnee3H::Normer ()
{ double norme = this->Norme();
{ double norme = this->Norme();
#ifdef MISE_AU_POINT
if(Dabs(norme) <= ConstMath::trespetit)
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonnee3H::Normer () " << endl;
Sortie (1);
}
}
#endif
*this /= norme;
return *this ;
};
*this /= norme;
return *this ;
};
// somme de tous les composantes
#ifndef MISE_AU_POINT
inline
@ -342,7 +342,7 @@ Coordonnee3H& Coordonnee3H::Normer ()
double Coordonnee3H::Somme() const
{
return ( coord3[0] + coord3[1] + coord3[2] );
};
};
/* // Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees
#ifndef MISE_AU_POINT
@ -357,45 +357,45 @@ double Coordonnee3H::Somme() const
// sortie du schemaXML: en fonction de enu
void Coordonnee3H::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu)
{
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** CoordonneeH dim 3 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_3H\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 3: elements: "
<< "\n 3 reels "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" >"
<< "\n <xs:simpleType>"
<< "\n <xs:restriction base=\"liste_de_reels\">"
<< "\n <xs:minLength value=\"3\" />"
<< "\n <xs:maxLength value=\"3\" />"
<< "\n </xs:restriction>"
<< "\n </xs:simpleType>"
<< "\n </xs:element>"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
default: cout << "\n *** attention cas non pris en compte pour le moment "
<< " XML_TYPE_GLOBAUX= "<<XML_TYPE_GLOBAUX
<< " Coordonnee3H::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) "
<< endl;
};
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** CoordonneeH dim 3 *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_3H\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> coordonnee de dimension 3: elements: "
<< "\n 3 reels "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n <xs:sequence>"
<< "\n <xs:element name=\"coordonnees\" >"
<< "\n <xs:simpleType>"
<< "\n <xs:restriction base=\"liste_de_reels\">"
<< "\n <xs:minLength value=\"3\" />"
<< "\n <xs:maxLength value=\"3\" />"
<< "\n </xs:restriction>"
<< "\n </xs:simpleType>"
<< "\n </xs:element>"
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
default: cout << "\n *** attention cas non pris en compte pour le moment "
<< " XML_TYPE_GLOBAUX= "<<XML_TYPE_GLOBAUX
<< " Coordonnee3H::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) "
<< endl;
};
};

849
tenseurs_mai99/Coordonnees/CoordonneeB.cc
View file

File diff suppressed because it is too large Load diff

780
tenseurs_mai99/Coordonnees/CoordonneeH.cc
View file

File diff suppressed because it is too large Load diff