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

35
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
////------ 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
// }
//// (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);

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

@ -97,6 +97,9 @@ void Front::Affiche(int cas) const
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 "
@ -120,10 +123,13 @@ void Front::Affiche(int cas) const
}
else
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

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

@ -85,7 +85,8 @@ 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)
@ -98,7 +99,7 @@ Hexa::Hexa () :
{ 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 :

76
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;
@ -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
@ -93,30 +98,37 @@ HexaQ::HexaQ () :
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,33 +137,41 @@ 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;
{ // 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); }
Sortie (1);
}
// 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 -> nombre->nbiEr
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)
@ -162,11 +182,12 @@ HexaQ::HexaQ (int num_mail,int num_id,const Tableau<Noeud *>& tab):
#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 = 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++;
};
};
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;

79
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,6 +70,11 @@ HexaQComp::NombresConstruireHexaQComp::NombresConstruireHexaQComp()
// Constructeur par defaut, le seul accepte en dimension different de 3
HexaQComp::HexaQComp () :
HexaMemb(0,-3,QUADRACOMPL,HEXAEDRE)
{// 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
@ -78,7 +83,7 @@ HexaQComp::HexaQComp () :
// 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 == 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,32 +102,38 @@ HexaQComp::HexaQComp () :
}
else
{ unefois = & uneFois; // affectation du pointeur de la classe générique triangle
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg);
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)
{// 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 doCoHexa egalement si c'est le premier passage
// 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)
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)
@ -130,72 +141,88 @@ HexaQComp::HexaQComp (int num_mail,int num_id) :
<< "\n alors que l'on doit avoir 3 !! " << endl;
Sortie (1);
}
// #endif
// #endif
else
{unefois = & uneFois; // affectation du pointeur de la classe générique
doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg);
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;
{// 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 doCoHexa egalement si c'est le premier passage
// 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)
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);}
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
}
// #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
// #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);
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
// 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)
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
@ -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.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.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.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;

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
};

17
Lecture/utilLecture2.cc
View file

@ -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);
};
};
@ -477,6 +483,7 @@ 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;
if (proc_en_cours==0)
MPI_File_close(&ent_MPI_PI);
ent_MPI_PI=MPI_FILE_NULL;indic_ent_MPI_PI = 1;
};
@ -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

450
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,7 +2237,7 @@ 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)
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 $$ ";
@ -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
#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);
@ -2333,8 +2536,6 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
<< 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:
@ -2420,7 +2618,11 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau <Tableau <
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é

