diff --git a/Algo/AlgoRef/Algori.cc b/Algo/AlgoRef/Algori.cc index 99b0f2f..be24e5b 100644 --- a/Algo/AlgoRef/Algori.cc +++ b/Algo/AlgoRef/Algori.cc @@ -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 & listElContact = lesCont->LesElementsDeContact(); LaLIST ::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 :: "<PosiAssemb(Ass.Nb_cas_assemb().n)) +// cout << "\n nnoeud avec le poinnteur d'assemblage :" +// << elcontact.Const_Esclave()->Num_noeud(); +// } +// } +//// (resu.raid)->Affiche(); //1,8,1,1,8,1); +//// (resu.raid)->Affiche1(1,6,1,1,6,1); +// // (int min_i,int max_i,int pas_i,int min_j,int max_j,int pas_j,int nd) +//// ------ fin debug // on gère les exceptions éventuelles en mettant le bloc sous surveillance try {// boucle sur les elements de contact @@ -2461,12 +2483,15 @@ bool Algori::RaidSmEnerContact(LesContacts * lesCont,Assemblage& Ass,Vecteur & v // calcul effectif de la raideur et résidu locals Element::ResRaid resu = elcontact.SM_K_charge_contact(); // cout << "numéro =" << ne << endl; -//------ debug -// (resu.res)->Affiche(); -// (resu.raid)->Affiche(); //1,8,1,1,8,1); -// (resu.raid)->Affiche1(1,6,1,1,6,1); - // (int min_i,int max_i,int pas_i,int min_j,int max_j,int pas_j,int nd) -// ------ fin debug +////------ debug +// if (elcontact.Const_Esclave()->Num_noeud() == 1309) +// {cout <<"\n debug Algori::RaidSmEnerContact"; +// (resu.res)->Affiche(); +// } +//// (resu.raid)->Affiche(); //1,8,1,1,8,1); +//// (resu.raid)->Affiche1(1,6,1,1,6,1); +// // (int min_i,int max_i,int pas_i,int min_j,int max_j,int pas_j,int nd) +//// ------ fin debug #ifndef UTILISATION_MPI // assemblage // dans le cas où le retour est un pointeur nul, cela signifie qu'il n'y a pas de second membre et raideur calculés diff --git a/Algo/AlgoRef/Algori4.cc b/Algo/AlgoRef/Algori4.cc index 6d5aa81..16b0dcd 100644 --- a/Algo/AlgoRef/Algori4.cc +++ b/Algo/AlgoRef/Algori4.cc @@ -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 diff --git a/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc b/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc index 23dc498..05a4555 100644 --- a/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc +++ b/Algo/GalerkinContinu/AlgoStatiques/AlgoriNonDyna2.cc @@ -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); diff --git a/Elements/Geometrie/Frontiere/Front.cc b/Elements/Geometrie/Frontiere/Front.cc index 88e07a3..3466acc 100644 --- a/Elements/Geometrie/Frontiere/Front.cc +++ b/Elements/Geometrie/Frontiere/Front.cc @@ -91,13 +91,16 @@ Front::~Front() void Front::Affiche(int cas) const { if (elem != NULL) {if (cas == 1) - { cout << " front " ; - if (angle_mort) - cout << "(angle mort) "; - cout << num_frontiere << " (dans le type) ("<TypeFrontiere()<<") de l'EF " << ptEl->Num_elt() - << " ("<< ptEl->Geometrie()<<", "<Interpolation() <<") mail. " - << ptEl->Num_maillage() << flush; - } + { cout << " front " ; + if (angle_mort) + cout << "(angle mort) "; + cout << num_frontiere << " (dans le type) ("<TypeFrontiere()<<") de l'EF " << ptEl->Num_elt() + << " ("<< ptEl->Geometrie()<<", "<Interpolation() <<") mail. " + << ptEl->Num_maillage() << flush; + #ifdef UTILISATION_MPI + cout << "\n num_unique= "<Num_maillage() <<" , cree par l'element " << ptEl->Num_elt() << " de numero " << num_frontiere << " (dans le type) , de type de geometrie: " @@ -110,20 +113,23 @@ void Front::Affiche(int cas) const for (int i=1;i<=tabtaille;i++) cout << tabnoeud(i)->Num_noeud() << " , "; cout << " , et contiend les degres de liberte suivants: " - << elem->DdlElem_const(); + << elem->DdlElem_const(); if (this->tabmitoyen != NULL) - {int tai = this->tabmitoyen->Taille(); - cout << "\n " << tai << " elements mitoyens: ( "; - for (int i=1;i<=tai;i++) - cout << (*tabmitoyen)(i)->PtEI()->Num_elt() << " , "; - cout << ") "; - } + {int tai = this->tabmitoyen->Taille(); + cout << "\n " << tai << " elements mitoyens: ( "; + for (int i=1;i<=tai;i++) + cout << (*tabmitoyen)(i)->PtEI()->Num_elt() << " , "; + cout << ") "; + } else - cout << "\n *** aucun element mitoyen !!!! *** "; - }; + cout << "\n *** aucun element mitoyen !!!! *** "; + #ifdef UTILISATION_MPI + cout << "\n num_unique= "<Affiche(); +// cout << "\n second membre: " << (*residu); +// }; + + +//--- fin debug + + + #endif // --- intervention dans le cas d'une stabilisation d'hourglass // stabilisation pour un calcul implicit diff --git a/Elements/Mecanique/Hexaedre/Hexa.cc b/Elements/Mecanique/Hexaedre/Hexa.cc index 8fcfa41..7772bb4 100644 --- a/Elements/Mecanique/Hexaedre/Hexa.cc +++ b/Elements/Mecanique/Hexaedre/Hexa.cc @@ -60,7 +60,7 @@ Hexa::NombresConstruireHexa::NombresConstruireHexa() nbiS = 4; // le nombre de point d'intégration pour le calcul de second membre surfacique nbiA = 2; // le nombre de point d'intégration pour le calcul de second membre linéique nbiMas = 8; // le nombre de point d'intégration pour le calcul de la matrice masse - nbiHour = 0; // éventuellement, le nombre de point d'intégration un blocage d'hourglass + nbiHour = 0; // éventuellement, le nombre de point d'intégration un blocage d'hourglass }; @@ -85,20 +85,21 @@ Hexa::Hexa () : if ( doCoHexa == NULL) {hexa = new GeomHexalin(nombre->nbi); hexaEr = new GeomHexalin(nombre->nbiEr); - hexaMas = new GeomHexalin(nombre->nbiMas);} + hexaMas = new GeomHexalin(nombre->nbiMas); + } int dim = ParaGlob::Dimension(); if (dim != 3) // cas d'une dimension autre que trois - { if (ParaGlob::NiveauImpression() >= 7) - cout << "\nATTENTION -> dimension " << dim - <<", pas de definition d\'elements hexaedriques lineaires "<< endl; - delete hexa;delete hexaEr;delete hexaMas; - unefois = NULL; - } + { if (ParaGlob::NiveauImpression() >= 7) + cout << "\nATTENTION -> dimension " << dim + <<", pas de definition d\'elements hexaedriques lineaires "<< endl; + delete hexa;delete hexaEr;delete hexaMas; + unefois = NULL; + } else { unefois = & uneFois; // affectation du pointeur de la classe générique doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL); unefois->nbelem_in_Prog++; - } + }; }; }; @@ -121,7 +122,8 @@ Hexa::Hexa (int num_mail,int num_id) : if ( doCoHexa == NULL) {hexa = new GeomHexalin(nombre->nbi); hexaEr = new GeomHexalin(nombre->nbiEr); - hexaMas = new GeomHexalin(nombre->nbiMas);} + hexaMas = new GeomHexalin(nombre->nbiMas); + } #ifdef MISE_AU_POINT if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois {if (ParaGlob::NiveauImpression() >= 2) @@ -184,7 +186,7 @@ Hexa::Hexa (const Hexa& HexaraM) : // Constructeur de copie // a priori si on utilise le constructeur de copie, donc il y a déjà un élément // par contre a priori on ne doit pas faire une copie du premier élément -{ if (uneFois.nbelem_in_Prog == 1) +{if (uneFois.nbelem_in_Prog == 1) { cout << "\n **** erreur pour l'element Hexa, le constructeur de copie ne doit pas etre utilise" << " pour le premier element !! " << endl; Sortie (1); @@ -201,7 +203,7 @@ Hexa::~Hexa () { if (unefois != NULL) {unefois->nbelem_in_Prog--; Destruction(); - } + }; }; // affichage dans la sortie transmise, des variables duales "nom" diff --git a/Elements/Mecanique/Hexaedre/Hexa.h b/Elements/Mecanique/Hexaedre/Hexa.h index 965bc8b..1f8757f 100644 --- a/Elements/Mecanique/Hexaedre/Hexa.h +++ b/Elements/Mecanique/Hexaedre/Hexa.h @@ -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; diff --git a/Elements/Mecanique/Hexaedre/HexaMemb.h b/Elements/Mecanique/Hexaedre/HexaMemb.h index 0de6336..100d8c7 100644 --- a/Elements/Mecanique/Hexaedre/HexaMemb.h +++ b/Elements/Mecanique/Hexaedre/HexaMemb.h @@ -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 : diff --git a/Elements/Mecanique/Hexaedre/HexaQ.cc b/Elements/Mecanique/Hexaedre/HexaQ.cc index f52c0da..86e7507 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ.cc +++ b/Elements/Mecanique/Hexaedre/HexaQ.cc @@ -43,7 +43,7 @@ using namespace std; //introduces namespace std // la taille n'est pas defini ici car elle depend de la lecture //---------------------------------------------------------------- -HexaMemb::DonnComHexa * HexaQ::doCoHexa = NULL; +HexaMemb::DonnComHexa * HexaQ::doCoHexaQ = NULL; HexaMemb::UneFois HexaQ::uneFois; HexaQ::NombresConstruireHexaQ HexaQ::nombre_V; HexaQ::ConsHexaQ HexaQ::consHexaQ; @@ -60,7 +60,7 @@ HexaQ::NombresConstruireHexaQ::NombresConstruireHexaQ() nbiS = 4; // le nombre de point d'intégration pour le calcul de second membre surfacique nbiA = 2; // le nombre de point d'intégration pour le calcul de second membre linéique nbiMas = 27; // le nombre de point d'intégration pour le calcul de la matrice masse - nbiHour = 27; // éventuellement, le nombre de point d'intégration un blocage d'hourglass + nbiHour = 27; // éventuellement, le nombre de point d'intégration un blocage d'hourglass }; // =========================== constructeurs ================== @@ -69,14 +69,19 @@ HexaQ::NombresConstruireHexaQ::NombresConstruireHexaQ() // Constructeur par defaut, le seul accepte en dimension different de 3 HexaQ::HexaQ () : HexaMemb(0,-3,QUADRATIQUE,HEXAEDRE) - { nombre = & nombre_V; + { // on intervient seulement à partir du deuxième élément, + if (uneFois.nbelem_in_Prog == 0) + { uneFois.nbelem_in_Prog++; // au premier passage on se contente d'incrémenter + } + else // sinon on construit + {nombre = & nombre_V; tab_noeud.Change_taille(nombre->nbne); // 20 noeuds,8 pt d'integration // calcul de doCoHexaQ egalement si c'est le premier passage // après hexa, le nombre de point d'intégration de surface pour le second membre // ici 4 et 8 noeuds pour les éléments de surface ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL; - if ( doCoHexa == NULL) + if ( doCoHexaQ == NULL) {hexa = new GeomHexaQuad(nombre->nbi); // pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité // de la matrice de raideur -> 27 @@ -86,37 +91,44 @@ HexaQ::HexaQ () : } int dim = ParaGlob::Dimension(); if (dim != 3) // cas d'une dimension autre que trois - { if (ParaGlob::NiveauImpression() >= 7) - cout << "\nATTENTION -> dimension " << dim - <<", pas de definition d\'elements hexaedriques quadratiques "<< endl; - delete hexa;delete hexaEr;delete hexaMas; - unefois = NULL; - } + { if (ParaGlob::NiveauImpression() >= 7) + cout << "\nATTENTION -> dimension " << dim + <<", pas de definition d\'elements hexaedriques quadratiques "<< endl; + delete hexa;delete hexaEr;delete hexaMas; + unefois = NULL; + } else - { unefois = & uneFois; // affectation du pointeur de la classe générique triangle - doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL); + { unefois = & uneFois; // affectation du pointeur de la classe générique HexaMemb + doCoHexaQ = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL); unefois->nbelem_in_Prog++; - } + }; + }; }; // Constructeur fonction d'un numero // d'identification HexaQ::HexaQ (int num_mail,int num_id) : HexaMemb(num_mail,num_id,QUADRATIQUE,HEXAEDRE) - { nombre = & nombre_V; + { // on intervient seulement à partir du deuxième élément, + if (uneFois.nbelem_in_Prog == 0) + { uneFois.nbelem_in_Prog++; // au premier passage on se contente d'incrémenter + } + else // sinon on construit + {nombre = & nombre_V; tab_noeud.Change_taille(nombre->nbne); // 20 noeuds,8 pt d'integration - // calcul de doCoHexa egalement si c'est le premier passage + // calcul de doCoHexaQ egalement si c'est le premier passage // après hexa, le nombre de point d'intégration de surface pour le second membre // ici 4 et 4 noeuds pour les éléments de surface ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL; - if ( doCoHexa == NULL) + if ( doCoHexaQ == NULL) {hexa = new GeomHexaQuad(nombre->nbi); // pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité // de la matrice de raideur -> 27 - hexaEr = new GeomHexaQuad(nombre->nbiEr);} + hexaEr = new GeomHexaQuad(nombre->nbiEr); // idem pour les calculs de matrices masses consitstantes hexaMas = new GeomHexaQuad(nombre->nbiMas); + } #ifdef MISE_AU_POINT if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois { if (ParaGlob::NiveauImpression() >= 2) @@ -125,48 +137,57 @@ HexaQ::HexaQ (int num_mail,int num_id) : Sortie (1); } #endif - { unefois = & uneFois; // affectation du pointeur de la classe générique triangle - doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL); + { unefois = & uneFois; // affectation du pointeur de la classe générique HexaMemb + doCoHexaQ = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL); unefois->nbelem_in_Prog++; - } + }; + }; }; // Constructeur utile si le numero de l'element et // le tableau des noeuds sont connus HexaQ::HexaQ (int num_mail,int num_id,const Tableau& tab): HexaMemb(num_mail,num_id,QUADRATIQUE,HEXAEDRE,tab) -{ nombre = & nombre_V; - if (tab_noeud.Taille() != nombre->nbne) - { cout << "\n erreur de dimensionnement du tableau de noeud \n"; - cout << " HexaQ::HexaQ (int num_mail,int num_id,const Tableau& tab)\n"; - Sortie (1); } - // 20 noeuds,8 pt d'integration - // calcul de doCoHexa egalement si c'est le premier passage - // après hexa, le nombre de point d'intégration de surface pour le second membre - // ici 4 et 4 noeuds pour les éléments de surface - ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL; - if ( doCoHexa == NULL) - {hexa = new GeomHexaQuad(nombre->nbi); - // pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité - // de la matrice de raideur -> nombre->nbiEr - hexaEr = new GeomHexaQuad(nombre->nbiEr);} - // idem pour les calculs de matrices masses consitstantes - hexaMas = new GeomHexaQuad(nombre->nbiMas); - #ifdef MISE_AU_POINT - if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois - { if (ParaGlob::NiveauImpression() >= 2) - cout << "\n erreur de dimension dans HexaQ, dim = " << ParaGlob::Dimension() - << "\n alors que l'on doit avoir 3 !! " << endl; - Sortie (1); - } - #endif - { unefois = & uneFois; // affectation du pointeur de la classe générique triangle - bool sans_init_noeud = true; - doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL,sans_init_noeud); - // construction du tableau de ddl spécifique à l'élément pour ses - ConstTabDdl(); - unefois->nbelem_in_Prog++; - } +{ // on intervient seulement à partir du deuxième élément, + if (uneFois.nbelem_in_Prog == 0) + { uneFois.nbelem_in_Prog++; // au premier passage on se contente d'incrémenter + } + else // sinon on construit + {nombre = & nombre_V; + if (tab_noeud.Taille() != nombre->nbne) + { cout << "\n erreur de dimensionnement du tableau de noeud \n"; + cout << " HexaQ::HexaQ (int num_mail,int num_id,const Tableau& tab)\n"; + Sortie (1); + } + // 20 noeuds,8 pt d'integration + // calcul de doCoHexaQ egalement si c'est le premier passage + // après hexa, le nombre de point d'intégration de surface pour le second membre + // ici 4 et 4 noeuds pour les éléments de surface + ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL; + if ( doCoHexaQ == NULL) + {hexa = new GeomHexaQuad(nombre->nbi); + // pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité + // de la matrice de raideur -> nombre->nbiEr + hexaEr = new GeomHexaQuad(nombre->nbiEr); + // idem pour les calculs de matrices masses consitstantes + hexaMas = new GeomHexaQuad(nombre->nbiMas); + } + #ifdef MISE_AU_POINT + if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois + { if (ParaGlob::NiveauImpression() >= 2) + cout << "\n erreur de dimension dans HexaQ, dim = " << ParaGlob::Dimension() + << "\n alors que l'on doit avoir 3 !! " << endl; + Sortie (1); + } + #endif + { unefois = & uneFois; // affectation du pointeur de la classe générique triangle + bool sans_init_noeud = true; + doCoHexaQ = HexaMemb::Init (hexa,hexaEr,hexaMas,NULL,sans_init_noeud); + // construction du tableau de ddl spécifique à l'élément pour ses + ConstTabDdl(); + unefois->nbelem_in_Prog++; + } + }; }; HexaQ::HexaQ (const HexaQ& HexaQraM) : @@ -174,17 +195,24 @@ HexaQ::HexaQ (const HexaQ& HexaQraM) : // Constructeur de copie { ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL; - unefois = & uneFois; // affectation du pointeur de la classe générique + if (uneFois.nbelem_in_Prog == 1) + { cout << "\n **** erreur pour l'element HexaQ, le constructeur de copie ne doit pas etre utilise" + << " pour le premier element !! " << endl; + Sortie (1); + } + else + {unefois = & uneFois; // affectation du pointeur de la classe générique // ce qui est relatif à l'initialisation est déjà effectué dans elem_meca et HexaMemb - unefois->nbelem_in_Prog++; - }; + unefois->nbelem_in_Prog++; + }; + }; HexaQ::~HexaQ () // Destruction effectuee dans HexaMemb { if (unefois != NULL) {unefois->nbelem_in_Prog--; Destruction(); - } + }; }; // renseignement d'un élément quadratique incomplet à partir d'un élément linéaire de même type @@ -210,9 +238,9 @@ list HexaQ::Construct_from_lineaire(const Element & elem,list 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 const & ptlocal = doCoHexa->hexaed->PtelemRef(); + Tableau 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 HexaQ::Construct_from_lineaire(const Element & elem,list > const & nons = doCoHexa->hexaed->NonS(); + Tableau > const & nons = doCoHexaQ->hexaed->NonS(); // initialisation de li_bornes li_bornes.erase(li_bornes.begin(),li_bornes.end()); // on boucle sur les arrêtes diff --git a/Elements/Mecanique/Hexaedre/HexaQ.h b/Elements/Mecanique/Hexaedre/HexaQ.h index 51c268f..41874ab 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ.h +++ b/Elements/Mecanique/Hexaedre/HexaQ.h @@ -145,8 +145,8 @@ class HexaQ : public HexaMemb ElFrontiere* new_frontiere_surf(int ,Tableau & 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; diff --git a/Elements/Mecanique/Hexaedre/HexaQComp.cc b/Elements/Mecanique/Hexaedre/HexaQComp.cc index 8163551..c79bfdf 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp.cc +++ b/Elements/Mecanique/Hexaedre/HexaQComp.cc @@ -43,7 +43,7 @@ using namespace std; //introduces namespace std // la taille n'est pas defini ici car elle depend de la lecture //---------------------------------------------------------------- -HexaMemb::DonnComHexa * HexaQComp::doCoHexa = NULL; +HexaMemb::DonnComHexa * HexaQComp::doCoHexaQComp = NULL; HexaMemb::UneFois HexaQComp::uneFois; HexaQComp::NombresConstruireHexaQComp HexaQComp::nombre_V; HexaQComp::ConsHexaQComp HexaQComp::consHexaQComp; @@ -70,133 +70,160 @@ HexaQComp::NombresConstruireHexaQComp::NombresConstruireHexaQComp() // Constructeur par defaut, le seul accepte en dimension different de 3 HexaQComp::HexaQComp () : HexaMemb(0,-3,QUADRACOMPL,HEXAEDRE) - { nombre = & nombre_V; - tab_noeud.Change_taille(nombre->nbne); - // 27 noeuds,8 pt d'integration - // calcul de doCoHexaQComp egalement si c'est le premier passage - // après hexa, le nombre de point d'intégration de surface pour le second membre - // ici 4 et 9 noeuds pour les éléments de surface - ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL; - ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass - if ( doCoHexa == NULL) - {hexa = new GeomHexaQuadComp(nombre->nbi); - // pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité - // de la matrice de raideur -> 27 - hexaEr = new GeomHexaQuadComp(nombre->nbiEr); - // idem pour les calculs de matrices masses consitstantes - hexaMas = new GeomHexaQuadComp(nombre->nbiMas); - hexaeHourg = new GeomHexaQuadComp(nombre->nbiHour); - } - int dim = ParaGlob::Dimension(); - if (dim != 3) // cas d'une dimension autre que trois - { if (ParaGlob::NiveauImpression() >= 7) - cout << "\nATTENTION -> dimension " << dim - <<", pas de definition d\'elements hexaedriques quadratiques complet"<< endl; - delete hexa;delete hexaEr;delete hexaMas; - unefois = NULL; - } - else - { unefois = & uneFois; // affectation du pointeur de la classe générique triangle - doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg); - unefois->nbelem_in_Prog++; - } -}; + {// on intervient seulement à partir du deuxième élément, + if (uneFois.nbelem_in_Prog == 0) + { uneFois.nbelem_in_Prog++; // au premier passage on se contente d'incrémenter + } + else // sinon on construit + { nombre = & nombre_V; + tab_noeud.Change_taille(nombre->nbne); + // 27 noeuds,8 pt d'integration + // calcul de doCoHexaQComp egalement si c'est le premier passage + // après hexa, le nombre de point d'intégration de surface pour le second membre + // ici 4 et 9 noeuds pour les éléments de surface + ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL; + ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass + if ( doCoHexaQComp == NULL) + {hexa = new GeomHexaQuadComp(nombre->nbi); + // pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité + // de la matrice de raideur -> 27 + hexaEr = new GeomHexaQuadComp(nombre->nbiEr); + // idem pour les calculs de matrices masses consitstantes + hexaMas = new GeomHexaQuadComp(nombre->nbiMas); + hexaeHourg = new GeomHexaQuadComp(nombre->nbiHour); + } + int dim = ParaGlob::Dimension(); + if (dim != 3) // cas d'une dimension autre que trois + { if (ParaGlob::NiveauImpression() >= 7) + cout << "\nATTENTION -> dimension " << dim + <<", pas de definition d\'elements hexaedriques quadratiques complet"<< endl; + delete hexa;delete hexaEr;delete hexaMas; + unefois = NULL; + } + else + { unefois = & uneFois; // affectation du pointeur de la classe générique triangle + doCoHexaQComp = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg); + unefois->nbelem_in_Prog++; + }; + } + }; // Constructeur fonction d'un numero // d'identification HexaQComp::HexaQComp (int num_mail,int num_id) : HexaMemb(num_mail,num_id,QUADRACOMPL,HEXAEDRE) - { nombre = & nombre_V; - tab_noeud.Change_taille(nombre->nbne); - // 27 noeuds,8 pt d'integration - // calcul de doCoHexa egalement si c'est le premier passage - // après hexa, le nombre de point d'intégration de surface pour le second membre - // ici 4 et 9 noeuds pour les éléments de surface - ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL; - ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass - if ( doCoHexa == NULL) - {hexa = new GeomHexaQuadComp(nombre->nbi); - // pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité - // de la matrice de raideur -> 27 - hexaEr = new GeomHexaQuadComp(nombre->nbiEr); - }; - // idem pour les calculs de matrices masses consitstantes - hexaMas = new GeomHexaQuadComp(nombre->nbiMas); - hexaeHourg = new GeomHexaQuadComp(nombre->nbiHour); + {// on intervient seulement à partir du deuxième élément, + if (uneFois.nbelem_in_Prog == 0) + { uneFois.nbelem_in_Prog++; // au premier passage on se contente d'incrémenter + } + else // sinon on construit + { nombre = & nombre_V; + tab_noeud.Change_taille(nombre->nbne); + // 27 noeuds,8 pt d'integration + // calcul de doCoHexaQComp egalement si c'est le premier passage + // après hexa, le nombre de point d'intégration de surface pour le second membre + // ici 4 et 9 noeuds pour les éléments de surface + ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL; + ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass + if ( doCoHexaQComp == NULL) + {hexa = new GeomHexaQuadComp(nombre->nbi); + // pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité + // de la matrice de raideur -> 27 + hexaEr = new GeomHexaQuadComp(nombre->nbiEr); + // idem pour les calculs de matrices masses consitstantes + hexaMas = new GeomHexaQuadComp(nombre->nbiMas); + hexaeHourg = new GeomHexaQuadComp(nombre->nbiHour); + }; // #ifdef MISE_AU_POINT - if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois - { if (ParaGlob::NiveauImpression() >= 2) - cout << "\n erreur de dimension dans HexaQComp, dim = " << ParaGlob::Dimension() - << "\n alors que l'on doit avoir 3 !! " << endl; - Sortie (1); - } -// #endif - else - {unefois = & uneFois; // affectation du pointeur de la classe générique - doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg); - unefois->nbelem_in_Prog++; - }; -}; - + if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois + { if (ParaGlob::NiveauImpression() >= 2) + cout << "\n erreur de dimension dans HexaQComp, dim = " << ParaGlob::Dimension() + << "\n alors que l'on doit avoir 3 !! " << endl; + Sortie (1); + } + // #endif + else + {unefois = & uneFois; // affectation du pointeur de la classe générique + doCoHexaQComp = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg); + unefois->nbelem_in_Prog++; + }; + }; + }; // Constructeur utile si le numero de l'element et // le tableau des noeuds sont connus HexaQComp::HexaQComp (int num_mail,int num_id,const Tableau& tab): HexaMemb(num_mail,num_id,QUADRACOMPL,HEXAEDRE,tab) -{ nombre = & nombre_V; - if (tab_noeud.Taille() != nombre->nbne) - { cout << "\n erreur de dimensionnement du tableau de noeud \n"; - cout << " HexaQComp::HexaQComp (int num_mail,int num_id,const Tableau& tab)\n"; - Sortie (1); - }; - // 27 noeuds,8 pt d'integration - // calcul de doCoHexa egalement si c'est le premier passage - // après hexa, le nombre de point d'intégration de surface pour le second membre - // ici 4 et 9 noeuds pour les éléments de surface - ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL; - ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass - if ( doCoHexa == NULL) - {hexa = new GeomHexaQuadComp(nombre->nbi); - // pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité - // de la matrice de raideur -> nombre->nbiEr - hexaEr = new GeomHexaQuadComp(nombre->nbiEr);} - // idem pour les calculs de matrices masses consitstantes - hexaMas = new GeomHexaQuadComp(nombre->nbiMas); - hexaeHourg = new GeomHexaQuadComp(nombre->nbiHour); -// #ifdef MISE_AU_POINT - if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois - { if (ParaGlob::NiveauImpression() >= 2) - cout << "\n erreur de dimension dans HexaQComp, dim = " << ParaGlob::Dimension() - << "\n alors que l'on doit avoir 3 !! " << endl; - Sortie (1); - } -// #endif - else - { unefois = & uneFois; // affectation du pointeur de la classe générique triangle - bool sans_init_noeud = true; - doCoHexa = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg,sans_init_noeud); - // construction du tableau de ddl spécifique à l'élément pour ses - ConstTabDdl(); - unefois->nbelem_in_Prog++; + {// on intervient seulement à partir du deuxième élément, + if (uneFois.nbelem_in_Prog == 0) + { uneFois.nbelem_in_Prog++; // au premier passage on se contente d'incrémenter + } + else // sinon on construit + { nombre = & nombre_V; + if (tab_noeud.Taille() != nombre->nbne) + { cout << "\n erreur de dimensionnement du tableau de noeud \n"; + cout << " HexaQComp::HexaQComp (int num_mail,int num_id,const Tableau& tab)\n"; + Sortie (1); + }; + // 27 noeuds,8 pt d'integration + // calcul de doCoHexaQComp egalement si c'est le premier passage + // après hexa, le nombre de point d'intégration de surface pour le second membre + // ici 4 et 9 noeuds pour les éléments de surface + ElemGeomC0* hexa=NULL;ElemGeomC0* hexaEr=NULL; ElemGeomC0* hexaMas=NULL; + ElemGeomC0* hexaeHourg; // pour le blocage d'hourglass + if ( doCoHexaQComp == NULL) + {hexa = new GeomHexaQuadComp(nombre->nbi); + // pour le calcul d'erreur il faut plus de pt d'intégration pour éviter la singularité + // de la matrice de raideur -> nombre->nbiEr + hexaEr = new GeomHexaQuadComp(nombre->nbiEr); + // idem pour les calculs de matrices masses consitstantes + hexaMas = new GeomHexaQuadComp(nombre->nbiMas); + hexaeHourg = new GeomHexaQuadComp(nombre->nbiHour); + } + // #ifdef MISE_AU_POINT + if (ParaGlob::Dimension() != 3) // cas d'une dimension autre que trois + { if (ParaGlob::NiveauImpression() >= 2) + cout << "\n erreur de dimension dans HexaQComp, dim = " << ParaGlob::Dimension() + << "\n alors que l'on doit avoir 3 !! " << endl; + Sortie (1); + } + // #endif + else + { unefois = & uneFois; // affectation du pointeur de la classe générique triangle + bool sans_init_noeud = true; + doCoHexaQComp = HexaMemb::Init (hexa,hexaEr,hexaMas,hexaeHourg,sans_init_noeud); + // construction du tableau de ddl spécifique à l'élément pour ses + ConstTabDdl(); + unefois->nbelem_in_Prog++; + }; }; -}; + }; HexaQComp::HexaQComp (const HexaQComp& HexaQraM) : HexaMemb (HexaQraM) // Constructeur de copie - { unefois = & uneFois; // affectation du pointeur de la classe générique - // ce qui est relatif à l'initialisation est déjà effectué dans elem_meca et HexaMemb - unefois->nbelem_in_Prog++; - }; - -HexaQComp::~HexaQComp () -// Destruction effectuee dans HexaMemb -{ if (unefois != NULL) - {unefois->nbelem_in_Prog--; - Destruction(); - } -}; + // a priori si on utilise le constructeur de copie, donc il y a déjà un élément + // par contre a priori on ne doit pas faire une copie du premier élément + {if (uneFois.nbelem_in_Prog == 1) + { cout << "\n **** erreur pour l'element HexaQComp, le constructeur de copie ne doit pas etre utilise" + << " pour le premier element !! " << endl; + Sortie (1); + } + else + { unefois = & uneFois; // affectation du pointeur de la classe générique + // ce qui est relatif à l'initialisation est déjà effectué dans elem_meca et HexaMemb + unefois->nbelem_in_Prog++; + }; + }; + HexaQComp::~HexaQComp () + // Destruction effectuee dans HexaMemb + { if (unefois != NULL) + {unefois->nbelem_in_Prog--; + Destruction(); + } + }; + // renseignement d'un élément complet à partir d'un élément incomplet de même type // retourne les nouveaux noeuds construit à partir de l'interpolation incomplète. @@ -221,9 +248,9 @@ list HexaQComp::Construct_from_imcomplet(const Element & elem,list 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 const & ptlocal = doCoHexa->hexaed->PtelemRef(); + Tableau 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 HexaQComp::Construct_from_imcomplet(const Element & elem,list > const & nonf = doCoHexa->hexaed->Nonf(); + Tableau > 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 diff --git a/Elements/Mecanique/Hexaedre/HexaQComp.h b/Elements/Mecanique/Hexaedre/HexaQComp.h index 5518e5b..d2fa592 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp.h +++ b/Elements/Mecanique/Hexaedre/HexaQComp.h @@ -145,8 +145,8 @@ class HexaQComp : public HexaMemb ElFrontiere* new_frontiere_surf(int ,Tableau & 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; diff --git a/Elements/Mecanique/Hexaedre/HexaQComp_1pti.cc b/Elements/Mecanique/Hexaedre/HexaQComp_1pti.cc index b329d80..89aeac5 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp_1pti.cc +++ b/Elements/Mecanique/Hexaedre/HexaQComp_1pti.cc @@ -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& 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 Tableaunbelem_in_Prog++; diff --git a/Elements/Mecanique/Hexaedre/HexaQComp_27pti.cc b/Elements/Mecanique/Hexaedre/HexaQComp_27pti.cc index c85d4c4..93ab7be 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp_27pti.cc +++ b/Elements/Mecanique/Hexaedre/HexaQComp_27pti.cc @@ -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& 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 Tableaunbelem_in_Prog++; diff --git a/Elements/Mecanique/Hexaedre/HexaQComp_64pti.cc b/Elements/Mecanique/Hexaedre/HexaQComp_64pti.cc index dee92da..1ca96d3 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp_64pti.cc +++ b/Elements/Mecanique/Hexaedre/HexaQComp_64pti.cc @@ -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& 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 Tableaunbelem_in_Prog++; diff --git a/Elements/Mecanique/Hexaedre/HexaQComp_cm1pti.h b/Elements/Mecanique/Hexaedre/HexaQComp_cm1pti.h index 03103b6..c71a0ad 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp_cm1pti.h +++ b/Elements/Mecanique/Hexaedre/HexaQComp_cm1pti.h @@ -136,8 +136,8 @@ class HexaQComp_cm1pti : public HexaMemb ElFrontiere* new_frontiere_surf(int ,Tableau & 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; diff --git a/Elements/Mecanique/Hexaedre/HexaQComp_cm27pti.h b/Elements/Mecanique/Hexaedre/HexaQComp_cm27pti.h index 6666f9e..70ffae4 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp_cm27pti.h +++ b/Elements/Mecanique/Hexaedre/HexaQComp_cm27pti.h @@ -136,8 +136,8 @@ class HexaQComp_cm27pti : public HexaMemb ElFrontiere* new_frontiere_surf(int ,Tableau & 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; diff --git a/Elements/Mecanique/Hexaedre/HexaQComp_cm64pti.h b/Elements/Mecanique/Hexaedre/HexaQComp_cm64pti.h index 3ae7fe5..f069a05 100644 --- a/Elements/Mecanique/Hexaedre/HexaQComp_cm64pti.h +++ b/Elements/Mecanique/Hexaedre/HexaQComp_cm64pti.h @@ -136,8 +136,8 @@ class HexaQComp_cm64pti : public HexaMemb ElFrontiere* new_frontiere_surf(int ,Tableau & 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; diff --git a/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.cc b/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.cc index 1b0521b..c1b8161 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.cc +++ b/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.cc @@ -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& tab) cout << " HexaQ_cm1pti::HexaQ_cm1pti (int num_mail,int num_id,const Tableau& 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& 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++; diff --git a/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.h b/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.h index 52b2e5e..7aac17f 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.h +++ b/Elements/Mecanique/Hexaedre/HexaQ_cm1pti.h @@ -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; diff --git a/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.cc b/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.cc index 959805f..8aa1fcc 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.cc +++ b/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.cc @@ -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& ta cout << " HexaQ_cm27pti::HexaQ_cm27pti (int num_mail,int num_id,const Tableau& 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& 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++; diff --git a/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.h b/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.h index 5d727bc..073c3fb 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.h +++ b/Elements/Mecanique/Hexaedre/HexaQ_cm27pti.h @@ -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; diff --git a/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.cc b/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.cc index d5f5584..4a2f397 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.cc +++ b/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.cc @@ -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& ta cout << " HexaQ_cm64pti::HexaQ_cm64pti (int num_mail,int num_id,const Tableau& 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& 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++; diff --git a/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.h b/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.h index e58a840..fc1d502 100644 --- a/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.h +++ b/Elements/Mecanique/Hexaedre/HexaQ_cm64pti.h @@ -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; diff --git a/Elements/Mecanique/Hexaedre/Hexa_cm1pti.cc b/Elements/Mecanique/Hexaedre/Hexa_cm1pti.cc index 6bc6d7a..9e5a64b 100644 --- a/Elements/Mecanique/Hexaedre/Hexa_cm1pti.cc +++ b/Elements/Mecanique/Hexaedre/Hexa_cm1pti.cc @@ -44,7 +44,7 @@ using namespace std; //introduces namespace std // la taille n'est pas defini ici car elle depend de la lecture //---------------------------------------------------------------- -HexaMemb::DonnComHexa * Hexa_cm1pti::doCoHexa_cm1pti = NULL; +HexaMemb::DonnComHexa * Hexa_cm1pti::doCoHexa_cm1pti = NULL; HexaMemb::UneFois Hexa_cm1pti::uneFois; Hexa_cm1pti::NombresConstruireHexa_cm1pti Hexa_cm1pti::nombre_V; Hexa_cm1pti::ConsHexa_cm1pti Hexa_cm1pti::consHexa_cm1pti; diff --git a/Elements/Mecanique/Hexaedre/Hexa_cm1pti.h b/Elements/Mecanique/Hexaedre/Hexa_cm1pti.h index 2cb9634..21c812e 100644 --- a/Elements/Mecanique/Hexaedre/Hexa_cm1pti.h +++ b/Elements/Mecanique/Hexaedre/Hexa_cm1pti.h @@ -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; diff --git a/Elements/Mecanique/Hexaedre/Hexa_cm27pti.cc b/Elements/Mecanique/Hexaedre/Hexa_cm27pti.cc index 8a6f088..b36c029 100644 --- a/Elements/Mecanique/Hexaedre/Hexa_cm27pti.cc +++ b/Elements/Mecanique/Hexaedre/Hexa_cm27pti.cc @@ -43,7 +43,7 @@ using namespace std; //introduces namespace std // la taille n'est pas defini ici car elle depend de la lecture //---------------------------------------------------------------- -HexaMemb::DonnComHexa * Hexa_cm27pti::doCoHexa_cm27pti = NULL; +HexaMemb::DonnComHexa * Hexa_cm27pti::doCoHexa_cm27pti = NULL; HexaMemb::UneFois Hexa_cm27pti::uneFois; Hexa_cm27pti::NombresConstruireHexa_cm27pti Hexa_cm27pti::nombre_V; Hexa_cm27pti::ConsHexa_cm27pti Hexa_cm27pti::consHexa_cm27pti; diff --git a/Elements/Mecanique/Hexaedre/Hexa_cm27pti.h b/Elements/Mecanique/Hexaedre/Hexa_cm27pti.h index 5c99caa..4d4b65d 100644 --- a/Elements/Mecanique/Hexaedre/Hexa_cm27pti.h +++ b/Elements/Mecanique/Hexaedre/Hexa_cm27pti.h @@ -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; diff --git a/Elements/Mecanique/Hexaedre/Hexa_cm64pti.cc b/Elements/Mecanique/Hexaedre/Hexa_cm64pti.cc index 7907d1d..73ce626 100644 --- a/Elements/Mecanique/Hexaedre/Hexa_cm64pti.cc +++ b/Elements/Mecanique/Hexaedre/Hexa_cm64pti.cc @@ -50,7 +50,7 @@ Hexa_cm64pti::ConsHexa_cm64pti Hexa_cm64pti::consHexa_cm64pti; // constructeur des nombres spécifiques à la classe -Hexa_cm64pti::NombresConstruireHexa_cm64pti::NombresConstruireHexa_cm64pti() +Hexa_cm64pti::NombresConstruireHexa_cm64pti::NombresConstruireHexa_cm64pti() { nbne = 8; // le nombre de noeud de l'élément nbneS = 4; // le nombre de noeud des facettes nbneA = 2; // le nombre de noeud des aretes diff --git a/Elements/Mecanique/Hexaedre/Hexa_cm64pti.h b/Elements/Mecanique/Hexaedre/Hexa_cm64pti.h index 74b0706..f85cc60 100644 --- a/Elements/Mecanique/Hexaedre/Hexa_cm64pti.h +++ b/Elements/Mecanique/Hexaedre/Hexa_cm64pti.h @@ -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; diff --git a/Elements/Mecanique/Tetraedre/TetraQ.cc b/Elements/Mecanique/Tetraedre/TetraQ.cc index 99f5f3d..acc924b 100644 --- a/Elements/Mecanique/Tetraedre/TetraQ.cc +++ b/Elements/Mecanique/Tetraedre/TetraQ.cc @@ -62,7 +62,7 @@ TetraQ::NombresConstruireTetraQ::NombresConstruireTetraQ() nbiS = 3; // le nombre de point d'intégration pour le calcul de second membre surfacique nbiA = 2; // le nombre de point d'intégration pour le calcul de second membre linéique nbiMas = 15; // le nombre de point d'intégration pour le calcul de la matrice masse - nbiHour = 0; // le nombre de point d'intégration un blocage d'hourglass + nbiHour = 0; // le nombre de point d'intégration un blocage d'hourglass }; // =========================== constructeurs ================== diff --git a/General/Projet.cc b/General/Projet.cc index 9e23da5..f0708ff 100644 --- a/General/Projet.cc +++ b/General/Projet.cc @@ -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 diff --git a/General/herezh.cc b/General/herezh.cc index ae7f8f4..b6d338d 100644 --- a/General/herezh.cc +++ b/General/herezh.cc @@ -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 }; diff --git a/Lecture/utilLecture2.cc b/Lecture/utilLecture2.cc index 547bc2f..7f0d715 100644 --- a/Lecture/utilLecture2.cc +++ b/Lecture/utilLecture2.cc @@ -198,7 +198,7 @@ void UtilLecture::Ouverture_base_info(string type_entree) }; #ifndef UTILISATION_MPI }; - } + } #else // #ifdef UTILISATION_MPI @@ -224,8 +224,14 @@ void UtilLecture::Ouverture_base_info(string type_entree) if (ent_PI != NULL) {ent_PI->close();ent_PI = NULL;}; streampos debut_increment(0); #else - if (ent_MPI_PI != MPI_FILE_NULL) - {MPI_File_close(&ent_MPI_PI);ent_MPI_PI = MPI_FILE_NULL;}; + if(num_cpu_en_cours_BI == 0) + // seule le proc 0 gère le fichier PI + {if (ent_MPI_PI != MPI_FILE_NULL) + {MPI_File_close(&ent_MPI_PI);}; + } + // pour tous les proc on met la variable de fichier à NULL + // ce qui est utile pour les tests à suivre + ent_MPI_PI = MPI_FILE_NULL; MPI_Offset debut_increment(0); #endif // on efface les positions actuelles @@ -334,7 +340,7 @@ void UtilLecture::Ouverture_base_info(string type_entree) {liste_posi_BI.clear(); int taille = inter.size(); for (int i=0;i + #include + 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 >& 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 t_noe(nb_noeud); // le tableau global de noeuds + Tableau t_noe(nb_noeud); // le tableau global de noeuds: ne change pas après l'affectation qui suit Tableau t_oldNumNoeud(nb_noeud); // tableau des anciens numéros de noeuds Tableau 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 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="<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;isend(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"<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 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 > 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 tab_N_final_final;// ne sert que pour le cas nb_casAssemb != NULL + Tableau tab_N_final; +#ifdef UTILISATION_MPI +// std::vector vect_tab_N_final_final(nb_noeud); // pour le transfert + DeuxEntiers indic_phase1; + std::array indic_result; // "" +// std::vector vect_finalNumNoeud(nb_noeud); // tableau des numéros de noeuds finaux + std::list li_newNumNoeud; // list des nouveaux numéros de noeuds + std::list li_num_tab_N_final; +// std::vector > 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 tab_N_final = Maillage::Cuthill_Mac_Kee(nb_noeud,noe_dep,t_voisin,lis_descent); + { +//------- début de la partie qui sera absente dans le cas des proc != 0 ----------------- + // on appelle l'algorithme de Cuthill Mac Kee + tab_N_final = Maillage::Cuthill_Mac_Kee(nb_noeud,noe_dep,t_voisin,lis_descent); + #ifdef UTILISATION_MPI + // les numéros pointés par tab_N_final changent mais pas les éléments pointés + // et ici les numéros de noeuds n'ont pas encore changés + // donc tab_N_final(i) pointe sur toe(tab_N_final(i)->Num_noeud()) + for (int inoe=1;inoe <= nb_noeud; inoe++) + li_num_tab_N_final.push_back(tab_N_final(inoe)->Num_noeud()); // pour le transfert + #endif // --- maintenant on regarde l'évolution de la largeur de bande en noeud // tout d'abord la largeur initiale int largeur_initiale = Maillage::LargeurBandeEnNoeuds(t_elem); @@ -2140,8 +2237,8 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau 3) - || ((nb_casAssemb == NULL)&&(ParaGlob::NiveauImpression() > 0)) + if ( (ParaGlob::NiveauImpression() > 3) + || ((nb_casAssemb == NULL)&&(ParaGlob::NiveauImpression() > 0)) ) { cout << "\n $$ Premiere etape: optimisation sur l'ensemble des maillages sous forme d'un seul groupe $$ "; cout << "\n pour l'ensemble des maillages: 1/2 largeur de bande en noeud, initiale= " << largeur_initiale @@ -2200,17 +2297,117 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau 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 tab_N_final_final;// ne sert que pour le cas nb_casAssemb != NULL if (nouvelle_numerotation && (nb_casAssemb != NULL)) { // on garde en mémoire la numérotation des noeuds, dans l'ordre de tab_N_final // car on ne connait pas exactement le cheminement précédent de ce qui est retenue au final - tab_N_final_final.Change_taille(nb_noeud); - for (int i=1;i<=nb_noeud;i++) - tab_N_final_final(tab_N_final(i)->Num_noeud()) = tab_N_final(i); + + #ifdef UTILISATION_MPI + // les proc i reconstruisent le tableau tab_N_final_final à partir des infos + // récupérées du proc 0 + if (num_proc != 0) + // on met la numérotation comme elle est dans le cas du proc 0 + { + {// on remet la numérotation initiale dans noe + for (int ia=1;ia <= nb_noeud; ia++) + t_noe(ia)->Change_num_noeud(t_oldNumNoeud(ia)); + // on reconstruit tab_N_final + std::list::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::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("<recv(0, 300001, mess); +// if (mess==num_proc) +// {cout << "\n rebouclage :: proc "<Num_noeud() +// <<", t_noe("<> 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 Num_Mail())(t_oldNumNoeud(ia))=noe->Num_noeud(); }; +// #ifdef UTILISATION_MPI +// // on sauvegarde t_nv_num dans un std::vector pour le transmette au proc i +// for (int iml=1; iml<= nbMaillageTotal;iml++) +// {int taille = tabMaillage(iml)->Nombre_noeud(); +// for (int i=0;i& condCLL = tab_condCLL(i); @@ -2332,8 +2535,6 @@ bool LesMaillages::Renumerotation(LesReferences& lesRef,const Tableau Change_num_noeud(t_oldNumNoeud(i)); - if (ParaGlob::NiveauImpression() >= 3) - cout << "\n $$$ au final numerot. idem $$$ " << flush; - nouvelle_numerotation = false; - calcul_ok = true; - }; - + {// on remet néanmoins l'ancienne numérotation, car elle a changé + int nbN = t_noe.Taille(); + for (int i=1;i<=nbN;i++) + t_noe(i)->Change_num_noeud(t_oldNumNoeud(i)); + if (ParaGlob::NiveauImpression() >= 3) + cout << "\n $$$ au final numerot. idem $$$ " << flush; + nouvelle_numerotation = false; + calcul_ok = true; + }; +////------------debug --------- +//cout << "\n proc 0 : debug LesMaillages::Renumerotation "; +//for (int i=1;i<=nb_noeud;i++) +// cout << "\n i= "<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 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::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;iNum_noeud()); +// tab_N_final_final(i+1) = t_noe(vect_tab_N_final_final[i]); + }; + //-------- debug --------- + cout << "\n rebouclage :: proc "<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 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 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 > 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()= "<Num_Mail() <<", ia= "<< ia + // << " noe->Num_noeud()= "<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 *> 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= "<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="<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;isend(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"<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); diff --git a/Parametres/EnteteParaGlob.h b/Parametres/EnteteParaGlob.h index 7d26b63..5473c80 100644 --- a/Parametres/EnteteParaGlob.h +++ b/Parametres/EnteteParaGlob.h @@ -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 diff --git a/References/LesReferences.cc b/References/LesReferences.cc index 3f520f1..32f3da0 100644 --- a/References/LesReferences.cc +++ b/References/LesReferences.cc @@ -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 & nv_tab,int num_mail,Tableau & non_referencer) +void LesReferences::Mise_a_jour_ref_noeud(const Tableau & nv_tab,int num_mail,Tableau & 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 & 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 & nv_tab,int num_mail) +void LesReferences::Mise_a_jour_ref_noeud(const Tableau & 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 & 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 & nv_tab,int num_mail,Tableau & non_referencer) +void LesReferences::Mise_a_jour_ref_element(const Tableau & nv_tab,int num_mail,Tableau & 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())) diff --git a/References/LesReferences.h b/References/LesReferences.h index 3465273..248ae59 100644 --- a/References/LesReferences.h +++ b/References/LesReferences.h @@ -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 & nv_tab,int num_mail,Tableau & non_referencer); + void Mise_a_jour_ref_noeud(const Tableau & nv_tab,int num_mail,Tableau & 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 & nv_tab,int num_mail); + void Mise_a_jour_ref_noeud(const Tableau & 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 & nv_tab,int num_mail,Tableau & non_referencer); + void Mise_a_jour_ref_element(const Tableau & nv_tab,int num_mail,Tableau & 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) diff --git a/contact/ElContact.cc b/contact/ElContact.cc index 3b7d340..568eb52 100644 --- a/contact/ElContact.cc +++ b/contact/ElContact.cc @@ -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é diff --git a/contact/LesContacts.cc b/contact/LesContacts.cc index 0b71f31..780697d 100644 --- a/contact/LesContacts.cc +++ b/contact/LesContacts.cc @@ -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 "<rank() == 0) + if (num_proc == 0) #endif if (niveau_commentaire_lescontacts >2 ) cout << "\n mail. maitre "<::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 "<rank() == 0) + if (num_proc == 0) #endif if (!zone_definie) { cout << "\n *** erreur dans la construction de la zone de contact "<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 & taa = *ta; // pour simplifier int ta_taille = ta->Taille(); -// Tableau inter(ta_taille);// un tableau inter de travail + LaLIST_io newmitoyen;// les mitoyens qui sont locaux LaLIST_io 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 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 & list_fronta = (t_listFront(i)(j)); // pour simplifier -// LaLIST_io ::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 * ta = fronta.TabMitoyen(); // récup des mitoyens -// if (ta != NULL) // cas où il y a des éléments voisins ! -// { const Tableau & 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 & list_fronta = (t_listFront(i)(j)); // pour simplifier + LaLIST ::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 * ta = fronta.TabMitoyen(); // récup des mitoyens + if (ta != NULL) // cas où il y a des éléments voisins ! + { const Tableau & taa = *ta; // pour simplifier + int ta_taille = ta->Taille(); + LaLIST_io 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 & list_fronta = (t_listFront(i)(j)); // pour simplifier + LaLIST_io ::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 * ta = fronta.TabMitoyen(); // récup des mitoyens + if (ta != NULL) // cas où il y a des éléments voisins ! + { const Tableau & 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 <<", "<isend(0, 61, inter_entiers); // on attend pas @@ -1240,36 +1298,50 @@ bool LesContacts::DefElemCont(double dep_max) {// l'objectif ici est de récupérer les infos tempsContact.Arret_du_comptage(); // fin cpu int nb_contact=0;int nb_new_contact = 0;int nb_efface_contact = 0; // que l'on va cumuler + int nb_actif=0; int nb_proc_terminer = 0; // permettra de terminer while (nb_proc_terminer < (ParaGlob::Monde()->size()-1)) { // on récupère un résultat de cpu i temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu - QuatreEntiers inter_entiers; + + CinqEntiers inter_entiers; mpi::request reqs1 = ParaGlob::Monde()->irecv(mpi::any_source, 61, inter_entiers ); reqs1.wait(); // on attend que le conteneur soit rempli // on cumule nb_contact += inter_entiers.deux; nb_new_contact += inter_entiers.trois; nb_efface_contact += inter_entiers.quatre; + nb_actif += inter_entiers.cinq; if (inter_entiers.un) // si un seul des retour s est bon on passe à true retour = true; nb_proc_terminer++; // on prend en compte que l'on a récupéré un conteneur }; - if (niveau_commentaire_lescontacts > 2) // ==> LesContacts:: + if (niveau_commentaire_lescontacts > 2) // ==> LesContacts:: {cout << "\n apres Def Elem Cont: "<< nb_contact << " elem contact "; if ( nb_new_contact) cout <<", "<< nb_new_contact << " nouveau(x) "; if (nb_efface_contact) cout <<", "<>>> 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 <<", "< & list_fronta = (t_listFront(i)(j)); // pour simplifier + LaLIST_io ::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 * ta = fronta.TabMitoyen(); // récup des mitoyens + if (ta != NULL) // cas où il y a des éléments voisins ! + { const Tableau & 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 ::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 * ta = elfront->TabMitoyen(); + if (ta != NULL) // cas où il y a des éléments voisins ! + { const Tableau & 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 & list_fronta = (t_listFront(i)(j)); // pour simplifier + LaLIST_io ::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 * ta = fronta.TabMitoyen(); // récup des mitoyens + if (ta != NULL) // cas où il y a des éléments voisins ! + { const Tableau & taa = *ta; // pour simplifier + int ta_taille = ta->Taille(); + for (int i=1; i <= ta_taille; i++) + {if (taa(i)->NumUnique() == 0) + cout << "\n debug : LesContacts::Actualisation " + << " ***** erreur dans les mitoyens : numunique == 0 !!" ; + }; + }; + }; + }; + }; + } +#endif + //-- fin debug #endif // retour @@ -2824,13 +2997,26 @@ void LesContacts::CalculReaction(Vecteur& residu,bool& decol,const Nb_assemb& ca if (niveau_commentaire_lescontacts > 5) {if ((contact_type==1)||(contact_type==3)) - {cout << "\n LesContacts::CalculReaction >> Details: residu totale = contact + CL + F_int (noeud:" << noe->Num_noeud() - << " maillage:"<< noe->Num_Mail() << ")\nR=" << force << " gapTDT= " << (*iE).Gaptdt() - << "\n dont F_contact= "<< (*iE).Force_contact() ; + { + #ifdef UTILISATION_MPI + cout << "\n proc " << proc_en_cours<<": " + #else + cout << "\n" + #endif + + << " LesContacts::CalculReaction >> Details: residu totale = contact + CL + F_int (noeud:" << noe->Num_noeud() + << " maillage:"<< noe->Num_Mail() << ")\nR=" << force << " gapTDT= " << (*iE).Gaptdt() + << "\n dont F_contact= "<< (*iE).Force_contact() ; cout << "\n noeud: coor_tdt: "<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() ; diff --git a/contact/LesContacts_2.cc b/contact/LesContacts_2.cc index 4929ada..230c8d8 100755 --- a/contact/LesContacts_2.cc +++ b/contact/LesContacts_2.cc @@ -44,9 +44,9 @@ // idem au niveau de l'élément template void LesContacts::Lec_base_info_LesContacts(istream& ent - ,T& instance // l'instance qui permet d'appeler les pointeurs de fonctions - ,Noeud& (T::*RecupNoeud)(int i, int j) const - ,Element& (T::*RecupElement_LesMaille)(int i, int j) const) + ,T& instance // l'instance qui permet d'appeler les pointeurs de fonctions + ,Noeud& (T::*RecupNoeud)(int i, int j) const + ,Element& (T::*RecupElement_LesMaille)(int i, int j) const) { bool mono_proc_on_lit_un_BI_multiProc = false; int taille=0; // taille par défaut @@ -120,7 +120,7 @@ void LesContacts::Lec_base_info_LesContacts(istream& ent listContact.erase(iiE); // efface l'element }; }; - Tableau compteur_inesc(nb_mail_Esclave,1); // compteur de compteur de noeuds esclaves + Tableau compteur_inesc(nb_mail_Esclave,1); // compteur de compteur de noeuds esclaves // on initialise la liste des éléments en contact // listContact.clear(); // comme on redémarre, on efface la situation actuelle @@ -163,7 +163,7 @@ void LesContacts::Lec_base_info_LesContacts(istream& ent // le nombre de maillages esclave et en auto-contact, peut-être redéfinit lors d'un restart // donc n'est pas sauvegardé if (numMail_esclave <= nb_mail_Esclave) - { Noeud& no = (instance.*RecupNoeud)(numMail_esclave, numNoeud_esclave); // "" + { Noeud& no = (instance.*RecupNoeud)(numMail_esclave, numNoeud_esclave); // "" // --- création de la frontière Element& elem = (instance.*RecupElement_LesMaille)(numMail_element,num_element); ElFrontiere* elfr; @@ -270,6 +270,19 @@ void LesContacts::Lec_base_info_LesContacts(istream& ent // dans le cas // on ne continue que si l'élément de contact est relatif à un élément associé au cpu if ((ParaGlob::param->Element_concerner(numMail_element,num_element ))) #endif + {// on s'occupe d'abord de la frontière initiale + if (trouver_0) + {// on met à jour les mitoyens pour froont_0 + // definition des elements mitoyens à partir du front enregistré qui lui contient les mitoyens + // qui ont été créé à l'initialisation + if (froant_0->TabMitoyen() != NULL) + courant.Elfront_initiale()->DefMitoyen(*(froant_0->TabMitoyen())); + #ifdef UTILISATION_MPI + // on attribue au front de l'élément de contact, le numéro unique utilisable pour le tableau pointe_t_listFront + courant.Elfront_initiale()->ChangeNumUnique(froant_0->NumUnique()); + #endif + }; + // puis la frontière courante if (trouver) {// on met à jour les mitoyens // definition des elements mitoyens à partir du front enregistré qui lui contient les mitoyens @@ -306,7 +319,8 @@ void LesContacts::Lec_base_info_LesContacts(istream& ent tesN_encontact(numMail_esclave)[(*ipp).Esclave()].push_front(listContact.begin()); }; }; - } // fin de l'ajout d'un élément de contact + }; + } // fin de l'ajout d'un élément de contact else {if (ParaGlob::NiveauImpression() > 0) cout << "\n *** attention, le maillage "< 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 diff --git a/tenseurs_mai99/Coordonnees/Coordonnee.cc b/tenseurs_mai99/Coordonnees/Coordonnee.cc index f206172..e05ad62 100644 --- a/tenseurs_mai99/Coordonnees/Coordonnee.cc +++ b/tenseurs_mai99/Coordonnees/Coordonnee.cc @@ -47,13 +47,13 @@ using namespace std; //introduces namespace std #ifndef COORDONNEE_H_deja_inclus // Constructeur par defaut -// avant ->// N.B. : la dimension est affectee a 3 et les valeurs a 0 +// avant ->// N.B. : la dimension est affectee a 3 et les valeurs a 0 #ifndef MISE_AU_POINT inline #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,22 +62,22 @@ Coordonnee::Coordonnee () : #endif Coordonnee::Coordonnee (int dimension) : dim ((short)dimension), memoire(true),coord (NULL) -{ if (dim == 0) return; - #ifdef MISE_AU_POINT - if ( (dimension<0) || (dimension>3) ) - { - cout << "\nErreur de dimension !\n"; - cout << "COORDONNEE::COORDONNEE (int ) \n"; - Sortie(1); - }; + { if (dim == 0) return; + #ifdef MISE_AU_POINT + if ( (dimension<0) || (dimension>3) ) + {cout << "\nErreur de dimension !\n"; + cout << "\n la dimension demandée est "< aucune action #ifndef MISE_AU_POINT inline #endif Coordonnee::~Coordonnee () -{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 - } -}; + { if (memoire) + { if (dim > 0) + { delete [] coord; + coord=NULL; + dim=0; + } + }; + }; -// 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; } - else { Change_dim(dimension); coord[0] = x; }; -}; +void Coordonnee::Change_Coordonnee(int dimension, double x) // dimension 1 + { 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); - coord[0] = x; coord[1] = y; -}; - -// changement des coordonnees -#ifndef MISE_AU_POINT - inline -#endif -void Coordonnee::Change_Coordonnee(int dimension, double x,double y,double z) // dimension 3 +void Coordonnee::Change_Coordonnee(int dimension, double x,double y) // dimension 2 + { 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 + inline +#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; }; @@ -223,156 +219,181 @@ void Coordonnee::Change_Coordonnee(int dimension, double x,double y,double z) inline #endif int Coordonnee::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 Coordonnee::Libere () -{if (memoire) - { if (dim > 0) - { delete [] coord; - coord=NULL; - dim=0; - } - }; - 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 "< 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 inline #endif double& Coordonnee::operator() (int i) - { - #ifdef MISE_AU_POINT - if ( (i<1) || (i>dim) ) - { cout << "\nErreur de dimension !\n"; - cout << "COORDONNEE::OPERATOR() (int ) \n"; - Sortie(1); - }; - #endif - return coord[i-1]; - }; - + { + #ifdef MISE_AU_POINT + if ( (i<1) || (i>dim) ) + {cout << "\nErreur de dimension !\n"; + cout <<"\n on demande la coordonnee i="<dim) ) - { cout << "\nErreur de dimension !\n"; - cout << "COORDONNEE::OPERATOR() (int ) \n"; - Sortie(1); - }; - #endif - return coord[i-1]; - }; + { + #ifdef MISE_AU_POINT + if ( (i<1) || (i>dim) ) + {cout << "\nErreur de dimension !\n"; + cout <<"\n on demande la coordonnee i="<3)) { cout << "\n erreur, la nouvelle dimension doit etre comprise entre 0 et 3 ! "; cout << "\n dim voulue = " << dimen ; cout << "\nCoordonnee::Change_dim(int dim) " << endl; Sortie(1); - } + } #endif - double * sauve = coord; - if (dimen == 0) - { // comme on a déjà passé le cas où dimen == dim, cela veut dire que dim est non nulle - 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 - // 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 - { coord = new double [dimen]; dim = dimen; - switch (dim) - {case 3: coord[2]=0.0; - case 2: coord[1]=0.0; - case 1: coord[0]=0.0; - }; - } - else // cas où dim est différent de 0 - {switch (dimen - dim) - {case 2: // là obligatoirement: dimen=3 et dim = 1 - { coord = new double [dimen]; dim = (short)dimen; - coord[2]=0.;coord[1]=0.;coord[0]=sauve[0]; - delete [] sauve; - break; - } - case 1: // dim ne peut avoir comme dimension que 2 ou 1 - { coord = new double [dimen]; - switch (dim) - {case 2: // dimen = 3 - { coord[2]=0.;coord[1]=sauve[1];coord[0]=sauve[0]; - break; - } - case 1: // dimen = 2 - { coord[1]=0.;coord[0]=sauve[0]; - break; - } - }; - dim = (short)dimen; - delete [] sauve; - } - }; - } - } - else if (dim > dimen) // nouvelle dimension non nulle, plus petite - { coord = new double [dimen]; - switch (dimen) - {case 3: coord[2]=sauve[2]; - case 2: coord[1]=sauve[1]; - case 1: coord[0]=sauve[0]; - }; - if (dim > 0) delete [] sauve; - dim = (short) dimen; + double * sauve = coord; + if (dimen == 0) + { // comme on a déjà passé le cas où dimen == dim, cela veut dire que dim est non nulle + Libere(); } + else if (dim < dimen) // cas où la nouvelle dimension est supérieur + { // 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 + { coord = new double [dimen]; dim = dimen; + switch (dim) + {case 3: coord[2]=0.0; + case 2: coord[1]=0.0; + case 1: coord[0]=0.0; + }; + } + else // cas où dim est différent de 0 + {switch (dimen - dim) + {case 2: // là obligatoirement: dimen=3 et dim = 1 + { coord = new double [dimen]; dim = (short)dimen; + coord[2]=0.;coord[1]=0.;coord[0]=sauve[0]; + delete [] sauve; + break; + } + case 1: // dim ne peut avoir comme dimension que 2 ou 1 + { coord = new double [dimen]; + switch (dim) + {case 2: // dimen = 3 + { coord[2]=0.;coord[1]=sauve[1];coord[0]=sauve[0]; + break; + } + case 1: // dimen = 2 + { coord[1]=0.;coord[0]=sauve[0]; + break; + } + }; + dim = (short)dimen; + delete [] sauve; + } + }; + } + } + else if (dim > dimen) // nouvelle dimension non nulle, plus petite + { coord = new double [dimen]; + switch (dimen) + {case 3: coord[2]=sauve[2]; + case 2: coord[1]=sauve[1]; + case 1: coord[0]=sauve[0]; + }; + 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: "< erreur #ifndef MISE_AU_POINT inline #endif Coordonnee& Coordonnee::operator= (const Coordonnee& c) -{ if (dim==c.dim) - { switch (dim) - {case 3: coord[2]=c.coord[2]; - case 2: coord[1]=c.coord[1]; - case 1: coord[0]=c.coord[0]; - // case 0: on ne fait rien - }; - return (*this); - } - else if ( c.dim==0 ) - { Libere();} - else - { if (!memoire) +{ if (dim==c.dim) + { switch (dim) + {case 3: coord[2]=c.coord[2]; + case 2: coord[1]=c.coord[1]; + case 1: coord[0]=c.coord[0]; + // case 0: on ne fait rien + }; + return (*this); + } + else if (( c.dim==0 )&&(memoire)) + { Libere();} + else + { 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 = " << c.dim << " ancienne dimension: " << dim ; @@ -380,12 +401,12 @@ Coordonnee& Coordonnee::operator= (const Coordonnee& c) Sortie(1); }; - #ifdef MISE_AU_POINT + #ifdef MISE_AU_POINT if (dim != 0) cout << "\n attention, on change la dimension du point !!!" << " de "<> ( istream & ent, Coordonnee & coo) return ent; }; // lecture de la dimension - int dim; + int dim; ent >> nomtype >> dim; - // on redimensionne éventuellement la taille + // on redimensionne éventuellement la taille if (coo.dim != dim) { if (coo.memoire) // cas ou c'est un vrai point { if (coo.coord != NULL) { delete [] coo.coord;} @@ -755,18 +783,18 @@ istream & operator >> ( istream & ent, Coordonnee & 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, Coordonnee & coo) " << endl ; Sortie(2); }; - }; + }; // les data switch (coo.dim) { case 3 : {ent >> coo.coord[0] >> coo.coord[1] >> coo.coord[2] ; break;} case 2 : {ent >> coo.coord[0] >> coo.coord[1] ; break;} case 1 : {ent >> coo.coord[0] ; break;} - case 0 : break; // on ne fait rien + case 0 : break; // on ne fait rien }; return ent; }; @@ -786,7 +814,7 @@ ostream & operator << ( ostream & sort,const Coordonnee & coo) case 2 : {sort << setprecision(ParaGlob::NbdigdoCA()) << coo.coord[0] << " " << setprecision(ParaGlob::NbdigdoCA()) << coo.coord[1] << " "; break;} case 1 : {sort << setprecision(ParaGlob::NbdigdoCA()) << coo.coord[0] << " "; break;} - case 0 : break; // on ne fait rien + case 0 : break; // on ne fait rien }; return sort; }; @@ -797,17 +825,17 @@ ostream & operator << ( ostream & sort,const Coordonnee & coo) inline #endif double Coordonnee::Norme () const -{ double norme=0.0; - switch (dim) - {case 3: norme+=coord[2] * coord[2]; - case 2: norme+=coord[1] * coord[1]; - case 1: norme+=coord[0] * coord[0]; - case 0: ; - }; - return sqrt(norme); -// norme=sqrt((double)norme); // calcul de la norme -// return norme; -}; + { double norme=0.0; + switch (dim) + {case 3: norme+=coord[2] * coord[2]; + case 2: norme+=coord[1] * coord[1]; + case 1: norme+=coord[0] * coord[0]; + case 0: ; + }; + return sqrt(norme); + // norme=sqrt((double)norme); // calcul de la norme + // return norme; + }; // norme le vecteur coordonnée #ifndef MISE_AU_POINT @@ -815,7 +843,7 @@ double Coordonnee::Norme () const #endif Coordonnee& Coordonnee::Normer () { double norme = this->Norme(); - #ifdef MISE_AU_POINT + #ifdef MISE_AU_POINT if(Dabs(norme) <= ConstMath::trespetit) { cout << "\n erreur, division par zero "; cout << "\nCoordonnee3::Normer () " << endl; @@ -831,15 +859,15 @@ Coordonnee& Coordonnee::Normer () #endif // Retourne le maximum en valeur absolue des composantes double Coordonnee::Max_val_abs () const -{ double maxi=0.; - switch (dim) - { case 3: maxi=DabsMaX(maxi,coord[2]); - case 2: maxi=DabsMaX(maxi,coord[1]); - case 1: maxi=DabsMaX(maxi,coord[0]); - case 0: break; - }; - return maxi; -}; + { double maxi=0.; + switch (dim) + { case 3: maxi=DabsMaX(maxi,coord[2]); + case 2: maxi=DabsMaX(maxi,coord[1]); + case 1: maxi=DabsMaX(maxi,coord[0]); + case 0: break; + }; + return maxi; + }; #ifndef MISE_AU_POINT @@ -847,14 +875,14 @@ double Coordonnee::Max_val_abs () const #endif // ramène l'indice du maxi en valeur absolu int Coordonnee::Indice_max_val_abs() const -{ double maxi=Dabs(coord[dim-1 ]);int indice=dim; +{ double maxi=Dabs(coord[dim-1 ]);int indice=dim; switch (dim) - { case 3: if (maxi < Dabs(coord[2])) {maxi = Dabs(coord[2]),indice = 3;} - case 2: if (maxi < Dabs(coord[1])) {maxi = Dabs(coord[1]),indice = 2;} - case 1: if (maxi < Dabs(coord[0])) {maxi = Dabs(coord[0]),indice = 1;} - case 0: break; - }; - return maxi; + { case 3: if (maxi < Dabs(coord[2])) {maxi = Dabs(coord[2]),indice = 3;} + case 2: if (maxi < Dabs(coord[1])) {maxi = Dabs(coord[1]),indice = 2;} + case 1: if (maxi < Dabs(coord[0])) {maxi = Dabs(coord[0]),indice = 1;} + case 0: break; + }; + return indice; }; @@ -863,15 +891,15 @@ int Coordonnee::Indice_max_val_abs() const #endif // Retourne le maximum en valeur absolue des composantes et l'indice correspondant double Coordonnee::Max_val_abs (int& in) const -{ double maxi=0.; - in = 0; +{ double maxi=0.; + in = 0; switch (dim) - { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} - case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} - case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} - case 0: break; - }; - return maxi; + { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} + case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} + case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} + case 0: break; + }; + return maxi; }; #ifndef MISE_AU_POINT @@ -880,17 +908,17 @@ 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.; - int in = 0; - switch (dim) - { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} - case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} - case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} - case 0: break; - }; - if (in != 0) {return coord[in-1];} - else {return maxi;}; -}; + { double maxi=0.; + int in = 0; + switch (dim) + { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} + case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} + case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} + case 0: break; + }; + if (in != 0) {return coord[in-1];} + else {return maxi;}; + }; #ifndef MISE_AU_POINT inline @@ -898,17 +926,17 @@ 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.; - in = 0; - switch (dim) - { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} - case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} - case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} - case 0: break; - }; - if (in != 0) {return coord[in-1];} - else {return maxi;}; -}; + { double maxi=0.; + in = 0; + switch (dim) + { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} + case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} + case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} + case 0: break; + }; + if (in != 0) {return coord[in-1];} + else {return maxi;}; + }; #ifndef MISE_AU_POINT @@ -917,21 +945,21 @@ double Coordonnee::Max_val_abs_signe (int& in) const // modifie éventuellement les coordonnées de this pour quelles soient supérieures ou égales // aux coordonnées en paramètre void Coordonnee::Modif_en_max(const Coordonnee& v) - { - #ifdef MISE_AU_POINT - if ( dim!=v.dim ) - { cout << "\nErreur : dimensions non egales !\n"; - cout << " Coordonnee::Modif_en_max(const Coordonnee& v) \n"; - Sortie(1); - }; - #endif - switch (dim) - { case 3: if (coord[2] < v.coord[2]) coord[2]=v.coord[2]; - case 2: if (coord[1] < v.coord[1]) coord[1]=v.coord[1]; - case 1: if (coord[0] < v.coord[0]) coord[0]=v.coord[0]; - case 0: break; - }; - }; + { + #ifdef MISE_AU_POINT + if ( dim!=v.dim ) + { cout << "\nErreur : dimensions non egales !\n"; + cout << " Coordonnee::Modif_en_max(const Coordonnee& v) \n"; + Sortie(1); + }; + #endif + switch (dim) + { case 3: if (coord[2] < v.coord[2]) coord[2]=v.coord[2]; + case 2: if (coord[1] < v.coord[1]) coord[1]=v.coord[1]; + case 1: if (coord[0] < v.coord[0]) coord[0]=v.coord[0]; + case 0: break; + }; + }; #ifndef MISE_AU_POINT inline @@ -939,34 +967,34 @@ void Coordonnee::Modif_en_max(const Coordonnee& v) // modifie éventuellement les coordonnées de this pour quelles soient inférieures ou égales // aux coordonnées en paramètre void Coordonnee::Modif_en_min(const Coordonnee& v) - { - #ifdef MISE_AU_POINT - if ( dim!=v.dim ) - { cout << "\nErreur : dimensions non egales !\n"; - cout << " Coordonnee::Modif_en_min(const Coordonnee& v) \n"; - Sortie(1); - }; - #endif - switch (dim) - { case 3: if (coord[2] > v.coord[2]) coord[2]=v.coord[2]; - case 2: if (coord[1] > v.coord[1]) coord[1]=v.coord[1]; - case 1: if (coord[0] > v.coord[0]) coord[0]=v.coord[0]; - case 0: break; - }; - }; + { + #ifdef MISE_AU_POINT + if ( dim!=v.dim ) + { cout << "\nErreur : dimensions non egales !\n"; + cout << " Coordonnee::Modif_en_min(const Coordonnee& v) \n"; + Sortie(1); + }; + #endif + switch (dim) + { case 3: if (coord[2] > v.coord[2]) coord[2]=v.coord[2]; + case 2: if (coord[1] > v.coord[1]) coord[1]=v.coord[1]; + case 1: if (coord[0] > v.coord[0]) coord[0]=v.coord[0]; + case 0: break; + }; + }; #ifndef MISE_AU_POINT inline #endif // ajoute une même valeur à tous les coordonnées void Coordonnee::Ajout_meme_valeur(double val) -{ switch (dim) - {case 3: coord[2] += val; - case 2: coord[1] += val; - case 1: coord[0] += val; - case 0: ; - }; - }; + { switch (dim) + {case 3: coord[2] += val; + case 2: coord[1] += val; + case 1: coord[0] += val; + case 0: ; + }; + }; #ifndef MISE_AU_POINT inline @@ -974,43 +1002,43 @@ void Coordonnee::Ajout_meme_valeur(double val) // sortie du schemaXML: en fonction de enu void Coordonnee::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) { - switch (enu) - { case XML_TYPE_GLOBAUX : - {sort << "\n " - << "\n" - << "\n " - << "\n coordonnee de dimension 1 ou 2 ou 3: elements: " - << "\n un entier (dim) donnant la dimension, et dim reels " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n"; - break; - } - case XML_IO_POINT_INFO : - { - break; - } - case XML_IO_POINT_BI : - { - break; - } - case XML_IO_ELEMENT_FINI : - { - break; - } + switch (enu) + { case XML_TYPE_GLOBAUX : + {sort << "\n " + << "\n" + << "\n " + << "\n coordonnee de dimension 1 ou 2 ou 3: elements: " + << "\n un entier (dim) donnant la dimension, et dim reels " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n"; + break; + } + case XML_IO_POINT_INFO : + { + break; + } + case XML_IO_POINT_BI : + { + break; + } + case XML_IO_ELEMENT_FINI : + { + break; + } default: sort << "\n SchemaXML: cas non pris en compte " ; - }; + }; }; // définit des coordonnées sans variance à la même place que des coordonnées avec variances @@ -1021,14 +1049,15 @@ 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;} - }; + { memoire = false; coord = vB.coord;} + }; }; }; @@ -1041,14 +1070,15 @@ 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 + { 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;} + }; }; }; diff --git a/tenseurs_mai99/Coordonnees/Coordonnee.h b/tenseurs_mai99/Coordonnees/Coordonnee.h index db7f89c..0200d9a 100644 --- a/tenseurs_mai99/Coordonnees/Coordonnee.h +++ b/tenseurs_mai99/Coordonnees/Coordonnee.h @@ -132,8 +132,10 @@ class Coordonnee // constructeur fonction d'une adresse memoire ou sont stockee les coordonnees // et d'une dimension ( l'existance de la place mémoire est a la charge // de l'utilisateur et ne sera pas détruite par le destructeur.) + // de même il n'y aura pas de redimentionnement possible */ Coordonnee (int dimension,double* t); + // Constructeur fonction d'un vecteur qui doit avoir une dim = 1 ou 2 ou 3 // on supprime car il y a plein de conversion n'ont explicite, le mieux est d'utiliser // l'opérateur Vect(), qui permet "explicitement" de créer un coordonnée et ensuite d'utiliser @@ -145,19 +147,21 @@ class Coordonnee //// Construit(const Vecteur& vec); /// Constructeur de copie + // mais là on construit systématiquement un vrai coordonnée + // même si c.memoire est faux, car on ne veut pas que plusieur + // coordonnée pointes sur les mêmes valeurs, sans précautions supplémentaires Coordonnee (const Coordonnee& c); /// DESTRUCTEUR : + // dans le cas où la mémoire n'est pas gérée localement -> aucune action virtual ~Coordonnee (); // METHODES : - /*! \brief - // fonction équivalente au constructeur: changement pour une place externe via un pointeur - // ( l'existance de la place mémoire est a la charge - // de l'utilisateur et ne sera pas détruite par le destructeur.) - */ - void Change_place(int dimension,double* t); +// // fonction équivalente au constructeur: changement pour une place externe via un pointeur +// // ( l'existance de la place mémoire est a la charge +// // de l'utilisateur et ne sera pas détruite par le destructeur.) +// void Change_place(int dimension,double* t); // changement des coordonnees // rapide si c'est la même dimension !! @@ -170,7 +174,10 @@ class Coordonnee /// Renvoie le nombre de coordonnees virtual int Dimension () const ; + /// Desallocation de la place memoire allouee + /// uniquement dans le cas où la mémoire est gérée localement + /// sinon aucune action virtual void Libere (); /// Renvoie la ieme coordonnee virtual double& operator() (int i); @@ -194,7 +201,7 @@ class Coordonnee /// Surcharge de l'operateur -= void operator-= (const Coordonnee& c); /// Surcharge de l'operateur *= - void operator*= (double val); + virtual void operator*= (double val); /// Surcharge de l'operateur * : multiplication de coordonnees par un scalaire Coordonnee operator* (double val) const; /// Surcharge de l'operateur * : produit scalaire entre coordonnees @@ -234,6 +241,7 @@ class Coordonnee // changement de la dimension // dans le cas d'une nouvelle dimension inferieur on supprime les dernieres coord // dans le cas d'une dimension superieur, on ajoute des coord initialisees a zero + // NB: possible uniquement si la mémoire est gérée localement */ virtual void Change_dim(int dim); /// création d'un Vecteur équivalent @@ -366,6 +374,7 @@ class CoordonneeH CoordonneeH (const CoordonneeH& c); /// DESTRUCTEUR : + // dans le cas où la mémoire n'est pas gérée localement -> aucune action virtual ~CoordonneeH (); // METHODES : @@ -380,7 +389,10 @@ class CoordonneeH /// Renvoie le nombre de coordonnees virtual int Dimension () const ; - /// Desallocation de la place memoire allouee + + /// Desallocation de la place memoire allouee + /// uniquement dans le cas où la mémoire est gérée localement + /// sinon aucune action virtual void Libere (); /// Renvoie la ieme coordonnee virtual double& operator() (int i); @@ -441,6 +453,7 @@ class CoordonneeH // changement de la dimension // dans le cas d'une nouvelle dimension inferieur on supprime les dernieres coord // dans le cas d'une dimension superieur, on ajoute des coord initialisees a zero + // NB: possible uniquement si la mémoire est gérée localement */ virtual void Change_dim(int dim); /// création d'un Vecteur équivalent @@ -559,6 +572,7 @@ class CoordonneeB CoordonneeB (const CoordonneeB& c); /// DESTRUCTEUR : + // dans le cas où la mémoire n'est pas gérée localement -> aucune action virtual ~CoordonneeB (); // METHODES : @@ -574,7 +588,10 @@ class CoordonneeB /// Renvoie le nombre de coordonnees virtual int Dimension () const ; - /// Desallocation de la place memoire allouee + + /// Desallocation de la place memoire allouee + /// uniquement dans le cas où la mémoire est gérée localement + /// sinon aucune action virtual void Libere (); /// Renvoie la ieme coordonnee virtual double& operator() (int i); @@ -637,6 +654,7 @@ class CoordonneeB // changement de la dimension // dans le cas d'une nouvelle dimension inferieur on supprime les dernieres coord // dans le cas d'une dimension superieur, on ajoute des coord initialisees a zero + // NB: possible uniquement si la mémoire est gérée localement */ virtual void Change_dim(int dim); /// conversion en Vecteur @@ -696,7 +714,7 @@ class CoordonneeB protected : short int dim; - bool memoire; // indique s'il y a allocation ou pas + bool memoire; // indique s'il y a allocation ou pas double* coord; // Constructeur inline qui ne fait rien CoordonneeB (bool ):dim (-1) , coord (NULL),memoire(true) {}; diff --git a/tenseurs_mai99/Coordonnees/Coordonnee1.cc b/tenseurs_mai99/Coordonnees/Coordonnee1.cc index fb1b7c3..daea1ac 100644 --- a/tenseurs_mai99/Coordonnees/Coordonnee1.cc +++ b/tenseurs_mai99/Coordonnees/Coordonnee1.cc @@ -51,8 +51,8 @@ using namespace std; //introduces namespace std #endif Coordonnee1::Coordonnee1 () : Coordonnee(1,coord1) -{ coord1[0] = 0.; -}; + { coord1[0] = 0.; + }; // Constructeur suivant un booleen // quelque soit la valeur du booleen il n'y a pas initialisation des coordonnées @@ -69,8 +69,8 @@ Coordonnee1::Coordonnee1 (bool ): #endif Coordonnee1::Coordonnee1 (double x): Coordonnee(1,coord1) -// Constructeur pour un point a deux dimensions -{ coord1[0]=x; +// Constructeur pour un point a une dimension +{ coord1[0]=x; }; // constructeur fonction d'une adresse memoire ou sont stockee les coordonnees @@ -82,7 +82,7 @@ Coordonnee1::Coordonnee1 (double x): Coordonnee1::Coordonnee1 (double* t): Coordonnee(1,coord1) { coord1[0]=t[0]; - }; + }; // Constructeur de copie #ifndef MISE_AU_POINT @@ -99,13 +99,13 @@ Coordonnee1::Coordonnee1 (const Coordonnee1& c): #endif Coordonnee1::Coordonnee1 (const Coordonnee& c): Coordonnee(1,coord1) -{ +{ #ifdef MISE_AU_POINT - if (c.Dimension () != 1) - { cout << "\nErreur la dimension de c est différente de 1 !! !\n"; - cout << "Coordonnee1::Coordonnee1 (const Coordonnee& c) \n"; - Sortie(1); - } + if (c.Dimension () != 1) + { cout << "\nErreur la dimension de c " << c.Dimension() << " est différente de 1 !! !\n"; + cout << "Coordonnee1::Coordonnee1 (const Coordonnee& c) \n"; + Sortie(1); + } #endif coord1[0]=c(1); }; @@ -116,24 +116,27 @@ Coordonnee1::Coordonnee1 (const Coordonnee& c): #endif Coordonnee1::~Coordonnee1 () { dim = 0; // pour l'appel de ~Coordonnee() - #ifdef MISE_AU_POINT - coord=NULL; - #endif + #ifdef MISE_AU_POINT + // memoire étant false on met coord à 0 + // ceci étant, l'objet étant détruit, coord ne sert pas ensuite + // donc ce n'est pas utile dans une version rapide + coord=NULL; + #endif }; -// Desallocation de la place memoire allouee -// fonction définie dans la classe mère générique mais qui n'a pas de -// sens ici -#ifndef MISE_AU_POINT - inline -#endif -void Coordonnee1::Libere () - { - #ifdef MISE_AU_POINT - cout << "\nErreur cette fonction n'a pas cours !! !\n"; - cout << "Coordonnee1::Libere () \n"; - Sortie(1); - #endif - }; +//// Desallocation de la place memoire allouee +//// fonction définie dans la classe mère générique mais qui n'a pas de +//// sens ici +//#ifndef MISE_AU_POINT +// inline +//#endif +//void Coordonnee1::Libere () +// { +// #ifdef MISE_AU_POINT +// cout << "\nErreur cette fonction n'a pas cours !! !\n"; +// cout << "Coordonnee1::Libere () \n"; +// Sortie(1); +// #endif +// }; // Renvoie le nombre de coordonnees @@ -143,90 +146,90 @@ void Coordonnee1::Libere () int Coordonnee1::Dimension () const { return 1; }; -// changement de la dimension -// fonction définie dans la classe mère générique mais qui n'a pas de -// sens ici -#ifndef MISE_AU_POINT - inline -#endif -void Coordonnee1::Change_dim(int ) - { - #ifdef MISE_AU_POINT - cout << "\nErreur cette fonction n'a pas cours !! !\n"; - cout << "Coordonnee1::Change_dim(int dimen) \n"; - Sortie(1); - #endif - }; +//// changement de la dimension +//// fonction définie dans la classe mère générique mais qui n'a pas de +//// sens ici +//#ifndef MISE_AU_POINT +// inline +//#endif +//void Coordonnee1::Change_dim(int ) +// { +// #ifdef MISE_AU_POINT +// cout << "\nErreur cette fonction n'a pas cours !! !\n"; +// cout << "Coordonnee1::Change_dim(int dimen) \n"; +// Sortie(1); +// #endif +// }; // Surcharge de l'operateur = : realise l'affectation entre deux points #ifndef MISE_AU_POINT inline #endif Coordonnee1& Coordonnee1::operator= (const Coordonnee1& c) - { coord1[0]=c.coord1[0]; - return (*this); + { coord1[0]=c.coord1[0]; + return (*this); }; - - + + // Surcharge de l'operateur - : renvoie l'oppose d'un point #ifndef MISE_AU_POINT inline #endif Coordonnee1 Coordonnee1::operator- () const - { return Coordonnee1(-coord1[0]); - }; - + { return Coordonnee1(-coord1[0]); + }; + // Surcharge de l'operateur - : realise la soustraction des // coordonnees de deux points #ifndef MISE_AU_POINT inline #endif Coordonnee1 Coordonnee1::operator- (const Coordonnee1& c) const - { return Coordonnee1(coord1[0]-c.coord1[0]); - }; - + { return Coordonnee1(coord1[0]-c.coord1[0]); + }; + // Surcharge de l'operateur + : realise l'addition des // coordonnees de deux points #ifndef MISE_AU_POINT inline #endif Coordonnee1 Coordonnee1::operator+ (const Coordonnee1& c) const - { return Coordonnee1(coord1[0]+c.coord1[0]); - }; - + { return Coordonnee1(coord1[0]+c.coord1[0]); + }; + // Surcharge de l'operateur += #ifndef MISE_AU_POINT inline #endif void Coordonnee1::operator+= (const Coordonnee1& c) - { coord1[0]+=c.coord1[0]; - }; + { coord1[0]+=c.coord1[0]; + }; // Surcharge de l'operateur -= #ifndef MISE_AU_POINT inline #endif void Coordonnee1::operator-= (const Coordonnee1& c) - { coord1[0]-=c.coord1[0]; - }; + { coord1[0]-=c.coord1[0]; + }; // Surcharge de l'operateur *= #ifndef MISE_AU_POINT inline #endif void Coordonnee1::operator*= (double val) - { coord1[0]*=val; - }; - + { coord1[0]*=val; + }; + // Surcharge de l'operateur * : multiplication de coordonnees par un scalaire #ifndef MISE_AU_POINT inline #endif Coordonnee1 Coordonnee1::operator* (double val) const - { - return Coordonnee1(val*coord1[0]); - }; - + { + return Coordonnee1(val*coord1[0]); + }; + // Surcharge de l'operateur * : produit scalaire entre coordonnees #ifndef MISE_AU_POINT inline @@ -251,7 +254,7 @@ Coordonnee1 Coordonnee1::operator/ (double val) const #endif return Coordonnee1(coord1[0] / val); }; - + // Surcharge de l'operateur /= : division de coordonnees par un scalaire #ifndef MISE_AU_POINT inline @@ -275,20 +278,20 @@ void Coordonnee1::operator/= (double val) inline #endif int Coordonnee1::operator== (const Coordonnee1& c) const - { if (c.coord1[0]!=coord1[0]) - return 0; - else - return 1; - }; + { if (c.coord1[0]!=coord1[0]) + return 0; + else + return 1; + }; // mise a zero des coordonnées #ifndef MISE_AU_POINT inline #endif void Coordonnee1::Zero() - { coord1[0] = 0.; - }; - + { coord1[0] = 0.; + }; + // Calcul de la norme euclidienne des composantes du point #ifndef MISE_AU_POINT inline @@ -312,7 +315,7 @@ Coordonnee1& Coordonnee1::Normer () *this /= norme; return *this ; }; - + // somme de tous les composantes #ifndef MISE_AU_POINT inline @@ -335,35 +338,35 @@ double Coordonnee1::Somme() const // sortie du schemaXML: en fonction de enu void Coordonnee1::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) { - switch (enu) - { case XML_TYPE_GLOBAUX : - {sort << "\n " - << "\n" - << "\n " - << "\n coordonnee de dimension 1: elements: " - << "\n 1 reel " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n"; - break; - } - case XML_IO_POINT_INFO : - { - break; - } - case XML_IO_POINT_BI : - { - break; - } - case XML_IO_ELEMENT_FINI : - { - break; - } + switch (enu) + { case XML_TYPE_GLOBAUX : + {sort << "\n " + << "\n" + << "\n " + << "\n coordonnee de dimension 1: elements: " + << "\n 1 reel " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n"; + break; + } + case XML_IO_POINT_INFO : + { + break; + } + case XML_IO_POINT_BI : + { + break; + } + case XML_IO_ELEMENT_FINI : + { + break; + } default: sort << "\n SchemaXML: cas non pris en compte " ; - }; + }; }; #endif diff --git a/tenseurs_mai99/Coordonnees/Coordonnee1.h b/tenseurs_mai99/Coordonnees/Coordonnee1.h index cbe5f0b..f6b218d 100644 --- a/tenseurs_mai99/Coordonnees/Coordonnee1.h +++ b/tenseurs_mai99/Coordonnees/Coordonnee1.h @@ -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); diff --git a/tenseurs_mai99/Coordonnees/Coordonnee1B.cc b/tenseurs_mai99/Coordonnees/Coordonnee1B.cc index f2e01a9..95bf1af 100644 --- a/tenseurs_mai99/Coordonnees/Coordonnee1B.cc +++ b/tenseurs_mai99/Coordonnees/Coordonnee1B.cc @@ -70,7 +70,7 @@ Coordonnee1B::Coordonnee1B (bool ): Coordonnee1B::Coordonnee1B (double x): CoordonneeB(1,coord1) // Constructeur pour un point a deux dimensions -{ coord1[0]=x; +{ coord1[0]=x; }; // constructeur fonction d'une adresse memoire ou sont stockee les coordonnees @@ -82,7 +82,7 @@ Coordonnee1B::Coordonnee1B (double x): Coordonnee1B::Coordonnee1B (double* t): CoordonneeB(1,coord1) { coord1[0]=t[0]; - }; + }; // Constructeur de copie #ifndef MISE_AU_POINT @@ -99,13 +99,13 @@ Coordonnee1B::Coordonnee1B (const Coordonnee1B& c): #endif Coordonnee1B::Coordonnee1B (const CoordonneeB& c): CoordonneeB(1,coord1) -{ +{ #ifdef MISE_AU_POINT - if (c.Dimension () != 1) - { cout << "\nErreur la dimension de c est différente de 1 !! !\n"; - cout << "Coordonnee1B::Coordonnee1B (const Coordonnee& c) \n"; - Sortie(1); - } + if (c.Dimension () != 1) + { cout << "\nErreur la dimension de c est différente de 1 !! !\n"; + cout << "Coordonnee1B::Coordonnee1B (const Coordonnee& c) \n"; + Sortie(1); + } #endif coord1[0]=c(1); }; @@ -120,20 +120,20 @@ Coordonnee1B::~Coordonnee1B () coord=NULL; #endif }; -// Desallocation de la place memoire allouee -// fonction définie dans la classe mère générique mais qui n'a pas de -// sens ici -#ifndef MISE_AU_POINT - inline -#endif -void Coordonnee1B::Libere () - { - #ifdef MISE_AU_POINT - cout << "\nErreur cette fonction n'a pas cours !! !\n"; - cout << "Coordonnee1B::Libere () \n"; - Sortie(1); - #endif - }; +//// Desallocation de la place memoire allouee +//// fonction définie dans la classe mère générique mais qui n'a pas de +//// sens ici +//#ifndef MISE_AU_POINT +// inline +//#endif +//void Coordonnee1B::Libere () +// { +// #ifdef MISE_AU_POINT +// cout << "\nErreur cette fonction n'a pas cours !! !\n"; +// cout << "Coordonnee1B::Libere () \n"; +// Sortie(1); +// #endif +// }; // Renvoie le nombre de coordonnees @@ -143,105 +143,105 @@ void Coordonnee1B::Libere () int Coordonnee1B::Dimension () const { return 1; }; -// changement de la dimension -// fonction définie dans la classe mère générique mais qui n'a pas de -// sens ici -#ifndef MISE_AU_POINT - inline -#endif -void Coordonnee1B::Change_dim(int ) - { - #ifdef MISE_AU_POINT - cout << "\nErreur cette fonction n'a pas cours !! !\n"; - cout << "Coordonnee1B::Change_dim(int dimen) \n"; - Sortie(1); - #endif - }; +//// changement de la dimension +//// fonction définie dans la classe mère générique mais qui n'a pas de +//// sens ici +//#ifndef MISE_AU_POINT +// inline +//#endif +//void Coordonnee1B::Change_dim(int ) +// { +// #ifdef MISE_AU_POINT +// cout << "\nErreur cette fonction n'a pas cours !! !\n"; +// cout << "Coordonnee1B::Change_dim(int dimen) \n"; +// Sortie(1); +// #endif +// }; // Surcharge de l'operateur = : realise l'affectation entre deux points #ifndef MISE_AU_POINT inline #endif Coordonnee1B& Coordonnee1B::operator= (const Coordonnee1B& c) - { coord1[0]=c.coord1[0]; - return (*this); + { coord1[0]=c.coord1[0]; + return (*this); }; - - + + // Surcharge de l'operateur - : renvoie l'oppose d'un point #ifndef MISE_AU_POINT inline #endif Coordonnee1B Coordonnee1B::operator- () const - { return Coordonnee1B(-coord1[0]); - }; - + { return Coordonnee1B(-coord1[0]); + }; + // Surcharge de l'operateur - : realise la soustraction des // coordonnees de deux points #ifndef MISE_AU_POINT inline #endif Coordonnee1B Coordonnee1B::operator- (const Coordonnee1B& c) const - { return Coordonnee1B(coord1[0]-c.coord1[0]); - }; - + { return Coordonnee1B(coord1[0]-c.coord1[0]); + }; + // Surcharge de l'operateur + : realise l'addition des // coordonnees de deux points #ifndef MISE_AU_POINT inline #endif Coordonnee1B Coordonnee1B::operator+ (const Coordonnee1B& c) const - { return Coordonnee1B(coord1[0]+c.coord1[0]); - }; - + { return Coordonnee1B(coord1[0]+c.coord1[0]); + }; + // Surcharge de l'operateur += #ifndef MISE_AU_POINT inline #endif void Coordonnee1B::operator+= (const Coordonnee1B& c) - { coord1[0]+=c.coord1[0]; - }; + { coord1[0]+=c.coord1[0]; + }; // Surcharge de l'operateur -= #ifndef MISE_AU_POINT inline #endif void Coordonnee1B::operator-= (const Coordonnee1B& c) - { coord1[0]-=c.coord1[0]; - }; + { coord1[0]-=c.coord1[0]; + }; // Surcharge de l'operateur *= #ifndef MISE_AU_POINT inline #endif void Coordonnee1B::operator*= (double val) - { coord1[0]*=val; - }; - + { coord1[0]*=val; + }; + // Surcharge de l'operateur * : multiplication de coordonnees par un scalaire #ifndef MISE_AU_POINT inline #endif Coordonnee1B Coordonnee1B::operator* (double val) const - { - return Coordonnee1B(val*coord1[0]); - }; - + { + return Coordonnee1B(val*coord1[0]); + }; + // Surcharge de l'operateur * : produit scalaire entre coordonnees #ifndef MISE_AU_POINT inline #endif double Coordonnee1B::operator* (const Coordonnee1H& c) const - { return ( coord1[0] * c.coord1[0] ); + { return ( coord1[0] * c.coord1[0] ); }; - + // produit scalaire entre coordonnees covariantes et covariantes #ifndef MISE_AU_POINT inline #endif double Coordonnee1B::ScalBB(const Coordonnee1B& c) const - { return ( coord1[0] * c.coord1[0] ); + { return ( coord1[0] * c.coord1[0] ); }; @@ -250,7 +250,7 @@ double Coordonnee1B::ScalBB(const Coordonnee1B& c) const inline #endif Coordonnee1B Coordonnee1B::operator/ (double val) const - { + { #ifdef MISE_AU_POINT if(Dabs(val) <= ConstMath::trespetit) { cout << "\n erreur, division par zero "; @@ -260,19 +260,19 @@ Coordonnee1B Coordonnee1B::operator/ (double val) const #endif return Coordonnee1B(coord1[0] / val); }; - + // Surcharge de l'operateur /= : division de coordonnees par un scalaire #ifndef MISE_AU_POINT inline #endif void Coordonnee1B::operator/= (double val) - { + { #ifdef MISE_AU_POINT if(Dabs(val) <= ConstMath::trespetit) { cout << "\n erreur, division par zero "; cout << "\nCoordonnee1B::operator/= (double val) " << endl; Sortie (1); - } + } #endif coord1[0]/=val; }; @@ -284,26 +284,26 @@ void Coordonnee1B::operator/= (double val) inline #endif int Coordonnee1B::operator== (const Coordonnee1B& c) const - { if (c.coord1[0]!=coord1[0]) - return 0; - else - return 1; - }; + { if (c.coord1[0]!=coord1[0]) + return 0; + else + return 1; + }; // mise a zero des coordonnées #ifndef MISE_AU_POINT inline #endif void Coordonnee1B::Zero() - { coord1[0] = 0.; - }; - + { coord1[0] = 0.; + }; + // Calcul de la norme euclidienne des composantes du point #ifndef MISE_AU_POINT inline #endif double Coordonnee1B::Norme () const - { return sqrt( coord1[0] * coord1[0] ); + { return sqrt( coord1[0] * coord1[0] ); }; // norme le vecteur coordonnée #ifndef MISE_AU_POINT @@ -316,12 +316,12 @@ Coordonnee1B& Coordonnee1B::Normer () { cout << "\n erreur, division par zero "; cout << "\nCoordonnee1B::Normer () " << endl; Sortie (1); - } + } #endif - *this /= norme; - return *this ; + *this /= norme; + return *this ; }; - + // somme de tous les composantes #ifndef MISE_AU_POINT inline @@ -329,7 +329,7 @@ Coordonnee1B& Coordonnee1B::Normer () double Coordonnee1B::Somme() const { return coord1[0] ; - }; + }; // Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees #ifndef MISE_AU_POINT @@ -345,35 +345,35 @@ double Coordonnee1B::Somme() const // sortie du schemaXML: en fonction de enu void Coordonnee1B::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) { - switch (enu) - { case XML_TYPE_GLOBAUX : - {sort << "\n " - << "\n" - << "\n " - << "\n coordonnee de dimension 1: elements: " - << "\n 1 reel " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n"; - break; - } - case XML_IO_POINT_INFO : - { - break; - } - case XML_IO_POINT_BI : - { - break; - } - case XML_IO_ELEMENT_FINI : - { - break; - } + switch (enu) + { case XML_TYPE_GLOBAUX : + {sort << "\n " + << "\n" + << "\n " + << "\n coordonnee de dimension 1: elements: " + << "\n 1 reel " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n"; + break; + } + case XML_IO_POINT_INFO : + { + break; + } + case XML_IO_POINT_BI : + { + break; + } + case XML_IO_ELEMENT_FINI : + { + break; + } default: sort << "\n SchemaXML: cas non pris en compte " ; - }; + }; }; #endif diff --git a/tenseurs_mai99/Coordonnees/Coordonnee1H.cc b/tenseurs_mai99/Coordonnees/Coordonnee1H.cc index 57ac715..42438a2 100644 --- a/tenseurs_mai99/Coordonnees/Coordonnee1H.cc +++ b/tenseurs_mai99/Coordonnees/Coordonnee1H.cc @@ -51,8 +51,8 @@ using namespace std; //introduces namespace std #endif Coordonnee1H::Coordonnee1H () : CoordonneeH(1,coord1) -{ coord1[0] = 0.; -}; + { coord1[0] = 0.; + }; // Constructeur suivant un booleen // quelque soit la valeur du booleen il n'y a pas initialisation des coordonnées @@ -62,16 +62,16 @@ Coordonnee1H::Coordonnee1H () : #endif Coordonnee1H::Coordonnee1H (bool ): CoordonneeH(1,coord1) -{ }; + { }; #ifndef MISE_AU_POINT inline #endif Coordonnee1H::Coordonnee1H (double x): CoordonneeH(1,coord1) -// Constructeur pour un point a deux dimensions -{ coord1[0]=x; -}; + // Constructeur pour un point a deux dimensions + { coord1[0]=x; + }; // constructeur fonction d'une adresse memoire ou sont stockee les coordonnees // et d'une dimension ( l'existance de la place mémoire est a la charge @@ -82,7 +82,7 @@ Coordonnee1H::Coordonnee1H (double x): Coordonnee1H::Coordonnee1H (double* t): CoordonneeH(1,coord1) { coord1[0]=t[0]; - }; + }; // Constructeur de copie #ifndef MISE_AU_POINT @@ -90,8 +90,8 @@ Coordonnee1H::Coordonnee1H (double* t): #endif Coordonnee1H::Coordonnee1H (const Coordonnee1H& c): CoordonneeH(1,coord1) -{ coord1[0]=c.coord1[0]; -}; + { coord1[0]=c.coord1[0]; + }; // Constructeur de copie pour une instance indiférenciée #ifndef MISE_AU_POINT @@ -99,41 +99,41 @@ Coordonnee1H::Coordonnee1H (const Coordonnee1H& c): #endif Coordonnee1H::Coordonnee1H (const CoordonneeH& c): CoordonneeH(1,coord1) -{ - #ifdef MISE_AU_POINT - if (c.Dimension () != 1) - { cout << "\nErreur la dimension de c est différente de 1 !! !\n"; - cout << "Coordonnee1H::Coordonnee1H (const Coordonnee& c) \n"; - Sortie(1); - } - #endif - coord1[0]=c(1); -}; + { + #ifdef MISE_AU_POINT + if (c.Dimension () != 1) + { cout << "\nErreur la dimension de c est différente de 1 !! !\n"; + cout << "Coordonnee1H::Coordonnee1H (const Coordonnee& c) \n"; + Sortie(1); + } + #endif + coord1[0]=c(1); + }; // DESTRUCTEUR : #ifndef MISE_AU_POINT inline #endif Coordonnee1H::~Coordonnee1H () -{ dim = 0; // pour l'appel de ~Coordonnee() - #ifdef MISE_AU_POINT - coord=NULL; - #endif - }; -// Desallocation de la place memoire allouee -// fonction définie dans la classe mère générique mais qui n'a pas de -// sens ici -#ifndef MISE_AU_POINT - inline -#endif -void Coordonnee1H::Libere () - { - #ifdef MISE_AU_POINT - cout << "\nErreur cette fonction n'a pas cours !! !\n"; - cout << "Coordonnee1H::Libere () \n"; - Sortie(1); - #endif - }; + { dim = 0; // pour l'appel de ~Coordonnee() + #ifdef MISE_AU_POINT + coord=NULL; + #endif + }; +//// Desallocation de la place memoire allouee +//// fonction définie dans la classe mère générique mais qui n'a pas de +//// sens ici +//#ifndef MISE_AU_POINT +// inline +//#endif +//void Coordonnee1H::Libere () +// { +// #ifdef MISE_AU_POINT +// cout << "\nErreur cette fonction n'a pas cours !! !\n"; +// cout << "Coordonnee1H::Libere () \n"; +// Sortie(1); +// #endif +// }; // Renvoie le nombre de coordonnees @@ -143,105 +143,105 @@ void Coordonnee1H::Libere () int Coordonnee1H::Dimension () const { return 1; }; -// changement de la dimension -// fonction définie dans la classe mère générique mais qui n'a pas de -// sens ici -#ifndef MISE_AU_POINT - inline -#endif -void Coordonnee1H::Change_dim(int ) - { - #ifdef MISE_AU_POINT - cout << "\nErreur cette fonction n'a pas cours !! !\n"; - cout << "Coordonnee1H::Change_dim(int dimen) \n"; - Sortie(1); - #endif - }; +//// changement de la dimension +//// fonction définie dans la classe mère générique mais qui n'a pas de +//// sens ici +//#ifndef MISE_AU_POINT +// inline +//#endif +//void Coordonnee1H::Change_dim(int ) +// { +// #ifdef MISE_AU_POINT +// cout << "\nErreur cette fonction n'a pas cours !! !\n"; +// cout << "Coordonnee1H::Change_dim(int dimen) \n"; +// Sortie(1); +// #endif +// }; // Surcharge de l'operateur = : realise l'affectation entre deux points #ifndef MISE_AU_POINT inline #endif Coordonnee1H& Coordonnee1H::operator= (const Coordonnee1H& c) - { coord1[0]=c.coord1[0]; - return (*this); - }; - - + { coord1[0]=c.coord1[0]; + return (*this); + }; + + // Surcharge de l'operateur - : renvoie l'oppose d'un point #ifndef MISE_AU_POINT inline #endif Coordonnee1H Coordonnee1H::operator- () const - { return Coordonnee1H(-coord1[0]); - }; - + { return Coordonnee1H(-coord1[0]); + }; + // Surcharge de l'operateur - : realise la soustraction des // coordonnees de deux points #ifndef MISE_AU_POINT inline #endif Coordonnee1H Coordonnee1H::operator- (const Coordonnee1H& c) const - { return Coordonnee1H(coord1[0]-c.coord1[0]); - }; - + { return Coordonnee1H(coord1[0]-c.coord1[0]); + }; + // Surcharge de l'operateur + : realise l'addition des // coordonnees de deux points #ifndef MISE_AU_POINT inline #endif Coordonnee1H Coordonnee1H::operator+ (const Coordonnee1H& c) const - { return Coordonnee1H(coord1[0]+c.coord1[0]); - }; - + { return Coordonnee1H(coord1[0]+c.coord1[0]); + }; + // Surcharge de l'operateur += #ifndef MISE_AU_POINT inline #endif void Coordonnee1H::operator+= (const Coordonnee1H& c) - { coord1[0]+=c.coord1[0]; - }; + { coord1[0]+=c.coord1[0]; + }; // Surcharge de l'operateur -= #ifndef MISE_AU_POINT inline #endif void Coordonnee1H::operator-= (const Coordonnee1H& c) - { coord1[0]-=c.coord1[0]; - }; + { coord1[0]-=c.coord1[0]; + }; // Surcharge de l'operateur *= #ifndef MISE_AU_POINT inline #endif void Coordonnee1H::operator*= (double val) - { coord1[0]*=val; - }; - + { coord1[0]*=val; + }; + // Surcharge de l'operateur * : multiplication de coordonnees par un scalaire #ifndef MISE_AU_POINT inline #endif Coordonnee1H Coordonnee1H::operator* (double val) const - { - return Coordonnee1H(val*coord1[0]); - }; - + { + return Coordonnee1H(val*coord1[0]); + }; + // Surcharge de l'operateur * : produit scalaire entre coordonnees #ifndef MISE_AU_POINT inline #endif double Coordonnee1H::operator* (const Coordonnee1B& c) const - { return ( coord1[0] * c.coord1[0] ); + { return ( coord1[0] * c.coord1[0] ); }; - + // produit scalaire entre coordonnees contravariantes et contravariantes #ifndef MISE_AU_POINT inline #endif double Coordonnee1H::ScalHH(const Coordonnee1H& c) const - { return ( coord1[0] * c.coord1[0] ); + { return ( coord1[0] * c.coord1[0] ); }; @@ -250,28 +250,28 @@ double Coordonnee1H::ScalHH(const Coordonnee1H& c) const inline #endif Coordonnee1H Coordonnee1H::operator/ (double val) const - { + { #ifdef MISE_AU_POINT if(Dabs(val) <= ConstMath::trespetit) - { cout << "\n erreur, division par zero "; - cout << "\nCoordonnee1H::operator/ (double val) " << endl; - Sortie (1); - } + { cout << "\n erreur, division par zero "; + cout << "\nCoordonnee1H::operator/ (double val) " << endl; + Sortie (1); + } #endif - return Coordonnee1H(coord1[0] / val); + return Coordonnee1H(coord1[0] / val); }; - + // Surcharge de l'operateur /= : division de coordonnees par un scalaire #ifndef MISE_AU_POINT inline #endif void Coordonnee1H::operator/= (double val) - { + { #ifdef MISE_AU_POINT if(Dabs(val) <= ConstMath::trespetit) - { cout << "\n erreur, division par zero "; - cout << "\nCoordonnee1H::operator/= (double val) " << endl; - Sortie (1); + { cout << "\n erreur, division par zero "; + cout << "\nCoordonnee1H::operator/= (double val) " << endl; + Sortie (1); } #endif coord1[0]/=val; @@ -284,44 +284,44 @@ void Coordonnee1H::operator/= (double val) inline #endif int Coordonnee1H::operator== (const Coordonnee1H& c) const - { if (c.coord1[0]!=coord1[0]) - return 0; - else - return 1; - }; + { if (c.coord1[0]!=coord1[0]) + return 0; + else + return 1; + }; // mise a zero des coordonnées #ifndef MISE_AU_POINT inline #endif void Coordonnee1H::Zero() - { coord1[0] = 0.; - }; - + { coord1[0] = 0.; + }; + // Calcul de la norme euclidienne des composantes du point #ifndef MISE_AU_POINT inline #endif double Coordonnee1H::Norme () const - { return sqrt( coord1[0] * coord1[0] ); + { return sqrt( coord1[0] * coord1[0] ); }; // norme le vecteur coordonnée #ifndef MISE_AU_POINT inline #endif Coordonnee1H& Coordonnee1H::Normer () - { double norme = this->Norme(); + { double norme = this->Norme(); #ifdef MISE_AU_POINT if(Dabs(norme) <= ConstMath::trespetit) { cout << "\n erreur, division par zero "; cout << "\nCoordonnee1H::Normer () " << endl; Sortie (1); - } + } #endif - *this /= norme; - return *this ; - }; - + *this /= norme; + return *this ; + }; + // somme de tous les composantes #ifndef MISE_AU_POINT inline @@ -329,7 +329,7 @@ Coordonnee1H& Coordonnee1H::Normer () double Coordonnee1H::Somme() const { return coord1[0] ; - }; + }; // Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees #ifndef MISE_AU_POINT @@ -344,39 +344,39 @@ double Coordonnee1H::Somme() const // sortie du schemaXML: en fonction de enu void Coordonnee1H::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) { - switch (enu) - { case XML_TYPE_GLOBAUX : - {sort << "\n " - << "\n" - << "\n " - << "\n coordonnee de dimension 1: elements: " - << "\n 1 reel " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n"; - break; - } - case XML_IO_POINT_INFO : - { - break; - } - case XML_IO_POINT_BI : - { - break; - } - case XML_IO_ELEMENT_FINI : - { - break; - } + switch (enu) + { case XML_TYPE_GLOBAUX : + {sort << "\n " + << "\n" + << "\n " + << "\n coordonnee de dimension 1: elements: " + << "\n 1 reel " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n"; + break; + } + case XML_IO_POINT_INFO : + { + break; + } + case XML_IO_POINT_BI : + { + break; + } + case XML_IO_ELEMENT_FINI : + { + break; + } default: cout << "\n *** attention cas non pris en compte pour le moment " << " XML_TYPE_GLOBAUX= "<Norme(); + { double norme = this->Norme(); #ifdef MISE_AU_POINT if(Dabs(norme) <= ConstMath::trespetit) { cout << "\n erreur, division par zero "; cout << "\nCoordonnee2::Normer () " << endl; Sortie (1); - } + } #endif - *this /= norme; - return *this ; + *this /= norme; + return *this ; }; - + // somme de tous les composantes #ifndef MISE_AU_POINT inline #endif double Coordonnee2::Somme() const { return ( coord2[0] + coord2[1] ); - }; + }; /*// Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees #ifndef MISE_AU_POINT @@ -338,45 +337,45 @@ double Coordonnee2::Somme() const // sortie du schemaXML: en fonction de enu void Coordonnee2::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) { - switch (enu) - { case XML_TYPE_GLOBAUX : - {sort << "\n " - << "\n" - << "\n " - << "\n coordonnee de dimension 2: elements: " - << "\n 2 reels " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n"; - break; - } - case XML_IO_POINT_INFO : - { - break; - } - case XML_IO_POINT_BI : - { - break; - } - case XML_IO_ELEMENT_FINI : - { - break; - } + switch (enu) + { case XML_TYPE_GLOBAUX : + {sort << "\n " + << "\n" + << "\n " + << "\n coordonnee de dimension 2: elements: " + << "\n 2 reels " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n"; + break; + } + case XML_IO_POINT_INFO : + { + break; + } + case XML_IO_POINT_BI : + { + break; + } + case XML_IO_ELEMENT_FINI : + { + break; + } default: cout << "\n *** attention cas non pris en compte pour le moment " << " XML_TYPE_GLOBAUX= "<Norme(); + { double norme = this->Norme(); #ifdef MISE_AU_POINT - if(Dabs(norme) <= ConstMath::trespetit) - { cout << "\n erreur, division par zero "; - cout << "\nCoordonnee2B::Normer () " << endl; - Sortie (1); + if(Dabs(norme) <= ConstMath::trespetit) + { cout << "\n erreur, division par zero "; + cout << "\nCoordonnee2B::Normer () " << endl; + Sortie (1); } - #endif - *this /= norme; - return *this ; - }; - + #endif + *this /= norme; + return *this ; + }; + // somme de tous les composantes #ifndef MISE_AU_POINT inline #endif double Coordonnee2B::Somme() const { return ( coord2[0] + coord2[1] ); - }; - + }; + #ifndef MISE_AU_POINT inline #endif // calcul du déterminant de deux vecteurs coordonnées double Coordonnee2B::Determinant2B( const Coordonnee2B & v1, const Coordonnee2B & v2) { return v1.coord2[0] * v2.coord2[1] - v1.coord2[1] * v2.coord2[0]; - }; + }; /* // Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees #ifndef MISE_AU_POINT @@ -352,45 +352,45 @@ double Coordonnee2B::Determinant2B( const Coordonnee2B & v1, const Coordonnee2B // sortie du schemaXML: en fonction de enu void Coordonnee2B::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) { - switch (enu) - { case XML_TYPE_GLOBAUX : - {sort << "\n " - << "\n" - << "\n " - << "\n coordonnee de dimension 2: elements: " - << "\n 2 reels " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n"; - break; - } - case XML_IO_POINT_INFO : - { - break; - } - case XML_IO_POINT_BI : - { - break; - } - case XML_IO_ELEMENT_FINI : - { - break; - } + switch (enu) + { case XML_TYPE_GLOBAUX : + {sort << "\n " + << "\n" + << "\n " + << "\n coordonnee de dimension 2: elements: " + << "\n 2 reels " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n"; + break; + } + case XML_IO_POINT_INFO : + { + break; + } + case XML_IO_POINT_BI : + { + break; + } + case XML_IO_ELEMENT_FINI : + { + break; + } default: cout << "\n *** attention cas non pris en compte pour le moment " << " XML_TYPE_GLOBAUX= "<Norme(); + { double norme = this->Norme(); #ifdef MISE_AU_POINT - if(Dabs(norme) <= ConstMath::trespetit) - { cout << "\n erreur, division par zero "; - cout << "\nCoordonnee2H::Normer () " << endl; - Sortie (1); - } + if(Dabs(norme) <= ConstMath::trespetit) + { cout << "\n erreur, division par zero "; + cout << "\nCoordonnee2H::Normer () " << endl; + Sortie (1); + } #endif - *this /= norme; - return *this ; - }; - + *this /= norme; + return *this ; + }; + // somme de tous les composantes #ifndef MISE_AU_POINT inline #endif double Coordonnee2H::Somme() const { return ( coord2[0] + coord2[1] ); - }; + }; /* // Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees #ifndef MISE_AU_POINT @@ -344,45 +344,45 @@ double Coordonnee2H::Somme() const // sortie du schemaXML: en fonction de enu void Coordonnee2H::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) { - switch (enu) - { case XML_TYPE_GLOBAUX : - {sort << "\n " - << "\n" - << "\n " - << "\n coordonnee de dimension 2: elements: " - << "\n 2 reels " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n"; - break; - } - case XML_IO_POINT_INFO : - { - break; - } - case XML_IO_POINT_BI : - { - break; - } - case XML_IO_ELEMENT_FINI : - { - break; - } - default: cout << "\n *** attention cas non pris en compte pour le moment " - << " XML_TYPE_GLOBAUX= "<" + << "\n" + << "\n " + << "\n coordonnee de dimension 2: elements: " + << "\n 2 reels " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n"; + break; + } + case XML_IO_POINT_INFO : + { + break; + } + case XML_IO_POINT_BI : + { + break; + } + case XML_IO_ELEMENT_FINI : + { + break; + } + default: cout << "\n *** attention cas non pris en compte pour le moment " + << " XML_TYPE_GLOBAUX= "<Norme(); + { double norme = this->Norme(); #ifdef MISE_AU_POINT - if(Dabs(norme) <= ConstMath::trespetit) - { cout << "\n erreur, division par zero "; - cout << "\nCoordonnee3::Normer () " << endl; - Sortie (1); + if(Dabs(norme) <= ConstMath::trespetit) + { cout << "\n erreur, division par zero "; + cout << "\nCoordonnee3::Normer () " << endl; + Sortie (1); } #endif - *this /= norme; - return *this ; - }; - + *this /= norme; + return *this ; + }; + // somme de tous les composantes #ifndef MISE_AU_POINT inline @@ -338,7 +338,7 @@ Coordonnee3& Coordonnee3::Normer () double Coordonnee3::Somme() const { return ( coord3[0] + coord3[1] + coord3[2] ); - }; + }; /* // Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees #ifndef MISE_AU_POINT @@ -353,45 +353,45 @@ double Coordonnee3::Somme() const // sortie du schemaXML: en fonction de enu void Coordonnee3::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) { - switch (enu) - { case XML_TYPE_GLOBAUX : - {sort << "\n " - << "\n" - << "\n " - << "\n coordonnee de dimension 3: elements: " - << "\n 3 reels " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n"; - break; - } - case XML_IO_POINT_INFO : - { - break; - } - case XML_IO_POINT_BI : - { - break; - } - case XML_IO_ELEMENT_FINI : - { - break; - } - default: cout << "\n *** attention cas non pris en compte pour le moment " - << " XML_TYPE_GLOBAUX= "<" + << "\n" + << "\n " + << "\n coordonnee de dimension 3: elements: " + << "\n 3 reels " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n"; + break; + } + case XML_IO_POINT_INFO : + { + break; + } + case XML_IO_POINT_BI : + { + break; + } + case XML_IO_ELEMENT_FINI : + { + break; + } + default: cout << "\n *** attention cas non pris en compte pour le moment " + << " XML_TYPE_GLOBAUX= "<Norme(); + { double norme = this->Norme(); #ifdef MISE_AU_POINT - if(Dabs(norme) <= ConstMath::trespetit) - { cout << "\n erreur, division par zero "; - cout << "\nCoordonnee3B::Normer () " << endl; - Sortie (1); + if(Dabs(norme) <= ConstMath::trespetit) + { cout << "\n erreur, division par zero "; + cout << "\nCoordonnee3B::Normer () " << endl; + Sortie (1); } #endif - *this /= norme; - return *this ; - }; - + *this /= norme; + return *this ; + }; + // somme de tous les composantes #ifndef MISE_AU_POINT inline @@ -341,8 +341,8 @@ Coordonnee3B& Coordonnee3B::Normer () double Coordonnee3B::Somme() const { return ( coord3[0] + coord3[1] + coord3[2] ); - }; - + }; + // calcul du déterminant de trois vecteurs #ifndef MISE_AU_POINT inline @@ -352,7 +352,7 @@ double Coordonnee3B::Determinant3B( const Coordonnee3B & v1, const Coordonnee3B +(v2.coord3[0] * v1.coord3[2] - v1.coord3[0] * v2.coord3[2])* v3.coord3[1] +(v1.coord3[0] * v2.coord3[1] - v2.coord3[0] * v1.coord3[1])* v3.coord3[2] ) ; return toto; - }; + }; // calcul du produit vectoriel de 2 vecteurs coordonnées #ifndef MISE_AU_POINT @@ -363,7 +363,7 @@ Coordonnee3H Coordonnee3B::Vectoriel( const Coordonnee3B & v1, const Coordonnee3 (v2.coord3[0] * v1.coord3[2] - v1.coord3[0] * v2.coord3[2]), (v1.coord3[0] * v2.coord3[1] - v2.coord3[0] * v1.coord3[1])); return ret; - }; + }; /* // Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees #ifndef MISE_AU_POINT @@ -378,45 +378,45 @@ Coordonnee3H Coordonnee3B::Vectoriel( const Coordonnee3B & v1, const Coordonnee3 // sortie du schemaXML: en fonction de enu void Coordonnee3B::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) { - switch (enu) - { case XML_TYPE_GLOBAUX : - {sort << "\n " - << "\n" - << "\n " - << "\n coordonnee de dimension 3: elements: " - << "\n 3 reels " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n"; - break; - } - case XML_IO_POINT_INFO : - { - break; - } - case XML_IO_POINT_BI : - { - break; - } - case XML_IO_ELEMENT_FINI : - { - break; - } - default: cout << "\n *** attention cas non pris en compte pour le moment " - << " XML_TYPE_GLOBAUX= "<" + << "\n" + << "\n " + << "\n coordonnee de dimension 3: elements: " + << "\n 3 reels " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n"; + break; + } + case XML_IO_POINT_INFO : + { + break; + } + case XML_IO_POINT_BI : + { + break; + } + case XML_IO_ELEMENT_FINI : + { + break; + } + default: cout << "\n *** attention cas non pris en compte pour le moment " + << " XML_TYPE_GLOBAUX= "<Norme(); + { double norme = this->Norme(); #ifdef MISE_AU_POINT if(Dabs(norme) <= ConstMath::trespetit) { cout << "\n erreur, division par zero "; cout << "\nCoordonnee3H::Normer () " << endl; Sortie (1); - } + } #endif - *this /= norme; - return *this ; - }; - + *this /= norme; + return *this ; + }; + // somme de tous les composantes #ifndef MISE_AU_POINT inline @@ -342,7 +342,7 @@ Coordonnee3H& Coordonnee3H::Normer () double Coordonnee3H::Somme() const { return ( coord3[0] + coord3[1] + coord3[2] ); - }; + }; /* // Surcharge de l'operateur * : multiplication entre un scalaire et des coordonnees #ifndef MISE_AU_POINT @@ -357,45 +357,45 @@ double Coordonnee3H::Somme() const // sortie du schemaXML: en fonction de enu void Coordonnee3H::SchemaXML_Coordonnee(ostream& sort,const Enum_IO_XML enu) { - switch (enu) - { case XML_TYPE_GLOBAUX : - {sort << "\n " - << "\n" - << "\n " - << "\n coordonnee de dimension 3: elements: " - << "\n 3 reels " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n"; - break; - } - case XML_IO_POINT_INFO : - { - break; - } - case XML_IO_POINT_BI : - { - break; - } - case XML_IO_ELEMENT_FINI : - { - break; - } - default: cout << "\n *** attention cas non pris en compte pour le moment " - << " XML_TYPE_GLOBAUX= "<" + << "\n" + << "\n " + << "\n coordonnee de dimension 3: elements: " + << "\n 3 reels " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n"; + break; + } + case XML_IO_POINT_INFO : + { + break; + } + case XML_IO_POINT_BI : + { + break; + } + case XML_IO_ELEMENT_FINI : + { + break; + } + default: cout << "\n *** attention cas non pris en compte pour le moment " + << " XML_TYPE_GLOBAUX= "<// N.B. : la dimension est affectee a 3 et les valeurs a 0 +// avant ->// N.B. : la dimension est affectee a 3 et les valeurs a 0 #ifndef MISE_AU_POINT inline #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,20 +60,19 @@ 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 << "CoordonneeB::CoordonneeB (int ) \n"; - Sortie(1); - }; - #endif - coord=new double [dim]; - for (int i=0;i3) ) + {cout << "\nErreur de dimension !\n"; + cout << "\n la dimension demandée est "< aucune action #ifndef MISE_AU_POINT inline #endif CoordonneeB::~CoordonneeB () -{ 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 - } -}; - + { if (memoire) + { if (dim > 0) + { delete [] coord; + coord=NULL; + dim=0; + } + }; + }; + // construction "explicite" à partir d'une instance de CoordonneeB // intéressant si this est initialement construit par defaut (donc vide) // cela permet de créer un CoordonneeH à partir d'un B, mais de manière explicite, @@ -174,16 +163,16 @@ 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]; case 1 : coord[0] = aH.coord[0]; case 0 : ; // on ne fait rien - }; + }; }; - + #ifndef MISE_AU_POINT inline #endif @@ -191,14 +180,14 @@ 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); case 1 : coord[0] = c(1); case 0 : ; // on ne fait rien - }; + }; }; @@ -207,155 +196,186 @@ void CoordonneeB::Change_val(const Coordonnee& c) inline #endif int CoordonneeB::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 CoordonneeB::Libere () - { if ( dim>0 ) - delete [] coord; - else - {if ( coord!=NULL ) - { cout << "\nErreur de liberation de la place memoire\n"; - cout << "CoordonneeB::LIBERE () \n"; - Sortie(1); - } - } - coord=NULL; - dim=0; - }; + {if (memoire) + { 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 << "CoordonneeB::Libere () \n"; + Sortie(1); + } + }; + coord=NULL; + dim=0; + }; + }; // Renvoie la ieme coordonnee #ifndef MISE_AU_POINT inline #endif double& CoordonneeB::operator() (int i) - { - #ifdef MISE_AU_POINT - if ( (i<1) || (i>dim) ) - { cout << "\nErreur de dimension !\n"; - cout << "CoordonneeB::OPERATOR() (int ) \n"; - Sortie(1); - }; - #endif - return coord[i-1]; - }; - + { + #ifdef MISE_AU_POINT + if ( (i<1) || (i>dim) ) + {cout << "\n***Erreur de dimension !\n"; + cout <<"\n on demande la coordonnee i="<dim) ) - { cout << "\nErreur de dimension !\n"; - cout << "CoordonneeB::OPERATOR() (int ) \n"; - Sortie(1); - }; - #endif - return coord[i-1]; - }; + { + #ifdef MISE_AU_POINT + if ( (i<1) || (i>dim) ) + {cout << "\nErreur de dimension !\n"; + cout <<"\n on demande la coordonnee i="<3)) - { cout << "\n erreur, la nouvelle dimension doit etre comprise entre 1 et 3 ! "; - cout << "\n dim voulue = " << dimen ; - cout << "\nCoordonneeB::Change_dim(int dim) " << endl; - Sortie(1); - } - #endif - double * sauve = coord; - if (dim < dimen) - { coord = new double [dimen]; - for (int i=0;i3)) + { cout << "\n erreur, la nouvelle dimension doit etre comprise entre 1 et 3 ! "; + cout << "\n dim voulue = " << dimen ; + cout << "\nCoordonneeB::Change_dim(int dim) " << endl; + Sortie(1); } - else if (dim > dimen) - { coord = new double [dimen]; - for (int i=0;i dimen) + { coord = new double [dimen]; + for (int i=0;i erreur #ifndef MISE_AU_POINT inline #endif CoordonneeB& CoordonneeB::operator= (const CoordonneeB& c) - { if (dim==c.dim) - { for (int i=0;idim-1; i++) sort << setw (nb) << this->coord[i] << " "; - }; + }; // conversion explicite en coordonnées sans variance #ifndef MISE_AU_POINT @@ -564,18 +598,18 @@ Coordonnee CoordonneeB::Coor()const // ici on pourrait optimiser en créant un coordonnée const, avec la mémoire au même endroit // non !!! car this pourrait ne plus exister alors que le retour continue à exister !! donc pas bon { switch (dim) - { case 1: {return Coordonnee(coord[0]); break;} - case 2: {return Coordonnee(coord[0],coord[1]); break;} - case 3: {return Coordonnee(coord[0],coord[1],coord[2]); break;} - default: - { cout << "\n erreur de dimension: dim= " << dim - << " il n'est pas possible de transformer en Coordonnee !" - << "\n CoordonneeB::Coor()const" ; - Sortie(1); - }; - }; - return Coordonnee(0.); // pour éviter le warning - }; + { case 1: {return Coordonnee(coord[0]); break;} + case 2: {return Coordonnee(coord[0],coord[1]); break;} + case 3: {return Coordonnee(coord[0],coord[1],coord[2]); break;} + default: + { cout << "\n erreur de dimension: dim= " << dim + << " il n'est pas possible de transformer en Coordonnee !" + << "\n CoordonneeB::Coor()const" ; + Sortie(1); + }; + }; + return Coordonnee(0.); // pour éviter le warning + }; // création explicite en coordonnées sans variance // mais le vecteur est à la même place pour un coût de construction minimum, @@ -584,8 +618,8 @@ Coordonnee CoordonneeB::Coor()const inline #endif const Coordonnee CoordonneeB::Coor_const()const - { return Coordonnee(dim,coord); - }; + { return Coordonnee(dim,coord); + }; // conversion explicite de B en H #ifndef MISE_AU_POINT @@ -595,34 +629,34 @@ CoordonneeH CoordonneeB::Bas_haut()const // ici on pourrait optimiser en créant un coordonnée const, avec la mémoire au même endroit // non !!! car this pourrait ne plus exister alors que le retour continue à exister !! donc pas bon { switch (dim) - { case 1: {return CoordonneeH(coord[0]); break;} - case 2: {return CoordonneeH(coord[0],coord[1]); break;} - case 3: {return CoordonneeH(coord[0],coord[1],coord[2]); break;} - default: - { cout << "\n erreur de dimension: dim= " << dim - << " il n'est pas possible de transformer en CoordonneeH !" - << "\n CoordonneeB::Bas_haut()const" ; - Sortie(1); - }; - }; - return CoordonneeH(0.); // pour éviter le warning - }; + { case 1: {return CoordonneeH(coord[0]); break;} + case 2: {return CoordonneeH(coord[0],coord[1]); break;} + case 3: {return CoordonneeH(coord[0],coord[1],coord[2]); break;} + default: + { cout << "\n erreur de dimension: dim= " << dim + << " il n'est pas possible de transformer en CoordonneeH !" + << "\n CoordonneeB::Bas_haut()const" ; + Sortie(1); + }; + }; + return CoordonneeH(0.); // pour éviter le warning + }; // mise a zero des coordonnées #ifndef MISE_AU_POINT inline #endif void CoordonneeB::Zero() - { for (int i=0;i> ( 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: "<> ( istream & ent, CoordonneeB & coo) " << endl ; + Sortie(1); return ent; - } + }; // lecture de la dimension - int dim; + int dim; ent >> nomtype >> dim ; - // on redimensionne éventuellement la taille - if (coo.dim != dim) - { if (coo.memoire) // cas ou c'est un vrai point - { if (coo.coord != NULL) { delete [] coo.coord;} - coo.coord = new double [dim]; - coo.dim = dim; - } - else - { 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); - }; - }; + // on redimensionne éventuellement la taille + if (coo.dim != dim) + { if (coo.memoire) // cas ou c'est un vrai point + { if (coo.coord != NULL) { delete [] coo.coord;} + coo.coord = new double [dim]; + coo.dim = dim; + } + else + { 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); + }; + }; // les data for (int i = 0; i<= coo.dim-1; i++) - ent >> coo.coord[i] ; + ent >> coo.coord[i] ; return ent; }; @@ -687,13 +724,13 @@ ostream & operator << ( ostream & sort,const CoordonneeB & coo) inline #endif double CoordonneeB::Norme () const -{ double norme=0.0; - for (int i=0;iNorme(); - #ifdef MISE_AU_POINT + #ifdef MISE_AU_POINT if(Dabs(norme) <= ConstMath::trespetit) { cout << "\n erreur, division par zero "; cout << "\nCoordonneeB::Normer () " << endl; Sortie (1); - } + }; #endif - *this /= norme; - return *this ; + *this /= norme; + return *this ; }; #ifndef MISE_AU_POINT @@ -717,31 +754,31 @@ 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]); - case 1: maxi=DabsMaX(maxi,coord[0]); - case 0: break; - }; - return maxi; -}; + { case 3: maxi=DabsMaX(maxi,coord[2]); + case 2: maxi=DabsMaX(maxi,coord[1]); + case 1: maxi=DabsMaX(maxi,coord[0]); + 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.; - in = 0; + {double maxi=0.; + in = 0; switch (dim) - { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} - case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} - case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} - case 0: break; - }; - return maxi; -}; + { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} + case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} + case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} + case 0: break; + }; + return maxi; + }; #ifndef MISE_AU_POINT inline @@ -749,17 +786,17 @@ 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.; - int in = 0; + {double maxi=0.; + int in = 0; switch (dim) - { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} - case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} - case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} - case 0: break; - }; - if (in != 0) {return coord[in-1];} - else {return maxi;}; -}; + { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} + case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} + case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} + case 0: break; + }; + if (in != 0) {return coord[in-1];} + else {return maxi;}; + }; #ifndef MISE_AU_POINT inline @@ -767,17 +804,17 @@ 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.; - in = 0; + {double maxi=0.; + in = 0; switch (dim) - { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} - case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} - case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} - case 0: break; - }; - if (in != 0) {return coord[in-1];} - else {return maxi;}; -}; + { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} + case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} + case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} + case 0: break; + }; + if (in != 0) {return coord[in-1];} + else {return maxi;}; + }; #ifndef MISE_AU_POINT inline @@ -804,7 +841,7 @@ void CoordonneeB::Modif_en_min(const CoordonneeB& v) // ajoute une même valeur à tous les coordonnées void CoordonneeB::Ajout_meme_valeur(double val) { for (int i=0;i" - << "\n" - << "\n " - << "\n coordonnee de dimension 1 ou 2 ou 3: elements: " - << "\n un entier (dim) donnant la dimension, et dim reels " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n"; - break; - } - case XML_IO_POINT_INFO : - { - break; - } - case XML_IO_POINT_BI : - { - break; - } - case XML_IO_ELEMENT_FINI : - { - break; - } - }; +switch (enu) +{ case XML_TYPE_GLOBAUX : + {sort << "\n " + << "\n" + << "\n " + << "\n coordonnee de dimension 1 ou 2 ou 3: elements: " + << "\n un entier (dim) donnant la dimension, et dim reels " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n"; + break; +} +case XML_IO_POINT_INFO : +{ + break; +} +case XML_IO_POINT_BI : +{ + break; +} +case XML_IO_ELEMENT_FINI : +{ + break; +} +}; }; - - + + #endif diff --git a/tenseurs_mai99/Coordonnees/CoordonneeH.cc b/tenseurs_mai99/Coordonnees/CoordonneeH.cc index 087ad80..12e977a 100644 --- a/tenseurs_mai99/Coordonnees/CoordonneeH.cc +++ b/tenseurs_mai99/Coordonnees/CoordonneeH.cc @@ -46,13 +46,13 @@ using namespace std; //introduces namespace std #ifndef COORDONNEE_H_deja_inclus // Constructeur par defaut -// avant ->// N.B. : la dimension est affectee a 3 et les valeurs a 0 +// avant ->// N.B. : la dimension est affectee a 3 et les valeurs a 0 #ifndef MISE_AU_POINT inline #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,20 +61,19 @@ 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 << "CoordonneeH::CoordonneeH (int ) \n"; - Sortie(1); - }; + { + #ifdef MISE_AU_POINT + if ( (dimension<1) || (dimension>3) ) + {cout << "\nErreur de dimension !\n"; + cout << "\n la dimension demandée est "< aucune action #ifndef MISE_AU_POINT inline #endif CoordonneeH::~CoordonneeH () -{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 - } -}; - + {if (memoire) + { if (dim > 0) + { delete [] coord; + coord=NULL; + dim=0; + } + }; + }; + // construction "explicite" à partir d'une instance de CoordonneeB // intéressant si this est initialement construit par defaut (donc vide) // cela permet de créer un CoordonneeH à partir d'un B, mais de manière explicite, @@ -175,14 +161,14 @@ 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]; case 1 : coord[0] = aB.coord[0]; case 0 : ; // on ne fait rien - }; + }; }; // Renvoie le nombre de coordonnees @@ -190,123 +176,153 @@ 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 ) - delete [] coord; - else - {if ( coord!=NULL ) - { cout << "\nErreur de liberation de la place memoire\n"; - cout << "CoordonneeH::LIBERE () \n"; - Sortie(1); - } - } - coord=NULL; - dim=0; - }; + {if (memoire) + {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 << "CoordonneeH::LIBERE () \n"; + Sortie(1); + } + }; + coord=NULL; + dim=0; + }; + }; // Renvoie la ieme coordonnee #ifndef MISE_AU_POINT inline #endif double& CoordonneeH::operator() (int i) - { - #ifdef MISE_AU_POINT - if ( (i<1) || (i>dim) ) - { cout << "\nErreur de dimension !\n"; - cout << "CoordonneeH::OPERATOR() (int ) \n"; - Sortie(1); - }; - #endif - return coord[i-1]; - }; - + { + #ifdef MISE_AU_POINT + if ( (i<1) || (i>dim) ) + {cout << "\nErreur de dimension !\n"; + cout <<"\n on demande la coordonnee i="<dim) ) - { cout << "\nErreur de dimension !\n"; - cout << "CoordonneeH::OPERATOR() (int ) \n"; - Sortie(1); - }; - #endif - return coord[i-1]; - }; + { + #ifdef MISE_AU_POINT + if ( (i<1) || (i>dim) ) + {cout << "\nErreur de dimension !\n"; + cout <<"\n on demande la coordonnee i="<3)) { cout << "\n erreur, la nouvelle dimension doit etre comprise entre 1 et 3 ! "; cout << "\n dim voulue = " << dimen ; cout << "\nCoordonneeH::Change_dim(int dim) " << endl; Sortie(1); - } + } #endif - double * sauve = coord; - if (dim < dimen) - { coord = new double [dimen]; - for (int i=0;i dimen) - { coord = new double [dimen]; - for (int i=0;i dimen) + { coord = new double [dimen]; + for (int i=0;i> ( 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: "<> ( istream & ent, CoordonneeH & coo) " << endl ; + Sortie(1); return ent; - } + }; // lecture de la dimension - int dim; + int dim; ent >> nomtype >> dim ; - // on redimensionne éventuellement la taille - if (coo.dim != dim) - { if (coo.memoire) // cas ou c'est un vrai point - { if (coo.coord != NULL) { delete [] coo.coord;} - coo.coord = new double [dim]; - coo.dim = dim; - } - else - { 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); - }; - }; + // on redimensionne éventuellement la taille + if (coo.dim != dim) + { if (coo.memoire) // cas ou c'est un vrai point + { if (coo.coord != NULL) { delete [] coo.coord;} + coo.coord = new double [dim]; + coo.dim = dim; + } + else + { 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); + }; + }; // les data for (int i = 0; i<= coo.dim-1; i++) ent >> coo.coord[i] ; @@ -681,13 +712,13 @@ ostream & operator << ( ostream & sort,const CoordonneeH & coo) inline #endif double CoordonneeH::Norme () const -{ double norme=0.0; - for (int i=0;iNorme(); - #ifdef MISE_AU_POINT + #ifdef MISE_AU_POINT if(Dabs(norme) <= ConstMath::trespetit) { cout << "\n erreur, division par zero "; cout << "\nCoordonneeH3::Normer () " << endl; Sortie (1); - } + } #endif - *this /= norme; - return *this ; + *this /= norme; + return *this ; }; #ifndef MISE_AU_POINT inline #endif // Retourne le maximum en valeur absolue des composantes double CoordonneeH::Max_val_abs () const -{ double maxi=0.; - switch (dim) - { case 3: maxi=DabsMaX(maxi,coord[2]); - case 2: maxi=DabsMaX(maxi,coord[1]); - case 1: maxi=DabsMaX(maxi,coord[0]); - case 0: break; - }; - return maxi; -}; + {double maxi=0.; + switch (dim) + { case 3: maxi=DabsMaX(maxi,coord[2]); + case 2: maxi=DabsMaX(maxi,coord[1]); + case 1: maxi=DabsMaX(maxi,coord[0]); + 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.; - in = 0; - switch (dim) - { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} - case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} - case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} - case 0: break; - }; - return maxi; -}; + {double maxi=0.; + in = 0; + switch (dim) + { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} + case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} + case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} + case 0: break; + }; + return maxi; + }; #ifndef MISE_AU_POINT inline @@ -742,17 +773,17 @@ 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.; - int in = 0; - switch (dim) - { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} - case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} - case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} - case 0: break; - }; - if (in != 0) {return coord[in-1];} - else {return maxi;}; -}; + {double maxi=0.; + int in = 0; + switch (dim) + { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} + case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} + case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} + case 0: break; + }; + if (in != 0) {return coord[in-1];} + else {return maxi;}; + }; #ifndef MISE_AU_POINT inline @@ -760,17 +791,17 @@ 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.; - in = 0; - switch (dim) - { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} - case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} - case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} - case 0: break; - }; - if (in != 0) {return coord[in-1];} - else {return maxi;}; -}; + {double maxi=0.; + in = 0; + switch (dim) + { case 3: if (maxi < Dabs(coord[2])) {maxi=coord[2]; in=3;} + case 2: if (maxi < Dabs(coord[1])) {maxi=coord[1]; in=2;} + case 1: if (maxi < Dabs(coord[0])) {maxi=coord[0]; in=1;} + case 0: break; + }; + 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 @@ -789,7 +821,7 @@ void CoordonneeH::Modif_en_max(const CoordonneeH& v) void CoordonneeH::Modif_en_min(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 @@ -797,7 +829,7 @@ void CoordonneeH::Modif_en_min(const CoordonneeH& v) // ajoute une même valeur à tous les coordonnées void CoordonneeH::Ajout_meme_valeur(double val) { for (int i=0;i" - << "\n" - << "\n " - << "\n coordonnee de dimension 1 ou 2 ou 3: elements: " - << "\n un entier (dim) donnant la dimension, et dim reels " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n " - << "\n"; - break; - } - case XML_IO_POINT_INFO : - { - break; - } - case XML_IO_POINT_BI : - { - break; - } - case XML_IO_ELEMENT_FINI : - { - break; - } - }; +switch (enu) +{ case XML_TYPE_GLOBAUX : + {sort << "\n " + << "\n" + << "\n " + << "\n coordonnee de dimension 1 ou 2 ou 3: elements: " + << "\n un entier (dim) donnant la dimension, et dim reels " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n " + << "\n"; + break; +} +case XML_IO_POINT_INFO : +{ + break; +} +case XML_IO_POINT_BI : +{ + break; +} +case XML_IO_ELEMENT_FINI : +{ + break; +} +}; }; - - + + #endif