308
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,18 +1298,21 @@ 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;
@ -1264,12 +1325,23 @@ bool LesContacts::DefElemCont(double dep_max)
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()
{
#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() ;

14
contact/LesContacts_2.cc
View file

@ -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,6 +319,7 @@ 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
else
{if (ParaGlob::NiveauImpression() > 0)

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

256
tenseurs_mai99/Coordonnees/Coordonnee.cc
View file

@ -53,7 +53,7 @@ using namespace std; //introduces namespace std
#endif
Coordonnee::Coordonnee () :
dim (0) , coord (NULL),memoire(true)
{};
{};
// Constructeur utile si le nombre de coordonnees est connue
// N.B. : les valeurs sont affectees a 0.
@ -62,12 +62,12 @@ Coordonnee::Coordonnee () :
#endif
Coordonnee::Coordonnee (int dimension) :
dim ((short)dimension), memoire(true),coord (NULL)
{ if (dim == 0) return;
{ if (dim == 0) return;
#ifdef MISE_AU_POINT
if ( (dimension<0) || (dimension>3) )
{
cout << "\nErreur de dimension !\n";
cout << "COORDONNEE::COORDONNEE (int ) \n";
{cout << "\nErreur de dimension !\n";
cout << "\n la dimension demandée est "<<dimension << ", elle ne peut-etre que 0 1 2 ou 3";
cout << "Coordonnee::Coordonnee (int ) \n";
Sortie(1);
};
#endif
@ -77,7 +77,7 @@ Coordonnee::Coordonnee (int dimension) :
case 2: coord[1]=0.0;
case 1: coord[0]=0.0;
};
};
};
// Constructeur pour un point a une dimension
#ifndef MISE_AU_POINT
@ -85,9 +85,9 @@ Coordonnee::Coordonnee (int dimension) :
#endif
Coordonnee::Coordonnee (double x) :
dim (1),memoire(true)
{ coord=new double [1];
{ coord=new double [1];
coord[0]=x;
};
};
// Constructeur pour un point a deux dimensions
#ifndef MISE_AU_POINT
@ -95,10 +95,10 @@ Coordonnee::Coordonnee (double x) :
#endif
Coordonnee::Coordonnee (double x,double y) :
dim (2),memoire(true)
{ coord=new double [2];
{ coord=new double [2];
coord[0]=x;
coord[1]=y;
};
};
// Constructeur pour un point a trois dimensions
#ifndef MISE_AU_POINT
@ -106,16 +106,17 @@ Coordonnee::Coordonnee (double x,double y) :
#endif
Coordonnee::Coordonnee (double x,double y,double z) :
dim (3) ,memoire(true)
{ coord=new double [3];
{ coord=new double [3];
coord[0]=x;
coord[1]=y;
coord[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
// de l'utilisateur.
// DANS CE CAS IL N'Y A PAS DE CREATION DE MEMOIRE !!
// de même il n'y aura pas de redimentionnement possible
#ifndef MISE_AU_POINT
inline
#endif
@ -125,8 +126,8 @@ Coordonnee::Coordonnee (int dimension,double* t) :
// Constructeur de copie
// mais là on construit systématiquement un vrai coordonnée
// même si la mémoire est fausse, car on ne veut pas que plusieur
// coordonnée pointes sur les mêmes valeurs, sans précautions supplémentaires
// même si c.memoire est faux, car on ne veut pas que plusieurs
// coordonnées pointes sur les mêmes valeurs, sans précautions supplémentaires
#ifndef MISE_AU_POINT
inline
#endif
@ -147,67 +148,61 @@ Coordonnee::Coordonnee (const Coordonnee& c) :
// Destructeur
// Desallocation de la place memoire allouee
// dans le cas où la mémoire n'est pas gérée localement -> aucune action
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee::~Coordonnee ()
{if (memoire)
{ if (memoire)
{ if (dim > 0)
{ delete [] coord;
coord=NULL;
dim=0;
}
#ifdef MISE_AU_POINT
else
{if ( coord!=NULL )
{ cout << "\nErreur de liberation de la place memoire\n";
cout << "COORDONNEE::LIBERE () \n";
Sortie(1);
}
}
#endif
}
};
};
};
// 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.)
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee::Change_place(int dimension,double* t)
{ // on commence par libérer la place
Libere();
// création en fonction de la dimension
dim = dimension;
switch (dim)
{ case 0: memoire = true; break; // on met à true, car de toute manière il n'y a pas de mémoire
case 1: case 2: case 3: { memoire = false; coord = t; break;} // cas normal
default:
{ cout << "\n erreur la dimension n'est entre 0 et 3 : " << dimension
<< "\n Coordonnee::Change_place(int dimension,double* t)";
Sortie(1);
}
};
};
//// 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.)
//#ifndef MISE_AU_POINT
// inline
//#endif
//void Coordonnee::Change_place(int dimension,double* t)
// { // on commence par libérer la place
// Libere();
// // création en fonction de la dimension
// dim = dimension;
// switch (dim)
// { case 0: memoire = true; break; // on met à true, car de toute manière il n'y a pas de mémoire
// case 1: case 2: case 3: { memoire = false; coord = t; break;} // cas normal
// default:
// { cout << "\n erreur la dimension n'est entre 0 et 3 : " << dimension
// << "\n Coordonnee::Change_place(int dimension,double* t)";
// Sortie(1);
// }
// };
// };
// changement des coordonnees
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee::Change_Coordonnee(int dimension, double x) // dimension 1
{ if (dim == dimension) { coord[0] = x; }
{ if (dim == dimension) { coord[0] = x; }
// si pb avec memoire == false, l'erreur est détectée au niveau de Change_dim
else { Change_dim(dimension); coord[0] = x; };
};
};
// changement des coordonnees
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee::Change_Coordonnee(int dimension, double x,double y) // dimension 2
{ if (dim != dimension) Change_dim(dimension);
{ if (dim != dimension) Change_dim(dimension);
// si pb avec memoire == false, l'erreur est détectée au niveau de Change_dim
coord[0] = x; coord[1] = y;
};
};
// changement des coordonnees
#ifndef MISE_AU_POINT
@ -215,6 +210,7 @@ void Coordonnee::Change_Coordonnee(int dimension, double x,double y) // dimens
#endif
void Coordonnee::Change_Coordonnee(int dimension, double x,double y,double z) // dimension 3
{ if (dim != dimension) Change_dim(dimension);
// si pb avec memoire == false, l'erreur est détectée au niveau de Change_dim
coord[0] = x; coord[1] = y; coord[2] = z;
};
@ -226,20 +222,38 @@ int Coordonnee::Dimension () const
{ return dim; };
// Desallocation de la place memoire allouee
// uniquement dans le cas où la mémoire est gérée localement
// sinon aucune action
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee::Libere ()
{if (memoire)
{ if (dim > 0)
{ delete [] coord;
coord=NULL;
dim=0;
{if (memoire)
{
if ((dim > 0) && (coord==NULL))
{ cout << "\n***Erreur de liberation de la place memoire\n";
cout << "\n la dimension locale est non nulle "<<dim
<< " et le pointeur de tableau est "
<< " null, ce n'est pas normal !! ";
cout << "Coordonnee::Libere() \n";
Sortie(1);
}
if (dim > 0)
{ delete [] coord;}
else
{if ( coord!=NULL )
{ cout << "\n***Erreur de liberation de la place memoire\n";
cout << "\n la dimension locale est nulle et le pointeur de tableau est "
<< " non null, ce n'est pas normal !! ";
cout << "Coordonnee::Libere() \n";
Sortie(1);
}
};
coord=NULL;
dim=0;
};
}
};
// Renvoie la ieme coordonnee
#ifndef MISE_AU_POINT
@ -249,8 +263,10 @@ double& Coordonnee::operator() (int i)
{
#ifdef MISE_AU_POINT
if ( (i<1) || (i>dim) )
{ cout << "\nErreur de dimension !\n";
cout << "COORDONNEE::OPERATOR() (int ) \n";
{cout << "\nErreur de dimension !\n";
cout <<"\n on demande la coordonnee i="<<i
<< " alors que dim du point = "<< dim << " !!!";
cout << "Coordonnee::operator() (int ) \n"<< flush;
Sortie(1);
};
#endif
@ -265,8 +281,10 @@ double Coordonnee::operator() (int i) const
{
#ifdef MISE_AU_POINT
if ( (i<1) || (i>dim) )
{ cout << "\nErreur de dimension !\n";
cout << "COORDONNEE::OPERATOR() (int ) \n";
{cout << "\nErreur de dimension !\n";
cout <<"\n on demande la coordonnee i="<<i
<< " alors que dim du point = "<< dim << " !!!";
cout << "Coordonnee::operator() (int ) \n"<< flush;
Sortie(1);
};
#endif
@ -276,11 +294,14 @@ double Coordonnee::operator() (int i) const
// 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`
// possible uniquement si la mémoire est gérée localement
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee::Change_dim(int dimen)
{ if (dimen == dim) return; // même dimension, on ne fait rien
if (memoire)
{
#ifdef MISE_AU_POINT
if ((dimen<0) || (dimen>3))
{ cout << "\n erreur, la nouvelle dimension doit etre comprise entre 0 et 3 ! ";
@ -296,17 +317,7 @@ void Coordonnee::Change_dim(int dimen)
Libere();
}
else if (dim < dimen) // cas où la nouvelle dimension est supérieur
{// dans le cas où il n'y a pas eu allocation, donc que la mémoire n'est
// pas gérée par l'objet, on ne peut pas changer de dimension
if (!memoire)
{ cout << "\n erreur, l'objet ne gere pas sa memoire, donc le changement de dim "
<< " n'est pas possible !! ";
cout << "\n dim voulue = " << dimen << " ancienne dimension: " << dim ;
cout << "\nCoordonnee::Change_dim(int dim) " << endl;
Sortie(1);
};
// donc pour la suite on considère que l'élément gère sa mémoire
// les dimensions sont 1 ou 2 ou 3
{ // les dimensions sont 1 ou 2 ou 3
// et le cas même dimension a déjà été réglé, donc ici il y a forcément
// une différence
if (dim ==0 ) // cas où rien n'exitait et dimen > 0
@ -352,10 +363,20 @@ void Coordonnee::Change_dim(int dimen)
};
if (dim > 0) delete [] sauve;
dim = (short) dimen;
};
}
else
{cout << "\n *** erreur de modification de la dimension d'un CoordonneeB "
<< "\n la memoire n'est pas gere localement et la dimension demandee: "<<dimen
<< " est differente de la dimension existante: "<<dim << " !! "
<< "\n CoordonneeB::Change_dim(int dimen) "<< flush;
Sortie(1);
};
};
// Surcharge de l'operateur = : realise l'affectation entre deux points
// adaptation de la dimension si la mémoire est gérée localement
// sinon ce n'est pas possible -> erreur
#ifndef MISE_AU_POINT
inline
#endif
@ -369,7 +390,7 @@ Coordonnee& Coordonnee::operator= (const Coordonnee& c)
};
return (*this);
}
else if ( c.dim==0 )
else if (( c.dim==0 )&&(memoire))
{ Libere();}
else
{ if (!memoire)
@ -405,7 +426,7 @@ Coordonnee& Coordonnee::operator= (const Coordonnee& c)
inline
#endif
Coordonnee Coordonnee::operator- () const
{ Coordonnee result(dim);
{ Coordonnee result(dim);
switch (dim)
{case 3: result.coord[2]=-coord[2];
case 2: result.coord[1]=-coord[1];
@ -413,7 +434,7 @@ Coordonnee Coordonnee::operator- () const
case 0: ; // on fait rien
};
return result;
};
};
// Surcharge de l'operateur - : realise la soustraction des
// coordonnees de deux points
@ -425,8 +446,8 @@ Coordonnee Coordonnee::operator- (const Coordonnee& c) const
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{
cout << "\nErreur : dimensions non egales !\n";
cout << "COORDONNEE::OPERATOR- (Coordonnee ) \n";
cout << "\nErreur : dimensions: dim "<<dim<<" et c.dim"<< c.dim <<" non egales !\n";
cout << "Coordonnee::operator- (Coordonnee ) \n";
Sortie(1);
};
#endif
@ -449,8 +470,8 @@ Coordonnee Coordonnee::operator+ (const Coordonnee& c) const
{
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{ cout << "\nErreur : dimensions non egales !\n";
cout << "COORDONNEE::OPERATOR+ (Coordonnee ) \n";
{cout << "\nErreur : dimensions: dim "<<dim<<" et c.dim"<< c.dim <<" non egales !\n";
cout << "Coordonnee::operator+ (Coordonnee ) \n";
Sortie(1);
};
#endif
@ -469,11 +490,11 @@ Coordonnee Coordonnee::operator+ (const Coordonnee& c) const
inline
#endif
void Coordonnee::operator+= (const Coordonnee& c)
{
{
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{ cout << "\nErreur : dimensions non egales !\n";
cout << "COORDONNEE::OPERATOR+= (Coordonnee ) \n";
{cout << "\nErreur : dimensions: dim "<<dim<<" et c.dim"<< c.dim <<" non egales !\n";
cout << "Coordonnee::operator+= (Coordonnee ) \n";
Sortie(1);
};
#endif
@ -483,18 +504,18 @@ void Coordonnee::operator+= (const Coordonnee& c)
case 1: coord[0]+=c.coord[0];
case 0: ; // on fait rien
};
};
};
// Surcharge de l'operateur -=
#ifndef MISE_AU_POINT
inline
#endif
void Coordonnee::operator-= (const Coordonnee& c)
{
{
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{ cout << "\nErreur : dimensions non egales !\n";
cout << "COORDONNEE::OPERATOR-= (Coordonnee ) \n";
{cout << "\nErreur : dimensions: dim "<<dim<<" et c.dim"<< c.dim <<" non egales !\n";
cout << "Coordonnee::operator-= (Coordonnee ) \n";
Sortie(1);
};
#endif
@ -504,7 +525,7 @@ void Coordonnee::operator-= (const Coordonnee& c)
case 1: coord[0]-=c.coord[0];
case 0: ; // on fait rien
};
};
};
// Surcharge de l'operateur *=
#ifndef MISE_AU_POINT
@ -523,7 +544,7 @@ void Coordonnee::operator*= (double val)
inline
#endif
Coordonnee Coordonnee::operator* (double val) const
{ Coordonnee result(dim);
{ Coordonnee result(dim);
switch (dim)
{case 3: result.coord[2]=val*coord[2];
case 2: result.coord[1]=val*coord[1];
@ -531,14 +552,21 @@ Coordonnee Coordonnee::operator* (double val) const
case 0: ; // on fait rien
};
return result;
};
};
// Surcharge de l'operateur * : produit scalaire entre coordonnees
#ifndef MISE_AU_POINT
inline
#endif
double Coordonnee::operator* (const Coordonnee& c) const
{ double res=0.0;
{double res=0.0;
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{cout << "\nErreur : dimensions: dim "<<dim<<" et c.dim"<< c.dim <<" non egales !\n";
cout << "Coordonnee::operator* (const Coordonnee& c) \n";
Sortie(1);
};
#endif
switch (dim)
{case 3: res += coord[2] * c.coord[2];
case 2: res += coord[1] * c.coord[1];
@ -546,7 +574,7 @@ double Coordonnee::operator* (const Coordonnee& c) const
case 0: ; // on fait rien
};
return res;
};
};
// Surcharge de l'operateur / : division de coordonnees par un scalaire
#ifndef MISE_AU_POINT
@ -569,7 +597,7 @@ Coordonnee Coordonnee::operator/ (double val) const
case 0: ; // on fait rien
};
return result;
};
};
// Surcharge de l'operateur /= : division de coordonnees par un scalaire
#ifndef MISE_AU_POINT
@ -599,10 +627,10 @@ void Coordonnee::operator/= (double val)
inline
#endif
int Coordonnee::operator== (const Coordonnee& c) const
{ if ( c.dim!=dim )
return 0;
{if ( c.dim!=dim )
{return 0;}
else
{ for (int i=0;i<dim;i++)
{for (int i=0;i<dim;i++)
{ if ( c.coord[i]!=coord[i] )
return 0;
};
@ -643,7 +671,7 @@ void Coordonnee::Affiche () const
inline
#endif
void Coordonnee::Affiche (ostream& sort) const
{ sort << "\t{ " ;
{ sort << "\t{ " ;
switch (dim)
{case 0: break; // on fait rien
case 1: sort << coord[0] << " "; break;
@ -651,7 +679,7 @@ void Coordonnee::Affiche (ostream& sort) const
case 3: sort << coord[0] << " "<< coord[1] << " "<< coord[2] << " " ;break;
};
sort << "}\n" ;
};
};
// Affiche les coordonnees du point dans sort sur nb digit plus un blanc
// et rien d'autre
@ -689,13 +717,13 @@ void Coordonnee::Affiche_1(ostream& sort) const
inline
#endif
void Coordonnee::Zero()
{ switch (dim)
{switch (dim)
{case 3: coord[2]=0.;
case 2: coord[1]=0.;
case 1: coord[0]=0.;
case 0: ; // on fait rien
};
};
};
// surcharge de l'operateur de lecture dans la mémoire
#ifndef MISE_AU_POINT
@ -797,7 +825,7 @@ ostream & operator << ( ostream & sort,const Coordonnee & coo)
inline
#endif
double Coordonnee::Norme () const
{ double norme=0.0;
{ double norme=0.0;
switch (dim)
{case 3: norme+=coord[2] * coord[2];
case 2: norme+=coord[1] * coord[1];
@ -805,9 +833,9 @@ double Coordonnee::Norme () const
case 0: ;
};
return sqrt(norme);
// norme=sqrt((double)norme); // calcul de la norme
// return norme;
};
// norme=sqrt((double)norme); // calcul de la norme
// return norme;
};
// norme le vecteur coordonnée
#ifndef MISE_AU_POINT
@ -831,7 +859,7 @@ Coordonnee& Coordonnee::Normer ()
#endif
// Retourne le maximum en valeur absolue des composantes
double Coordonnee::Max_val_abs () const
{ double maxi=0.;
{ double maxi=0.;
switch (dim)
{ case 3: maxi=DabsMaX(maxi,coord[2]);
case 2: maxi=DabsMaX(maxi,coord[1]);
@ -839,7 +867,7 @@ double Coordonnee::Max_val_abs () const
case 0: break;
};
return maxi;
};
};
#ifndef MISE_AU_POINT
@ -854,7 +882,7 @@ int Coordonnee::Indice_max_val_abs() const
case 1: if (maxi < Dabs(coord[0])) {maxi = Dabs(coord[0]),indice = 1;}
case 0: break;
};
return maxi;
return indice;
};
@ -880,7 +908,7 @@ double Coordonnee::Max_val_abs (int& in) const
// Retourne le maximum en valeur absolue des composantes du Coordonnee
// mais ramène la grandeur signée (avec son signe)
double Coordonnee::Max_val_abs_signe () const
{ double maxi=0.;
{ double maxi=0.;
int in = 0;
switch (dim)
{ case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;}
@ -890,7 +918,7 @@ double Coordonnee::Max_val_abs_signe () const
};
if (in != 0) {return coord[in-1];}
else {return maxi;};
};
};
#ifndef MISE_AU_POINT
inline
@ -898,7 +926,7 @@ double Coordonnee::Max_val_abs_signe () const
// Retourne le maximum en valeur absolue des composantes du Coordonnee
// mais ramène la grandeur signée (avec son signe) et l'indice
double Coordonnee::Max_val_abs_signe (int& in) const
{ double maxi=0.;
{ double maxi=0.;
in = 0;
switch (dim)
{ case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;}
@ -908,7 +936,7 @@ double Coordonnee::Max_val_abs_signe (int& in) const
};
if (in != 0) {return coord[in-1];}
else {return maxi;};
};
};
#ifndef MISE_AU_POINT
@ -960,7 +988,7 @@ void Coordonnee::Modif_en_min(const Coordonnee& v)
#endif
// ajoute une même valeur à tous les coordonnées
void Coordonnee::Ajout_meme_valeur(double val)
{ switch (dim)
{ switch (dim)
{case 3: coord[2] += val;
case 2: coord[1] += val;
case 1: coord[0] += val;
@ -1021,11 +1049,12 @@ void Coordonnee::Meme_place(CoordonneeB& vB)
{ // on regarde s'il faut faire quelque chose pour optimiser
if (coord != vB.coord)
{ // on commence par libérer la place
// si memoire = false, il n'y a aucune modif
Libere();
// création en fonction de la dimension
dim = vB.dim;
switch (dim)
{ case 0: memoire = true; break; // on met à true, car de toute manière il n'y a pas de mémoire
{ case 0: memoire = true; coord=NULL; break; // on met à true, car de toute manière il n'y a pas de mémoire
default:
{ memoire = false; coord = vB.coord;}
};
@ -1041,13 +1070,14 @@ void Coordonnee::Meme_place(CoordonneeH& vH)
{ // on regarde s'il faut faire quelque chose pour optimiser
if (coord != vH.coord)
{ // on commence par libérer la place
// si memoire = false, il n'y a aucune modif
Libere();
// création en fonction de la dimension
dim = vH.dim;
switch (dim)
{ case 0: memoire = true; break; // on met à true, car de toute manière il n'y a pas de mémoire
default:
{ memoire = false; coord = vH.coord;}
{ memoire = false; coord=NULL;coord = vH.coord;}
};
};
};

32
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
/// 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
/// 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

67
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,7 +69,7 @@ Coordonnee1::Coordonnee1 (bool ):
#endif
Coordonnee1::Coordonnee1 (double x):
Coordonnee(1,coord1)
// Constructeur pour un point a deux dimensions
// Constructeur pour un point a une dimension
{ coord1[0]=x;
};
@ -102,7 +102,7 @@ Coordonnee1::Coordonnee1 (const Coordonnee& c):
{
#ifdef MISE_AU_POINT
if (c.Dimension () != 1)
{ cout << "\nErreur la dimension de c est différente de 1 !! !\n";
{ cout << "\nErreur la dimension de c " << c.Dimension() << " est différente de 1 !! !\n";
cout << "Coordonnee1::Coordonnee1 (const Coordonnee& c) \n";
Sortie(1);
}
@ -117,23 +117,26 @@ Coordonnee1::Coordonnee1 (const Coordonnee& c):
Coordonnee1::~Coordonnee1 ()
{ dim = 0; // pour l'appel de ~Coordonnee()
#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,20 +146,20 @@ 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

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);

56
tenseurs_mai99/Coordonnees/Coordonnee1B.cc
View file

@ -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,20 +143,20 @@ 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

78
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
@ -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,7 +99,7 @@ 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";
@ -108,32 +108,32 @@ Coordonnee1H::Coordonnee1H (const CoordonneeH& c):
}
#endif
coord1[0]=c(1);
};
};
// DESTRUCTEUR :
#ifndef MISE_AU_POINT
inline
#endif
Coordonnee1H::~Coordonnee1H ()
{ dim = 0; // pour l'appel de ~Coordonnee()
{ 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
};
//// 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,20 +143,20 @@ 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

77
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[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
@ -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,7 +101,7 @@ 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";
@ -110,32 +110,32 @@ Coordonnee2::Coordonnee2 (const Coordonnee& c):
}
#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()
{ 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
};
//// 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
@ -145,20 +145,20 @@ void Coordonnee2::Libere ()
int Coordonnee2::Dimension () const
{ 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
@ -169,7 +169,6 @@ Coordonnee2& Coordonnee2::operator= (const Coordonnee2& c)
return (*this);
};
// Surcharge de l'operateur - : renvoie l'oppose d'un point
#ifndef MISE_AU_POINT
inline

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);

78
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;
//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
@ -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,7 +101,7 @@ 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";
@ -110,32 +110,32 @@ Coordonnee2B::Coordonnee2B (const CoordonneeB& c):
}
#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()
{ 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
};
//// 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
@ -145,20 +145,20 @@ void Coordonnee2B::Libere ()
int Coordonnee2B::Dimension () const
{ 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

76
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[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
@ -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,7 +101,7 @@ 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";
@ -110,32 +110,32 @@ Coordonnee2H::Coordonnee2H (const CoordonneeH& c):
}
#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()
{ 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
};
//// 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
@ -145,20 +145,20 @@ void Coordonnee2H::Libere ()
int Coordonnee2H::Dimension () const
{ 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

76
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[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
@ -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,7 +103,7 @@ 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";
@ -113,32 +113,32 @@ Coordonnee3::Coordonnee3 (const Coordonnee& c):
#endif
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()
{ 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
};
//// 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
@ -148,20 +148,20 @@ void Coordonnee3::Libere ()
int Coordonnee3::Dimension () const
{ 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

62
tenseurs_mai99/Coordonnees/Coordonnee3.h
View file

@ -62,6 +62,8 @@
* 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
@ -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);

78
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[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
@ -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,7 +103,7 @@ 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";
@ -113,32 +113,32 @@ Coordonnee3B::Coordonnee3B (const CoordonneeB& c):
#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()
{ 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
};
//// 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
@ -148,21 +148,21 @@ void Coordonnee3B::Libere ()
int Coordonnee3B::Dimension () const
{ 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

76
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[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,7 +83,7 @@ Coordonnee3H::Coordonnee3H (double x,double y,double z):
#endif
Coordonnee3H::Coordonnee3H (double* t):
CoordonneeH(3,coord3)
{ coord3[0]=t[0];
{coord3[0]=t[0];
coord3[1]=t[1];
coord3[2]=t[2];
};
@ -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,7 +103,7 @@ 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";
@ -113,32 +113,32 @@ Coordonnee3H::Coordonnee3H (const CoordonneeH& c):
#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()
{ 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
};
//// 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
@ -148,20 +148,20 @@ void Coordonnee3H::Libere ()
int Coordonnee3H::Dimension () const
{ 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

231
tenseurs_mai99/Coordonnees/CoordonneeB.cc
View file

@ -51,7 +51,7 @@ using namespace std; //introduces namespace std
#endif
CoordonneeB::CoordonneeB () :
dim (0) , coord (NULL),memoire(true)
{};
{};
// Constructeur utile si le nombre de coordonnees est connue
// N.B. : les valeurs sont affectees a 0.0
@ -60,11 +60,11 @@ CoordonneeB::CoordonneeB () :
#endif
CoordonneeB::CoordonneeB (int dimension) :
dim ((short)dimension),memoire(true)
{
{
#ifdef MISE_AU_POINT
if ( (dimension<1) || (dimension>3) )
{
cout << "\nErreur de dimension !\n";
{cout << "\nErreur de dimension !\n";
cout << "\n la dimension demandée est "<<dimension << ", elle ne peut-etre que 1 2 ou 3";
cout << "CoordonneeB::CoordonneeB (int ) \n";
Sortie(1);
};
@ -72,8 +72,7 @@ CoordonneeB::CoordonneeB (int dimension) :
coord=new double [dim];
for (int i=0;i<dim;i++)
coord[i]=0.0;
};
};
// Constructeur pour un point a une dimension
#ifndef MISE_AU_POINT
@ -81,10 +80,9 @@ CoordonneeB::CoordonneeB (int dimension) :
#endif
CoordonneeB::CoordonneeB (double x) :
dim (1),memoire(true)
{ coord=new double;
{ coord=new double;
coord[0]=x;
};
};
// Constructeur pour un point a deux dimensions
#ifndef MISE_AU_POINT
@ -92,11 +90,10 @@ CoordonneeB::CoordonneeB (double x) :
#endif
CoordonneeB::CoordonneeB (double x,double y) :
dim (2),memoire(true)
{ coord=new double [2];
{ coord=new double [2];
coord[0]=x;
coord[1]=y;
};
};
// Constructeur pour un point a trois dimensions
#ifndef MISE_AU_POINT
@ -104,16 +101,16 @@ CoordonneeB::CoordonneeB (double x,double y) :
#endif
CoordonneeB::CoordonneeB (double x,double y,double z) :
dim (3) ,memoire(true)
{ coord=new double [3];
{ coord=new double [3];
coord[0]=x;
coord[1]=y;
coord[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
// de l'utilisateur.
// de même il n'y aura pas de redimentionnement possible
#ifndef MISE_AU_POINT
inline
#endif
@ -121,15 +118,16 @@ CoordonneeB::CoordonneeB (int dimension,double* t) :
dim ((short)dimension),coord (t),memoire(false)
{};
// Constructeur de copie
// mais là on construit systématiquement un vrai coordonnée
// même si la mémoire est fausse, car on ne veut pas que plusieur
// coordonnée pointes sur les mêmes valeurs, sans précautions supplémentaires
#ifndef MISE_AU_POINT
inline
#endif
CoordonneeB::CoordonneeB (const CoordonneeB& c) :
dim (c.dim),memoire(true)
{
{
if ( dim==0 )
coord=NULL;
else
@ -138,32 +136,23 @@ CoordonneeB::CoordonneeB (const CoordonneeB& c) :
// copie des coordonnees
coord[i]=c.coord[i];
};
};
};
// Destructeur
// Desallocation de la place memoire allouee
// dans le cas où la mémoire n'est pas gérée localement -> aucune action
#ifndef MISE_AU_POINT
inline
#endif
CoordonneeB::~CoordonneeB ()
{ if (memoire)
{ if (memoire)
{ if (dim > 0)
{ delete [] coord;
coord=NULL;
dim=0;
}
#ifdef MISE_AU_POINT
else
{if ( coord!=NULL )
{ cout << "\nErreur de liberation de la place memoire\n";
cout << "CoordonneeB::LIBERE () \n";
Sortie(1);
}
}
#endif
}
};
};
};
// construction "explicite" à partir d'une instance de CoordonneeB
// intéressant si this est initialement construit par defaut (donc vide)
@ -174,8 +163,8 @@ CoordonneeB::~CoordonneeB ()
#endif
void CoordonneeB::ConstructionAPartirDe_H(const CoordonneeH& aH)
{ if (dim != aH.dim) Change_dim(aH.dim);
memoire = true;
dim = aH.dim;
// si auparavant memoire == false, l'erreur est détectée au niveau de Change_dim
// arrivée ici dim == aH_dim
switch (dim)
{ case 3 : coord[2] = aH.coord[2];
case 2 : coord[1] = aH.coord[1];
@ -191,8 +180,8 @@ void CoordonneeB::ConstructionAPartirDe_H(const CoordonneeH& aH)
void CoordonneeB::Change_val(const Coordonnee& c)
{ int c_dim = c.Dimension();
if (dim != c_dim) Change_dim(c_dim);
memoire = true;
dim = c_dim;
// si auparavant memoire == false, l'erreur est détectée au niveau de Change_dim
// arrivée ici dim == c_dim
switch (dim)
{ case 3 : coord[2] = c(3);
case 2 : coord[1] = c(2);
@ -210,22 +199,28 @@ int CoordonneeB::Dimension () const
{ return dim; };
// Desallocation de la place memoire allouee
// uniquement dans le cas où la mémoire est gérée localement
// sinon aucune action
#ifndef MISE_AU_POINT
inline
#endif
void CoordonneeB::Libere ()
{if (memoire)
{ if ( dim>0 )
delete [] coord;
{delete [] coord;}
else
{if ( coord!=NULL )
{ cout << "\nErreur de liberation de la place memoire\n";
cout << "CoordonneeB::LIBERE () \n";
{ cout << "\n***Erreur de liberation de la place memoire\n";
cout << "\n la dimension locale est nulle et le pointeur de tableau est "
<< " non null, ce n'est pas normal !! ";
cout << "CoordonneeB::Libere () \n";
Sortie(1);
}
}
};
coord=NULL;
dim=0;
};
};
// Renvoie la ieme coordonnee
#ifndef MISE_AU_POINT
@ -235,8 +230,10 @@ double& CoordonneeB::operator() (int i)
{
#ifdef MISE_AU_POINT
if ( (i<1) || (i>dim) )
{ cout << "\nErreur de dimension !\n";
cout << "CoordonneeB::OPERATOR() (int ) \n";
{cout << "\n***Erreur de dimension !\n";
cout <<"\n on demande la coordonnee i="<<i
<< " alors que dim du point = "<< dim << " !!!";
cout << "CoordonneeB::operator() (int ) \n" << flush;
Sortie(1);
};
#endif
@ -251,8 +248,10 @@ double CoordonneeB::operator() (int i) const
{
#ifdef MISE_AU_POINT
if ( (i<1) || (i>dim) )
{ cout << "\nErreur de dimension !\n";
cout << "CoordonneeB::OPERATOR() (int ) \n";
{cout << "\nErreur de dimension !\n";
cout <<"\n on demande la coordonnee i="<<i
<< " alors que dim du point = "<< dim << " !!!";
cout << "CoordonneeB::operator() (int ) \n"<< flush;
Sortie(1);
};
#endif
@ -262,10 +261,13 @@ double CoordonneeB::operator() (int i) const
// 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`
// possible uniquement si la mémoire est gérée localement
#ifndef MISE_AU_POINT
inline
#endif
void CoordonneeB::Change_dim(int dimen)
{ if (dimen == dim) return; // même dimension, on ne fait rien
if (memoire)
{
#ifdef MISE_AU_POINT
if ((dimen<1) || (dimen>3))
@ -291,11 +293,21 @@ void CoordonneeB::Change_dim(int dimen)
coord[i] = sauve[i];
dim = (short) dimen;
delete [] sauve;
}
};
// dans le cas ou dim = dimen on ne fait rien
}
else
{cout << "\n *** erreur de modification de la dimension d'un CoordonneeB "
<< "\n la memoire n'est pas gere localement et la dimension demandee: "<<dimen
<< " est differente de la dimension existante: "<<dim << " !! "
<< "\n CoordonneeB::Change_dim(int dimen) "<< flush;
Sortie(1);
};
};
// Surcharge de l'operateur = : realise l'affectation entre deux points
// adaptation de la dimension si la mémoire est gérée localement
// sinon ce n'est pas possible -> erreur
#ifndef MISE_AU_POINT
inline
#endif
@ -305,7 +317,7 @@ CoordonneeB& CoordonneeB::operator= (const CoordonneeB& c)
coord[i]=c.coord[i];
return (*this);
}
else if ( c.dim==0 )
else if (( c.dim==0 )&&(memoire))
{ Libere();}
else
{
@ -315,12 +327,21 @@ CoordonneeB& CoordonneeB::operator= (const CoordonneeB& c)
<< " de "<<dim<<" a "<<c.dim << endl;
}
#endif
Libere();
if (!memoire)
{cout << "\n *** erreur, la memoire n'est pas geree localement et c.dim :" << c.dim
<< ", est different de la dimension locale : "<< dim
<< ", le changement de dimension n'est pas possible !! "
<< "\n CoordonneeB::operator= (const CoordonneeB& c) ";
Sortie(1);
}
else
{Libere();
dim=c.dim;
coord=new double [dim];
for (int i=0;i<dim;i++)
coord[i]=c.coord[i];
};
};
return (*this);
};
@ -330,7 +351,7 @@ CoordonneeB& CoordonneeB::operator= (const CoordonneeB& c)
inline
#endif
CoordonneeB CoordonneeB::operator- () const
{ CoordonneeB result(dim);
{CoordonneeB result(dim);
for (int i=0;i<dim;i++)
result.coord[i]=-coord[i];
return result;
@ -345,9 +366,8 @@ CoordonneeB CoordonneeB::operator- (const CoordonneeB& c) const
{
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{
cout << "\nErreur : dimensions non egales !\n";
cout << "CoordonneeB::OPERATOR- (CoordonneeB ) \n";
{cout << "\nErreur : dimensions: dim "<<dim<<" et c.dim"<< c.dim <<" non egales !\n";
cout << "CoordonneeB::operator- (CoordonneeB ) \n";
Sortie(1);
};
#endif
@ -366,8 +386,8 @@ CoordonneeB CoordonneeB::operator+ (const CoordonneeB& c) const
{
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{ cout << "\nErreur : dimensions non egales !\n";
cout << "CoordonneeB::OPERATOR+ (CoordonneeB ) \n";
{cout << "\nErreur : dimensions: dim "<<dim<<" et c.dim"<< c.dim <<" non egales !\n";
cout << "CoordonneeB::operator+ (CoordonneeB ) \n";
Sortie(1);
};
#endif
@ -385,8 +405,8 @@ void CoordonneeB::operator+= (const CoordonneeB& c)
{
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{ cout << "\nErreur : dimensions non egales !\n";
cout << "CoordonneeB::OPERATOR+= (CoordonneeB ) \n";
{cout << "\nErreur : dimensions: dim "<<dim<<" et c.dim"<< c.dim <<" non egales !\n";
cout << "CoordonneeB::operator+= (CoordonneeB ) \n";
Sortie(1);
};
#endif
@ -402,9 +422,8 @@ void CoordonneeB::operator-= (const CoordonneeB& c)
{
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{
cout << "\nErreur : dimensions non egales !\n";
cout << "CoordonneeB::OPERATOR-= (CoordonneeB ) \n";
{cout << "\nErreur : dimensions: dim "<<dim<<" et c.dim"<< c.dim <<" non egales !\n";
cout << "CoordonneeB::operator-= (CoordonneeB ) \n";
Sortie(1);
};
#endif
@ -417,7 +436,7 @@ void CoordonneeB::operator-= (const CoordonneeB& c)
inline
#endif
void CoordonneeB::operator*= (double val)
{ for (int i=0;i<dim;i++)
{for (int i=0;i<dim;i++)
coord[i]*=val;
};
@ -426,7 +445,7 @@ void CoordonneeB::operator*= (double val)
inline
#endif
CoordonneeB CoordonneeB::operator* (double val) const
{ CoordonneeB result(dim);
{CoordonneeB result(dim);
for (int i=0;i<dim;i++)
result.coord[i]=val*coord[i];
return result;
@ -437,12 +456,19 @@ CoordonneeB CoordonneeB::operator* (double val) const
inline
#endif
double CoordonneeB::operator* (const CoordonneeH& c) const
{ double res=0.0;
{double res=0.0;
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{cout << "\nErreur : dimensions: dim "<<dim<<" et c.dim"<< c.dim <<" non egales !\n";
cout << "CoordonneeB::operator* (const CoordonneeH& c) \n";
Sortie(1);
};
#endif
for (int i=0;i<dim;i++)
// somme des produits
res+= coord[i] * c(i+1);
return res;
};
};
// produit scalaire entre coordonnees covariantes et covariantes
@ -450,12 +476,20 @@ double CoordonneeB::operator* (const CoordonneeH& c) const
inline
#endif
double CoordonneeB::ScalBB(const CoordonneeB& c) const
{ double res=0.0;
{ double res=0.0;
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{cout << "\nErreur : dimensions: dim "<<dim<<" et c.dim"<< c.dim <<" non egales !\n";
cout << "CoordonneeB::ScalBB(const CoordonneeB& c) \n";
Sortie(1);
};
#endif
for (int i=0;i<dim;i++)
// somme des produits
res+= coord[i] * c(i+1);
return res;
};
};
// Surcharge de l'operateur / : division de coordonnees par un scalaire
#ifndef MISE_AU_POINT
@ -501,10 +535,10 @@ void CoordonneeB::operator/= (double val)
#endif
int CoordonneeB::operator== (const CoordonneeB& c) const
{ if ( c.dim!=dim )
return 0;
{ return 0;}
else
{ for (int i=0;i<dim;i++)
{ if ( c.coord[i]!=coord[i] )
{if ( c.coord[i]!=coord[i] )
return 0;
};
return 1;
@ -518,7 +552,7 @@ int CoordonneeB::operator== (const CoordonneeB& c) const
inline
#endif
int CoordonneeB::operator!= (const CoordonneeB& c) const
{ if ( (*this)==c )
{if ( (*this)==c )
return 0;
else
return 1;
@ -529,7 +563,7 @@ int CoordonneeB::operator!= (const CoordonneeB& c) const
inline
#endif
void CoordonneeB::Affiche () const
{ cout << "\t{ ";
{cout << "\t{ ";
for (int i=1;i<=dim;i++)
cout << (*this)(i) << " ";
cout << "}\n";
@ -540,7 +574,7 @@ void CoordonneeB::Affiche () const
inline
#endif
void CoordonneeB::Affiche (ostream& sort) const
{ sort << "\t{ " ;
{sort << "\t{ " ;
for (int i=1;i<=dim;i++)
sort << (*this)(i) << " " ;
sort << "}\n" ;
@ -622,7 +656,7 @@ void CoordonneeB::Zero()
#endif
// lecture brut des coordonnées sans la dimension
void CoordonneeB::Lecture (UtilLecture& entreePrinc)
{ int dim = Dimension ();
{ int dim = Dimension();
double tab[3];
for (int i = 0; i<= dim-1; i++)
@ -642,9 +676,12 @@ istream & operator >> ( istream & ent, CoordonneeB & coo)
{ // lecture du type et vérification
string nomtype; ent >> nomtype;
if (nomtype != "CoordonneeB")
{ Sortie(1);
{ cout << "\n *** erreur en lecture du type point conteneur "
<< " on a lue: "<<nomtype << " alors que l'on attendait: CoordonneeB "
<< "\n operator >> ( istream & ent, CoordonneeB & coo) " << endl ;
Sortie(1);
return ent;
}
};
// lecture de la dimension
int dim;
ent >> nomtype >> dim ;
@ -656,7 +693,7 @@ istream & operator >> ( istream & ent, CoordonneeB & coo)
coo.dim = dim;
}
else
{ cout << "\n erreur en lecture la dimension du point conteneur "<< dim << " est differente de celle lue "
{ cout << "\n erreur en lecture la dimension du point conteneur "<< dim << " est differente de celle lue"
<< dim << " et memoire est faux, donc on ne peut pas changer la dimension "
<< "\n operator >> ( istream & ent, CoordonneeB & coo) " << endl ;
Sortie(2);
@ -687,13 +724,13 @@ ostream & operator << ( ostream & sort,const CoordonneeB & coo)
inline
#endif
double CoordonneeB::Norme () const
{ double norme=0.0;
{double norme=0.0;
for (int i=0;i<dim;i++)
// somme du carre des composantes du vecteur
norme=norme + coord[i] * coord[i];
norme=sqrt(norme); // calcul de la norme
return norme;
};
};
// norme le vecteur coordonnée
#ifndef MISE_AU_POINT
@ -706,7 +743,7 @@ CoordonneeB& CoordonneeB::Normer ()
{ cout << "\n erreur, division par zero ";
cout << "\nCoordonneeB::Normer () " << endl;
Sortie (1);
}
};
#endif
*this /= norme;
return *this ;
@ -717,7 +754,7 @@ CoordonneeB& CoordonneeB::Normer ()
#endif
// Retourne le maximum en valeur absolue des composantes
double CoordonneeB::Max_val_abs () const
{ double maxi=0.;
{double maxi=0.;
switch (dim)
{ case 3: maxi=DabsMaX(maxi,coord[2]);
case 2: maxi=DabsMaX(maxi,coord[1]);
@ -725,14 +762,14 @@ double CoordonneeB::Max_val_abs () const
case 0: break;
};
return maxi;
};
};
#ifndef MISE_AU_POINT
inline
#endif
// Retourne le maximum en valeur absolue des composantes et l'indice correspondant
double CoordonneeB::Max_val_abs (int& in) const
{ double maxi=0.;
{double maxi=0.;
in = 0;
switch (dim)
{ case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;}
@ -741,7 +778,7 @@ double CoordonneeB::Max_val_abs (int& in) const
case 0: break;
};
return maxi;
};
};
#ifndef MISE_AU_POINT
inline
@ -749,7 +786,7 @@ double CoordonneeB::Max_val_abs (int& in) const
// Retourne le maximum en valeur absolue des composantes du Coordonnee
// mais ramène la grandeur signée (avec son signe)
double CoordonneeB::Max_val_abs_signe () const
{ double maxi=0.;
{double maxi=0.;
int in = 0;
switch (dim)
{ case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;}
@ -759,7 +796,7 @@ double CoordonneeB::Max_val_abs_signe () const
};
if (in != 0) {return coord[in-1];}
else {return maxi;};
};
};
#ifndef MISE_AU_POINT
inline
@ -767,7 +804,7 @@ double CoordonneeB::Max_val_abs_signe () const
// Retourne le maximum en valeur absolue des composantes du Coordonnee
// mais ramène la grandeur signée (avec son signe) et l'indice
double CoordonneeB::Max_val_abs_signe (int& in) const
{ double maxi=0.;
{double maxi=0.;
in = 0;
switch (dim)
{ case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;}
@ -777,7 +814,7 @@ double CoordonneeB::Max_val_abs_signe (int& in) const
};
if (in != 0) {return coord[in-1];}
else {return maxi;};
};
};
#ifndef MISE_AU_POINT
inline
@ -812,8 +849,8 @@ void CoordonneeB::Ajout_meme_valeur(double val)
// sortie du schemaXML: en fonction de enu
void CoordonneeB::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu)
{
switch (enu)
{ case XML_TYPE_GLOBAUX :
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** CoordonneeB *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_B\" >"
<< "\n <xs:annotation>"
@ -834,20 +871,20 @@ void CoordonneeB::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu)
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
}
case XML_IO_ELEMENT_FINI :
{
break;
}
};
}
};
};

232
tenseurs_mai99/Coordonnees/CoordonneeH.cc
View file

@ -52,7 +52,7 @@ using namespace std; //introduces namespace std
#endif
CoordonneeH::CoordonneeH () :
dim (0) , coord (NULL),memoire(true)
{};
{};
// Constructeur utile si le nombre de coordonnees est connue
// N.B. : les valeurs sont affectees a 0.0
@ -61,11 +61,11 @@ CoordonneeH::CoordonneeH () :
#endif
CoordonneeH::CoordonneeH (int dimension) :
dim ((short) dimension),memoire(true)
{
{
#ifdef MISE_AU_POINT
if ( (dimension<1) || (dimension>3) )
{
cout << "\nErreur de dimension !\n";
{cout << "\nErreur de dimension !\n";
cout << "\n la dimension demandée est "<<dimension << ", elle ne peut-etre que 1 2 ou 3";
cout << "CoordonneeH::CoordonneeH (int ) \n";
Sortie(1);
};
@ -73,8 +73,7 @@ CoordonneeH::CoordonneeH (int dimension) :
coord=new double [dim];
for (int i=0;i<dim;i++)
coord[i]=0.0;
};
};
// Constructeur pour un point a une dimension
#ifndef MISE_AU_POINT
@ -82,10 +81,9 @@ CoordonneeH::CoordonneeH (int dimension) :
#endif
CoordonneeH::CoordonneeH (double x) :
dim (1),memoire(true)
{ coord=new double;
{ coord=new double;
coord[0]=x;
};
};
// Constructeur pour un point a deux dimensions
#ifndef MISE_AU_POINT
@ -93,11 +91,10 @@ CoordonneeH::CoordonneeH (double x) :
#endif
CoordonneeH::CoordonneeH (double x,double y) :
dim (2),memoire(true)
{ coord=new double [2];
{coord=new double [2];
coord[0]=x;
coord[1]=y;
};
};
// Constructeur pour un point a trois dimensions
#ifndef MISE_AU_POINT
@ -105,12 +102,11 @@ CoordonneeH::CoordonneeH (double x,double y) :
#endif
CoordonneeH::CoordonneeH (double x,double y,double z) :
dim (3) ,memoire(true)
{ coord=new double [3];
{coord=new double [3];
coord[0]=x;
coord[1]=y;
coord[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
@ -129,42 +125,32 @@ CoordonneeH::CoordonneeH (int dimension,double* t) :
#endif
CoordonneeH::CoordonneeH (const CoordonneeH& c) :
dim (c.dim),memoire(true)
{
{
if ( dim==0 )
coord=NULL;
else
{ coord=new double [dim];
{coord=new double [dim];
for (int i=0;i<dim;i++)
// copie des coordonnees
coord[i]=c.coord[i];
};
};
};
// Destructeur
// Desallocation de la place memoire allouee
// dans le cas où la mémoire n'est pas gérée localement -> aucune action
#ifndef MISE_AU_POINT
inline
#endif
CoordonneeH::~CoordonneeH ()
{if (memoire)
{if (memoire)
{ if (dim > 0)
{ delete [] coord;
coord=NULL;
dim=0;
}
#ifdef MISE_AU_POINT
else
{if ( coord!=NULL )
{ cout << "\nErreur de liberation de la place memoire\n";
cout << "CoordonneeH::LIBERE () \n";
Sortie(1);
}
}
#endif
}
};
};
};
// construction "explicite" à partir d'une instance de CoordonneeB
// intéressant si this est initialement construit par defaut (donc vide)
@ -175,8 +161,8 @@ CoordonneeH::~CoordonneeH ()
#endif
void CoordonneeH::ConstructionAPartirDe_B(const CoordonneeB& aB)
{ if (dim != aB.dim) Change_dim(aB.dim);
memoire = true;
dim = aB.dim;
// si auparavant memoire == false, l'erreur est détectée au niveau de Change_dim
// arrivée ici dim == aB_dim
switch (dim)
{ case 3 : coord[2] = aB.coord[2];
case 2 : coord[1] = aB.coord[1];
@ -190,25 +176,31 @@ void CoordonneeH::ConstructionAPartirDe_B(const CoordonneeB& aB)
inline
#endif
int CoordonneeH::Dimension () const
{ return dim; };
{return dim; };
// Desallocation de la place memoire allouee
// uniquement dans le cas où la mémoire est gérée localement
// sinon aucune action
#ifndef MISE_AU_POINT
inline
#endif
void CoordonneeH::Libere ()
{ if ( dim>0 )
{if (memoire)
{if ( dim>0 )
delete [] coord;
else
{if ( coord!=NULL )
{ cout << "\nErreur de liberation de la place memoire\n";
{ cout << "\n***Erreur de liberation de la place memoire\n";
cout << "\n la dimension locale est nulle et le pointeur de tableau est "
<< " non null, ce n'est pas normal !! ";
cout << "CoordonneeH::LIBERE () \n";
Sortie(1);
}
}
};
coord=NULL;
dim=0;
};
};
// Renvoie la ieme coordonnee
#ifndef MISE_AU_POINT
@ -218,8 +210,10 @@ double& CoordonneeH::operator() (int i)
{
#ifdef MISE_AU_POINT
if ( (i<1) || (i>dim) )
{ cout << "\nErreur de dimension !\n";
cout << "CoordonneeH::OPERATOR() (int ) \n";
{cout << "\nErreur de dimension !\n";
cout <<"\n on demande la coordonnee i="<<i
<< " alors que dim du point = "<< dim << " !!!";
cout << "CoordonneeH::operator() (int ) \n"<< flush;
Sortie(1);
};
#endif
@ -234,8 +228,10 @@ double CoordonneeH::operator() (int i) const
{
#ifdef MISE_AU_POINT
if ( (i<1) || (i>dim) )
{ cout << "\nErreur de dimension !\n";
cout << "CoordonneeH::OPERATOR() (int ) \n";
{cout << "\nErreur de dimension !\n";
cout <<"\n on demande la coordonnee i="<<i
<< " alors que dim du point = "<< dim << " !!!";
cout << "CoordonneeH::operator() (int ) \n"<< flush;
Sortie(1);
};
#endif
@ -245,10 +241,13 @@ double CoordonneeH::operator() (int i) const
// 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`
// possible uniquement si la mémoire est gérée localement
#ifndef MISE_AU_POINT
inline
#endif
void CoordonneeH::Change_dim(int dimen)
{ if (dimen == dim) return; // même dimension, on ne fait rien
if (memoire)
{
#ifdef MISE_AU_POINT
if ((dimen<1) || (dimen>3))
@ -274,8 +273,16 @@ void CoordonneeH::Change_dim(int dimen)
coord[i] = sauve[i];
dim = (short) dimen;
delete [] sauve;
}
};
// dans le cas ou dim = dimen on ne fait rien
}
else
{cout << "\n *** erreur de modification de la dimension d'un CoordonneeB "
<< "\n la memoire n'est pas gere localement et la dimension demandee: "<<dimen
<< " est differente de la dimension existante: "<<dim << " !! "
<< "\n CoordonneeH::Change_dim(int dimen) "<< flush;
Sortie(1);
};
};
// Surcharge de l'operateur = : realise l'affectation entre deux points
@ -288,7 +295,7 @@ CoordonneeH& CoordonneeH::operator= (const CoordonneeH& c)
coord[i]=c.coord[i];
return (*this);
}
else if ( c.dim==0 )
else if (( c.dim==0 )&&(memoire))
{ Libere();}
else
{
@ -298,12 +305,21 @@ CoordonneeH& CoordonneeH::operator= (const CoordonneeH& c)
<< " de "<<dim<<" a "<<c.dim << endl;
};
#endif
Libere();
if (!memoire)
{cout << "\n *** erreur, la memoire n'est pas geree localement et c.dim :" << c.dim
<< ", est different de la dimension locale : "<< dim
<< ", le changement de dimension n'est pas possible !! "
<< "\n CoordonneeH::operator= (const CoordonneeH& c) ";
Sortie(1);
}
else
{Libere();
dim=c.dim;
coord=new double [dim];
for (int i=0;i<dim;i++)
coord[i]=c.coord[i];
};
};
return (*this);
};
@ -314,8 +330,8 @@ CoordonneeH& CoordonneeH::operator= (const CoordonneeH& c)
void CoordonneeH::Change_val(const Coordonnee& c)
{ int c_dim = c.Dimension();
if (dim != c_dim) Change_dim(c_dim);
memoire = true;
dim = c_dim;
// si auparavant memoire == false, l'erreur est détectée au niveau de Change_dim
// arrivée ici dim == c_dim
switch (dim)
{ case 3 : coord[2] = c(3);
case 2 : coord[1] = c(2);
@ -329,11 +345,11 @@ void CoordonneeH::Change_val(const Coordonnee& c)
inline
#endif
CoordonneeH CoordonneeH::operator- () const
{ CoordonneeH result(dim);
for (int i=0;i<dim;i++)
result.coord[i]=-coord[i];
return result;
};
{CoordonneeH result(dim);
for (int i=0;i<dim;i++)
result.coord[i]=-coord[i];
return result;
};
// Surcharge de l'operateur - : realise la soustraction des
// coordonnees de deux points
@ -344,9 +360,8 @@ CoordonneeH CoordonneeH::operator- (const CoordonneeH& c) const
{
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{
cout << "\nErreur : dimensions non egales !\n";
cout << "CoordonneeH::OPERATOR- (CoordonneeH ) \n";
{cout << "\nErreur : dimensions non egales !\n";
cout << "CoordonneeH::operator- (CoordonneeH ) \n";
Sortie(1);
};
#endif
@ -365,8 +380,8 @@ CoordonneeH CoordonneeH::operator+ (const CoordonneeH& c) const
{
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{ cout << "\nErreur : dimensions non egales !\n";
cout << "CoordonneeH::OPERATOR+ (CoordonneeH ) \n";
{cout << "\nErreur : dimensions non egales !\n";
cout << "CoordonneeH::operator+ (CoordonneeH ) \n";
Sortie(1);
};
#endif
@ -384,8 +399,8 @@ void CoordonneeH::operator+= (const CoordonneeH& c)
{
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{ cout << "\nErreur : dimensions non egales !\n";
cout << "CoordonneeH::OPERATOR+= (CoordonneeH ) \n";
{cout << "\nErreur : dimensions non egales !\n";
cout << "CoordonneeH::operator+= (CoordonneeH ) \n";
Sortie(1);
};
#endif
@ -401,9 +416,8 @@ void CoordonneeH::operator-= (const CoordonneeH& c)
{
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{
cout << "\nErreur : dimensions non egales !\n";
cout << "CoordonneeH::OPERATOR-= (CoordonneeH ) \n";
{cout << "\nErreur : dimensions non egales !\n";
cout << "CoordonneeH::operator-= (CoordonneeH ) \n";
Sortie(1);
};
#endif
@ -416,7 +430,7 @@ void CoordonneeH::operator-= (const CoordonneeH& c)
inline
#endif
void CoordonneeH::operator*= (double val)
{ for (int i=0;i<dim;i++)
{for (int i=0;i<dim;i++)
coord[i]*=val;
};
@ -436,24 +450,38 @@ CoordonneeH CoordonneeH::operator* (double val) const
inline
#endif
double CoordonneeH::operator* (const CoordonneeB& c) const
{ double res=0.0;
{double res=0.0;
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{cout << "\nErreur : dimensions: dim "<<dim<<" et c.dim"<< c.dim <<" non egales !\n";
cout << "CoordonneeH::operator* (const CoordonneeB& c) \n";
Sortie(1);
};
#endif
for (int i=0;i<dim;i++)
// somme des produits
res+= coord[i] * c(i+1);
return res;
};
};
// produit scalaire entre coordonnees contravariantes et contravariantes
#ifndef MISE_AU_POINT
inline
#endif
double CoordonneeH::ScalHH(const CoordonneeH& c) const
{ double res=0.0;
{double res=0.0;
#ifdef MISE_AU_POINT
if ( dim!=c.dim )
{cout << "\nErreur : dimensions: dim "<<dim<<" et c.dim"<< c.dim <<" non egales !\n";
cout << "CoordonneeH::ScalHH(const CoordonneeH& c) \n";
Sortie(1);
};
#endif
for (int i=0;i<dim;i++)
// somme des produits
res+= coord[i] * c(i+1);
return res;
};
};
// Surcharge de l'operateur / : division de coordonnees par un scalaire
#ifndef MISE_AU_POINT
@ -498,16 +526,16 @@ void CoordonneeH::operator/= (double val)
inline
#endif
int CoordonneeH::operator== (const CoordonneeH& c) const
{ if ( c.dim!=dim )
return 0;
{ if ( c.dim!=dim )
{ return 0;}
else
{ for (int i=0;i<dim;i++)
{ if ( c.coord[i]!=coord[i] )
{if ( c.coord[i]!=coord[i] )
return 0;
};
return 1;
};
};
};
// Surcharge de l'operateur !=
// Renvoie 1 si les deux positions ne sont pas identiques
@ -516,7 +544,7 @@ int CoordonneeH::operator== (const CoordonneeH& c) const
inline
#endif
int CoordonneeH::operator!= (const CoordonneeH& c) const
{ if ( (*this)==c )
{if ( (*this)==c )
return 0;
else
return 1;
@ -527,7 +555,7 @@ int CoordonneeH::operator!= (const CoordonneeH& c) const
inline
#endif
void CoordonneeH::Affiche () const
{ cout << "\t{ ";
{cout << "\t{ ";
for (int i=1;i<=dim;i++)
cout << (*this)(i) << " ";
cout << "}\n";
@ -538,7 +566,7 @@ void CoordonneeH::Affiche () const
inline
#endif
void CoordonneeH::Affiche (ostream& sort) const
{ sort << "\t{ " ;
{sort << "\t{ " ;
for (int i=1;i<=dim;i++)
sort << (*this)(i) << " " ;
sort << "}\n" ;
@ -636,9 +664,12 @@ istream & operator >> ( istream & ent, CoordonneeH & coo)
{ // lecture du type et vérification
string nomtype; ent >> nomtype;
if (nomtype != "CoordonneeH")
{ Sortie(1);
{ cout << "\n *** erreur en lecture du type point conteneur "
<< " on a lue: "<<nomtype << " alors que l'on attendait: CoordonneeH "
<< "\n operator >> ( istream & ent, CoordonneeH & coo) " << endl ;
Sortie(1);
return ent;
}
};
// lecture de la dimension
int dim;
ent >> nomtype >> dim ;
@ -650,7 +681,7 @@ istream & operator >> ( istream & ent, CoordonneeH & coo)
coo.dim = dim;
}
else
{ cout << "\n erreur en lecture la dimension du point conteneur "<< dim << " est differente de celle lue "
{ cout << "\n erreur en lecture la dimension du point conteneur "<< dim << " est differente de celle lue"
<< dim << " et memoire est faux, donc on ne peut pas changer la dimension "
<< "\n operator >> ( istream & ent, CoordonneeH & coo) " << endl ;
Sortie(2);
@ -681,13 +712,13 @@ ostream & operator << ( ostream & sort,const CoordonneeH & coo)
inline
#endif
double CoordonneeH::Norme () const
{ double norme=0.0;
{double norme=0.0;
for (int i=0;i<dim;i++)
// somme du carre des composantes du vecteur
norme=norme + coord[i] * coord[i];
norme=sqrt(norme); // calcul de la norme
return norme;
};
};
// norme le vecteur coordonnée
#ifndef MISE_AU_POINT
@ -710,7 +741,7 @@ CoordonneeH& CoordonneeH::Normer ()
#endif
// Retourne le maximum en valeur absolue des composantes
double CoordonneeH::Max_val_abs () const
{ double maxi=0.;
{double maxi=0.;
switch (dim)
{ case 3: maxi=DabsMaX(maxi,coord[2]);
case 2: maxi=DabsMaX(maxi,coord[1]);
@ -718,14 +749,14 @@ double CoordonneeH::Max_val_abs () const
case 0: break;
};
return maxi;
};
};
#ifndef MISE_AU_POINT
inline
#endif
// Retourne le maximum en valeur absolue des composantes et l'indice correspondant
double CoordonneeH::Max_val_abs (int& in) const
{ double maxi=0.;
{double maxi=0.;
in = 0;
switch (dim)
{ case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;}
@ -734,7 +765,7 @@ double CoordonneeH::Max_val_abs (int& in) const
case 0: break;
};
return maxi;
};
};
#ifndef MISE_AU_POINT
inline
@ -742,7 +773,7 @@ double CoordonneeH::Max_val_abs (int& in) const
// Retourne le maximum en valeur absolue des composantes du Coordonnee
// mais ramène la grandeur signée (avec son signe)
double CoordonneeH::Max_val_abs_signe () const
{ double maxi=0.;
{double maxi=0.;
int in = 0;
switch (dim)
{ case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;}
@ -752,7 +783,7 @@ double CoordonneeH::Max_val_abs_signe () const
};
if (in != 0) {return coord[in-1];}
else {return maxi;};
};
};
#ifndef MISE_AU_POINT
inline
@ -760,7 +791,7 @@ double CoordonneeH::Max_val_abs_signe () const
// Retourne le maximum en valeur absolue des composantes du Coordonnee
// mais ramène la grandeur signée (avec son signe) et l'indice
double CoordonneeH::Max_val_abs_signe (int& in) const
{ double maxi=0.;
{double maxi=0.;
in = 0;
switch (dim)
{ case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;}
@ -770,7 +801,7 @@ double CoordonneeH::Max_val_abs_signe (int& in) const
};
if (in != 0) {return coord[in-1];}
else {return maxi;};
};
};
#ifndef MISE_AU_POINT
inline
@ -781,6 +812,7 @@ void CoordonneeH::Modif_en_max(const CoordonneeH& v)
{ for (int i=1;i<=dim;i++)
if (coord[i-1] < v(i)) coord[i-1]=v(i);
};
#ifndef MISE_AU_POINT
inline
#endif
@ -806,8 +838,8 @@ void CoordonneeH::Ajout_meme_valeur(double val)
// sortie du schemaXML: en fonction de enu
void CoordonneeH::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu)
{
switch (enu)
{ case XML_TYPE_GLOBAUX :
switch (enu)
{ case XML_TYPE_GLOBAUX :
{sort << "\n <!-- *************************** CoordonneeH *************************** -->"
<< "\n<xs:complexType name=\"COORDONNEE_H\" >"
<< "\n <xs:annotation>"
@ -828,20 +860,20 @@ void CoordonneeH::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu)
<< "\n </xs:sequence>"
<< "\n</xs:complexType>";
break;
}
case XML_IO_POINT_INFO :
{
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
}
case XML_IO_ELEMENT_FINI :
{
break;
}
};
}
};
};