rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Maillage/LesMaillages.cc
Gérard Rio 3a4e74e5d7 ajout des fichiers du répertoire Maillage 
- concerne les conditions limites, les maillages, les ddl en tout genre
2021-09-18 09:47:14 +02:00

3872 lines
189 KiB
C++
Raw Blame History

// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "LesMaillages.h"
#include "ElemMeca.h"
#include "ReferenceNE.h"
#include "ReferenceAF.h"
#include "MathUtil.h"
#include "ConstMath.h"
#include "LaList.h"
#include "CharUtil.h"
#include "TypeQuelconqueParticulier.h"
#ifndef SYSTEM_MAC_OS_X_unix
#include "Frontier.h"
#endif
// Constructeur
// constructeur par défaut
LesMaillages::LesMaillages():
tabMaillage(0),listFrontiere(),t_i_n(0)
,tab_nb_assemb(0),tt_noeud_front(),tous_indices()
,nbEnreg(0),nbMaillageTotal(0),nbPortion(0),entreePrinc(NULL),paraGlob(NULL)
,lesRef(NULL),domEsclave(0),mapNomMail()
,ddl_representatifs_des_physiques(),types_de_problemes()
,integ_vol_typeQuel(),integ_vol_typeQuel_t(),ref_integ_vol()
,integ_vol_t_typeQuel(),integ_vol_t_typeQuel_t(),ref_integ_vol_t()
,statistique_typeQuel(),statistique_typeQuel_t(),ref_statistique()
,pour_statistique_de_ddl()
,statistique_t_typeQuel(),statistique_t_typeQuel_t(),ref_statistique_t()
,pour_statistique_t_de_ddl()
{ cout << "\n erreur: ce constructeur ne doit pas etre utilise !!"
<< "\n LesMaillages::LesMaillages()";
Sortie(1);
};
LesMaillages::LesMaillages(UtilLecture * ent,ParaGlob * para,LesReferences* Ref) :
/* nbEnreg(para->NombreMaillage()), // Nombre initial de maillage est determine
// dans les parametres globaux
tabMaillage(nbEnreg) // def du tableau de maillage */
tabMaillage(5),listFrontiere(),t_i_n()
,tab_nb_assemb(0),tt_noeud_front(),tous_indices()
,mapNomMail()
,ddl_representatifs_des_physiques(),types_de_problemes()
,integ_vol_typeQuel(),integ_vol_typeQuel_t(),ref_integ_vol()
,integ_vol_t_typeQuel(),integ_vol_t_typeQuel_t(),ref_integ_vol_t()
,statistique_typeQuel(),statistique_typeQuel_t(),ref_statistique()
,pour_statistique_de_ddl()
,statistique_t_typeQuel(),statistique_t_typeQuel_t(),ref_statistique_t()
,pour_statistique_t_de_ddl()
{ lesRef = Ref;
// mise à jour de la map qui fait la liaison nom de maillage <=> numéro de maillage
lesRef->MiseAJourMap(mapNomMail);
entreePrinc = ent;
nbEnreg = 5;
nbMaillageTotal = 0 ; // pour l'instant pas de maillage
nbPortion = nbEnreg ;
paraGlob = para;
domEsclave = 0; // a priori pas de maillage esclave
};
//constructeur de copie
LesMaillages::LesMaillages(const LesMaillages& a)
{ cout << "\n erreur: pour l'instant ce constructeur ne doit pas etre utilise !!"
<< "\n LesMaillages::LesMaillages(const LesMaillages& a)";
Sortie(1);
};
// Destructeur
LesMaillages::~LesMaillages()
{ int tabMaillage_Taille=tabMaillage.Taille();
if (tabMaillage_Taille>=1)
for (int i=1;i<= tabMaillage_Taille;i++)
if (tabMaillage(i)!=NULL)
{delete tabMaillage(i);tabMaillage(i)=NULL;}
};
// METHODES PUBLIQUES :
// lecture des maillages et des references s'y rapportant
void LesMaillages::LectureLesMaillages()
{ if (ParaGlob::NiveauImpression() >= 4)
cout << " debut de la lecture des maillages " << endl;
// --- rechercher d'un premier maillage maillage
int lectureEnCour = 0;
// lecture du premier maillage obligatoire
if ((strstr(entreePrinc->tablcar,"noeuds")!=NULL) ||
(strstr(entreePrinc->tablcar,"nom_maillage")!=NULL))
{ if (ParaGlob::NiveauImpression() >= 5)
cout << " lecture du premier maillage " << endl;
tabMaillage(1) = new Maillage (mapNomMail,1,paraGlob->Dimension());
// indique que les prochaines references seront pour le maillage 1
lesRef->NbMaille(1);
tabMaillage(1)->LectureMaillage(entreePrinc,*lesRef);
// opération d'affinage
tabMaillage(1)->LectureEtApplicationAffinage(entreePrinc,*lesRef);
// init du nombre de maillage
nbMaillageTotal = 1 ;
/*////------- debug
//cout << "\n debug1 LesMaillages::LectureLesMaillages ";
//{
// map < string, int , std::less <string> >::iterator id1, idfin=mapNomMail.end();
// for (id1=mapNomMail.begin();id1!=idfin;id1++)
// cout << "\n "<<(*id1).first << " , " << (*id1).second ;
// cout << endl;
//// mapNomMail;
//
//};*/
}
else
{ cout << " *** erreur dans la lecture du premier maillage " << '\n';
cout << " un premier maillage est obligatoire !!! " << '\n';
Sortie(1);
};
// --- recherche s'il y a d'autres maillages
// tout d'abord on passe le numéro de version si besoin est:
if (strstr(entreePrinc->tablcar,"version:")!=NULL)
entreePrinc->NouvelleDonnee();
if ((strstr(entreePrinc->tablcar,"noeuds")!=NULL) ||
(strstr(entreePrinc->tablcar,"nom_maillage")!=NULL))
do { nbMaillageTotal++;
#ifdef ETUDIANT_LIMITATION
if (nbMaillageTotal > nb_maxi_maillage)
{ cout << "\n nombre maxi de maillage autorisé atteind " << nb_maxi_maillage;
Sortie(1);
}
#endif
if (nbMaillageTotal > nbPortion) // il faut agrandir le tableau de maillage
{ nbPortion = nbPortion+nbEnreg;
tabMaillage.Change_taille(nbPortion);
};
tabMaillage(nbMaillageTotal) = new Maillage (mapNomMail,nbMaillageTotal,paraGlob->Dimension());
// indique le nb de maillage pour l'enregistrement des prochaines references
lesRef->NbMaille(nbMaillageTotal);
//lect des autres MAILlages
if (ParaGlob::NiveauImpression() >= 5)
cout << " lecture du maillage nb: " << nbMaillageTotal << endl;
tabMaillage(nbMaillageTotal)->LectureMaillage(entreePrinc,*lesRef);
/*////------- debug
//cout << "\n debug2 LesMaillages::LectureLesMaillages ";
//{
// map < string, int , std::less <string> >::iterator id1, idfin=mapNomMail.end();
// for (id1=mapNomMail.begin();id1!=idfin;id1++)
// cout << "\n "<<(*id1).first << " , " << (*id1).second ;
// cout << endl;
//// mapNomMail;
//
//};*/
// on demande au maillage de lire éventuellement des rotation, collapse etc.
// --> opération d'affinage, juste pour ce maillage
tabMaillage(nbMaillageTotal)->LectureEtApplicationAffinage(entreePrinc,*lesRef);
// maintenant on regarde si l'on veut une fusion avec le maillage précédent
if (strstr(entreePrinc->tablcar,"fusion_avec_le_maillage_precedent_")!=NULL)
{// si oui on appel la méthode de fusion pour le maillage précédent
List_io < string > nom_mails_a_fusionner; // on crée une liste qui sert pour l'appel général
nom_mails_a_fusionner.push_back(tabMaillage(nbMaillageTotal)->NomDuMaillage());
int nbMaillageTotal_save = nbMaillageTotal;
Fusion_maillages(nom_mails_a_fusionner,tabMaillage(nbMaillageTotal-1)->NomDuMaillage(),lesRef);
// on vérifie qu'il n'y a pas eu de nouveau maillage créé durant la fusion
if (nbMaillageTotal != nbMaillageTotal_save)
{ cout << "\n erreur, il y a eu un nouveau maillage cree, ce n'est pas normal, la suite est impossible "
<< "\n LesMaillages::LectureLesMaillages() " << endl ;
Sortie(1);
};
////------- debug
//cout << "\n debug LesMaillages::LectureLesMaillages : avant le delete";
//lesRef->Affiche(2,0);
////----- fin debug
//{
// map < string, int , std::less <string> >::iterator id1, idfin=mapNomMail.end();
// for (id1=mapNomMail.begin();id1!=idfin;id1++)
// cout << "\n "<<(*id1).first << " , " << (*id1).second ;
// cout << endl;
//// mapNomMail;
//
//};
// maintenant on va supprimer le maillage que l'on vient de lire
Suppression_maillage(tabMaillage(nbMaillageTotal)->NomDuMaillage());
////------- debug
//cout << "\n debug LesMaillages::LectureLesMaillages : après le delete ";
//lesRef->Affiche(2,0);
//{
// map < string, int , std::less <string> >::iterator id1, idfin=mapNomMail.end();
// for (id1=mapNomMail.begin();id1!=idfin;id1++)
// cout << "\n "<<(*id1).first << " , " << (*id1).second ;
// cout << endl;
//// mapNomMail;
//
//};
entreePrinc->NouvelleDonnee(); // on prépare la nouvelle lecture
// après la fusion, on peut encore avoir de l'affinage
// on demande au maillage de lire éventuellement des rotation, collapse etc.
// --> opération d'affinage
tabMaillage(nbMaillageTotal)->LectureEtApplicationAffinage(entreePrinc,*lesRef);
};
/*////------- debug
//cout << "\n debug LesMaillages::LectureLesMaillages après LectureEtApplicationAffinage ";
//{
// map < string, int , std::less <string> >::iterator id1, idfin=mapNomMail.end();
// for (id1=mapNomMail.begin();id1!=idfin;id1++)
// cout << "\n "<<(*id1).first << " , " << (*id1).second ;
// cout << endl;
//// mapNomMail;
//
//};*/
if ((strstr(entreePrinc->tablcar,"noeuds")!=NULL) ||
(strstr(entreePrinc->tablcar,"nom_maillage")!=NULL)) {lectureEnCour = 1;}
else {lectureEnCour = 0;};
} while (lectureEnCour == 1);
// fin de la lecture des maillages les uns après les autres
//---- essai d'une renumérotation globale
//--- on regarde si l'on demande une renumérotation globale de tous les maillages
// n'est actif que s'il y a plusieurs maillages,
if (strstr(entreePrinc->tablcar,"renumerotation_tous_maillages_")!=NULL)
// if (nbMaillageTotal != 1)
{ if (ParaGlob::NiveauImpression() >= 5)
cout << " renumerotation globale de tous les noeuds de tous les maillages " << endl;
// on définit un tableau vide de conditions linéaires (ne sert pas ici)
Tableau <Tableau <Condilineaire> > condCLL;
// appel de l'utilitaire dans lesMaillages avec les conditions linéaire éventuelles
TroisEntiers nouvelles_largeur_en_ddl;
this->Renumerotation(*lesRef,condCLL,nouvelles_largeur_en_ddl);
entreePrinc->NouvelleDonnee(); // positionnement sur une nouvelle info
};
// else
// { if (ParaGlob::NiveauImpression() >= 5)
// cout << " il n'y a qu'un seul maillage, doncrenumerotation globale de tous les noeuds de tous les maillages " << endl;
//
// --- on examine le cas où il y a une distinction domaine esclave/ou non
// if ((strstr(entreePrinc->tablcar,"domaine_esclave")!=NULL) && (nbMaillageTotal != 1))
if (strstr(entreePrinc->tablcar,"domaine_esclave")!=NULL)
// cas ou l'on a des domaines esclaves, lecture du nombre
{ entreePrinc->NouvelleDonnee();
if (ParaGlob::NiveauImpression() >= 5)
cout << " lecture du nombre de domaines esclaves " << endl;
*(entreePrinc->entree) >> domEsclave; // lecture du nombre
if (ParaGlob::NiveauImpression() >= 5) cout << domEsclave << endl;
if ((domEsclave <1) || (domEsclave > nbMaillageTotal))
// domEsclave doit etre > 0 et < nbMaillageTotal, s'il = nbMaillageTotal
// on n'a aucun maillage maitre -> pb, sauf s'il y a de l'auto contact, c'est géré par le contact
{ cout << "\n le nombre de maillage esclave lu : " << domEsclave
<< ", n\'est pas acceptable, (nbMaillageTotal = " << nbMaillageTotal << " )"
<< endl;
entreePrinc->MessageBuffer("** lecture des domaines esclaves **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
entreePrinc->NouvelleDonnee(); // positionnement sur une nouvelle info
};
// // --- vérification obsolète mais que l'on conserve pour l'instant
// if ((paraGlob->TypeCalcul() == NON_DYNA_CONT) && (domEsclave < 1))
// { cout << "\n erreur, le type de calcul : NON_DYNA_CONT necessite d\'avoir plusieurs"
// << " maillages et de savoir le nombre de domaine esclave !! "
// << "\n LesMaillages::LectureLesMaillages() " << endl;
// entreePrinc->MessageBuffer("** lecture des domaines esclaves **");
// throw (UtilLecture::ErrNouvelleDonnee(-1));
// Sortie(1);
// };
// --- on vérifie que les références sont correctes
const Reference* refG = lesRef->Init_et_Premiere();
while (refG != NULL)
{ // on définit la référence réelle
// et on voit s'il n'y a pas d'erreur lorsque l'on essaie d'utiliser la référence
// 1- cas des noeuds
if ( refG->Indic() == 1)
{ const ReferenceNE & ref = (ReferenceNE &) (*refG);
int ref_Taille=ref.Taille();
for (int j= 1; j<= ref_Taille; j++)
{int nb = ref.Numero(j) ; // le numero du dans le maillage
int nn = ref.Nbmaille(); // le numero du maillage
// on tente de récupérer le noeud, ce qui permet de vérifier son existence
try {Noeud& toto = Noeud_LesMaille(nn,nb);}
// si le noeud n'existe pas il y a une erreur qui est récupérer
catch (ErrSortie erreur)
{ // cas d'un noeud n'existant pas
cout << "\n erreur dans la verification de la liste : " ;
ref.Affiche();
cout << "\n peut-etre que le noeud nb : " << nb << " du maillage : " << nn
<< " n'existe pas ? " << endl;
Sortie(-1); // on force la sortie
};
};
};
// 2- cas des éléments
if ( refG->Indic() == 2)
{ const ReferenceNE & ref = (ReferenceNE &) (*refG);
int ref_Taille=ref.Taille();
for (int j= 1; j<= ref_Taille; j++)
{int nb = ref.Numero(j) ; // le numero de l'element dans le maillage
int nn = ref.Nbmaille(); // le numero du maillage
// on tente de récupérer l'élément, ce qui permet de vérifier son existence
try {Element& toto = Element_LesMaille(nn,nb);}
// si l'élément n'existe pas il y a une erreur qui est récupérer
catch (ErrSortie erreur)
{ // cas d'un élément n'existant pas
cout << "\n erreur dans la verification de la liste : " ;
ref.Affiche();
cout << "\n peut-etre que l'element nb : " << nb << " du maillage : " << nn
<< " n'existe pas ? " << endl;
Sortie(-1); // on force la sortie
};
};
};
// 3- cas des faces ou des arrêtes
if (( refG->Indic() == 3) || ( refG->Indic() == 4))
{ const ReferenceAF & ref = (ReferenceAF &) (*refG);
int ref_Taille=ref.Taille();
for (int j= 1; j<= ref_Taille; j++)
{int nb = ref.NumeroElem(j) ; // le numero de l'element dans le maillage
int nn = ref.Nbmaille(); // le numero du maillage
// on tente de récupérer l'élément, ce qui permet de vérifier son existence
try {Element& toto = Element_LesMaille(nn,nb);}
// si l'élément n'existe pas il y a une erreur qui est récupérer
catch (ErrSortie erreur)
{ // cas d'un élément n'existant pas
cout << "\n erreur dans la verification de la liste : " ;
ref.Affiche();
cout << "\n peut-etre que l'element nb : " << nb << " du maillage : " << nn
<< " n'existe pas ? " << endl;
Sortie(-1); // on force la sortie
};
};
};
refG = lesRef->Reference_suivante();
};
// on s'occupe de mettre à jour les types de pb et les ddl types associés
Mise_a_jour_type_pb_type_associe_ddl();
if (ParaGlob::NiveauImpression() >= 4)
cout << " fin de la lecture des maillages " << endl;
};
// affichage et definition interactive des commandes
void LesMaillages::Info_commande_lesMaillages()
{ // def des maillages
// int lectureEnCour = 0;
// def d'un premier maillage
tabMaillage(1) = new Maillage (mapNomMail,1,paraGlob->Dimension());
cout << "\n# ----- definition des maillages ----- ";
cout << "\n# def des fichiers de maillage ";
string rep="_";
if (rep != "f")
{ofstream & sort = *(entreePrinc->Commande_pointInfo()); // pour simplifier
sort << "\n#--------------------------------------"
<< "\n#| definition du (ou des) maillage(s) |"
<< "\n#--------------------------------------";
cout << "\n dans le fichier de commande final, on utilisera de preference une inclusion "
<< "\n d'un fichier qui contiendra le maillage (ou plusieurs fichiers pour plusieurs maillages\n";
while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
{
try
{ cout
<< "\n (0 ou f) (fin) "
<< "\n (1) (defaut) inclusion de fichier et affinage "
<< "\n (2) fusion des deux precedents maillages "
// << "\n (3) renumerotation de tous les maillages "
// << "\n (4 ou ? ) exemple - informations sur fichier ! "
<< "\n (3 ou ? ) exemple - informations sur fichier ! "
<< "\n ";
if (rep != "f")
rep = lect_return_defaut(false,"1");
if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie directe
break;
int num = ChangeEntier(rep);
if (Minuscules(rep) == "?")
num = 3; //4;
bool choix_valide=false;
if ((num >= 0)&&(num<=3))
{ choix_valide=true; }
else { cout << "\n Erreur on attendait un entier entre 0 et 3 !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour arreter le programme";
choix_valide=false;
}
switch (num)
{ case 0: // sortie
{ break;} // normalement cela a déjà été filtré avant
case 1: // inclusion de fichier et affinage
{ string repi;
while (Minuscules(repi) != "f")
{// indique que les prochaines references seront pour le maillage 1, systématiquement
lesRef->NbMaille(1); int cas = 1;
tabMaillage(1)->Info_commande_Maillages(entreePrinc,*lesRef, cas);
nbMaillageTotal = 1 ;
cout << "\n autre fichier ou fin (rep o ou f) ";
repi = lect_return_defaut(false,"f");
};
sort << "\n \n ";
break;
}
case 2: // fusion des deux precedents maillages
{ sort << "\n fusion_avec_le_maillage_precedent_ ";
int cas = 3; // on rappelle l'affinage en fin de maillage
tabMaillage(1)->Info_commande_Maillages(entreePrinc,*lesRef, cas);
break;}
// case 3: // renumerotation de tous les maillages
// { sort << "\n renumerotation_tous_maillages_ ";
// break;}
case 3: // exemple - informations sur fichier
{ cout << "\n on se reportera a la documentation pour une information precise "
<< " ici il y a sortie sur le fichier .info d'exemple et d'infos succintes ";
sort << "\n# exemples: tout d'abord l'inclusion, "
<< "\n# 2 solutions equivalentes : soit deux fichiers par maillage -> exemple"
<< "\n# < nom_de_maillage.her # fichier qui contiend le maillage"
<< "\n# < nom_de_maillage.lis # fichier qui contiend les references "
<< "\n# soit un seul fichier par maillage -> exemple"
<< "\n# < nom_de_maillage.her # fichier qui contiend le maillage"
<< "\n \n# maintenant on presente un exemple de contenu de mailage correspondant aux choix propose"
<< "\n#------------------------------ exemple de contenu maillage -----------------";
// indique que les prochaines references seront pour le maillage 1
lesRef->NbMaille(1);int cas = 2;
tabMaillage(1)->Info_commande_Maillages(entreePrinc,*lesRef, cas);
nbMaillageTotal = 1 ;
sort << "\n#-------------------------- fin exemple de contenu maillage -----------------\n \n ";
break;
};
default:
cout << "\n le cas "<<rep<<" n'est pas traite !!, bizarre, il faut se plaindre !! ";
};
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch (...)//(UtilLecture::ErrNouvelleDonnee erreur)
{ cout << "\n Erreur on attendait un des mots cles proposes !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour sortir ";
};
}; //-- fin du while
// --- domaines esclaves éventuelles
cout << "\n def d'un nombre de domaine(s) esclave(s) rep: o ou n (defaut) ? ";
rep = lect_return_defaut(false,"n");
if (Minuscules(rep) == "o")
{int nb=0;
cout << "\n nombre ? (un entier) ";
nb= (int) lect_double();
sort << "\n\n domaine_esclave "
<< "\n#--------------------------------------------------------------------"
<< "\n# definition du nombre de domaine esclave |"
<< "\n#--------------------------------------------------------------------\n"
<< nb << " ";
};
sort << flush;
};
};
// affiche sur la sortie standard les differents maillage
void LesMaillages::Affiche () const
{ cout << '\n'<< '\n'
<< " --------- CAS des maillages ---------" << '\n' << '\n'; // en tete
cout << '\n'<< "il y a " << nbMaillageTotal << " maillages " << '\n' ;
for (int i = 1; i<= nbMaillageTotal; i++)
{ cout << " *** maillage numero = " << i << '\n';
(tabMaillage(i))->Affiche();
// pas d'affichage des types de calcul car c'est déjà dans chaque maillage
}
// ----- cas des grandeurs intégrés éventuelles-----
cout << "\n\n int_vol_mail ";
int integ_vol_typeQuel_taille = integ_vol_typeQuel.Taille();
if (integ_vol_typeQuel_taille == 0) cout << 0; else cout << integ_vol_typeQuel_taille;
cout << " ";
for (int i=1;i<= integ_vol_typeQuel_taille;i++)
cout << "\n" << integ_vol_typeQuel_t(i) ;
cout << "\n int_vol_temps_mail ";
int integ_vol_t_typeQuel_taille = integ_vol_t_typeQuel.Taille();
if (integ_vol_t_typeQuel_taille == 0) cout << 0; else cout <<integ_vol_t_typeQuel_taille;
cout << " ";
for (int i=1;i<= integ_vol_t_typeQuel_taille;i++)
cout << "\n" << integ_vol_t_typeQuel_t(i);
// ----- cas des statistiques éventuelles-----
cout << "\n\n statistique_mail ";
int statistique_typeQuel_taille = statistique_typeQuel.Taille();
if (statistique_typeQuel_taille == 0) cout << 0; else cout << statistique_typeQuel_taille;
cout << " ";
for (int i=1;i<= statistique_typeQuel_taille;i++)
cout << "\n" << statistique_typeQuel_t(i) ;
cout << "\n statistique_temps_mail ";
int statistique_t_typeQuel_taille = statistique_t_typeQuel.Taille();
if (statistique_t_typeQuel_taille == 0) cout << 0; else cout <<statistique_t_typeQuel_taille;
cout << " ";
for (int i=1;i<= statistique_t_typeQuel_taille;i++)
cout << "\n" << statistique_t_typeQuel_t(i);
cout << '\n' << "-------- fin des maillages ------" << '\n';
};
// Affiche les donnees du maillage dans le fichier de nom nom_fichier
// au format du fichier ".her"
void LesMaillages::Affiche (char* ) const
{ };
// test si toutes les informations des maillages sont completes
// = true -> complet
// = false -> incomplet
bool LesMaillages::Complet()
{ bool res = true;
for ( int i=1; i<= nbMaillageTotal;i++)
res = res && tabMaillage(i)->Complet();
return res;
};
// introduction des lois de comportement dans les elements qui le necessite
// des sections pour les poutres etc c-a-d , completer les elements
// avec les donnees qui ont ete acquises apres la lecture du maillage
// def des tableaux de ddl dans les noeuds
// def des pointeurs d'assemblage dans les noeuds
void LesMaillages::Completer(DiversStockage* divers,LesLoisDeComp* lesLois
,LesFonctions_nD* lesFonctionsnD )
{
// cas des dilatations thermiques
int divers_TabDila_Taille=divers->TabCoefDila().Taille();
for (int ii=1;ii<= divers_TabDila_Taille;ii++)
{ string nomDila = (divers->TabCoefDila())(ii).NomRef(); // recup du nom de la ref
const BlocDdlLim<BlocScal_ou_fctnD>& div_Dila = (divers->TabCoefDila())(ii);
// soit c'est une valeur fixe soit une fonction nD
double val = 0; // init par défaut
string nom_fct_nD("_"); // ""
if (div_Dila.Val() != NULL) // cas d'une valeur fixe
{ val = *(div_Dila.Val());} // recup de la valeur
else if (div_Dila.Fct_nD() != NULL) // cas d'une fonction nD
{ nom_fct_nD = *(div_Dila.Fct_nD());}
else // sinon il y a un pb
{ cout << "\n *** erreur de definition de la dilatation les infos lues ne sont pas correctes: ";
div_Dila.Affiche();
Sortie(1);
};
const Reference & refG = lesRef->Trouve(nomDila,div_Dila.NomMaillage()); // recup de la reference
// vérif que la référence s'adresse à des éléments
if ( refG.Indic() != 2)
{ // erreur la référence ne concerne pas des éléments
cout << "\n erreur la reference " << refG.Nom() << " ne concerne pas des elements ";
cout << " \n cas des donnees relatives aux masses volumiques ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
const ReferenceNE & ref = (ReferenceNE &) refG;
int ref_Taille=ref.Taille();
for (int jj= 1; jj<= ref_Taille; jj++)
{int nbb = ref.Numero(jj) ; // le numero de l'element dans le maillage
int nnn = ref.Nbmaille(); // le numero du maillage
// recup de l'element
Element * poi = & Element_LesMaille(nnn,nbb);
// creation d'un bloc general contenant des informations
BlocGen bloc(2,1);
bloc.Change_nom(1,"dilatation_thermique");
bloc.Change_nom(2,nom_fct_nD); // s'il contient "_" cela veut dire : pas de fctnD
bloc.Change_val(1, val);
// demande a l'element de se completer
poi = poi->Complete(bloc,lesFonctionsnD);
if (poi == NULL)
{ // cas d'un probleme
cout << "\n erreur la dilatation thermique n'est pas adapte a l\'element ";
poi = & Element_LesMaille(nnn,nbb);
cout << "\n element " << poi->Geometrie() << poi->Interpolation();
cout << "\n LesMaillages::Completer( etc ... " << endl;
Sortie(1);
};
}
};
// cas des lois de comportement
int lesLois_TabRefLoi_Taille = lesLois->TabRefLoi().Taille();
for (int i=1;i<= lesLois_TabRefLoi_Taille;i++)
{ string nomLoi = (lesLois->TabRefLoi())(i).st2;
// recup de la reference
const LesLoisDeComp::RefLoi & refloi = (lesLois->TabRefLoi())(i); // ref de loi
const Reference& refG = lesRef->Trouve(refloi.st1,(refloi.nom_maillage));
// vérif que la référence s'adresse à des éléments
if ( refG.Indic() != 2)
{ // erreur la référence ne concerne pas des éléments
cout << "\n erreur la reference " << refG.Nom() << " ne concerne pas des elements ";
cout << " \n cas des donnees relatives aux lois de comportement ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
const ReferenceNE & ref = (ReferenceNE &) refG;
int ref_Taille=ref.Taille();
for (int j= 1; j<= ref_Taille; j++)
{int nb = ref.Numero(j) ; // le numero de l'element dans le maillage
int nn = ref.Nbmaille(); // le numero du maillage
// le pointeur le loi
LoiAbstraiteGeneral * pt = lesLois->PtLoi_abstraite(nomLoi);
if (pt == NULL)
{ // cas d'un pointeur en retour null, la loi n'existe pas
cout << "\n *** erreur en lecture: la loi de nom : " << nomLoi
<< " n'existe pas !! revoyez vos donnees ";
if (ParaGlob::NiveauImpression() > 5)
cout << "\n LesMaillages::Completer( ... ";
Sortie(1);
}
// attribution du pointeur
Element_LesMaille(nn,nb).DefLoi(pt);
}
}
// cas des sections d' elements
int divers_TabSect_Taille=divers->TabSect().Taille();
for (int ii=1;ii<= divers_TabSect_Taille;ii++)
{ //string nomSect = (divers->TabSect())(ii).nomref; // recup du nom de la ref
string nomSect = (divers->TabSect())(ii).NomRef(); // recup du nom de la ref
//double val = (divers->TabSect())(ii).val; // recup de la valeur
const BlocDdlLim<BlocScal_ou_fctnD>& div_sect = (divers->TabSect())(ii);
// soit c'est une valeur fixe soit une fonction nD
double val = 0; // init par défaut
string nom_fct_nD("_"); // ""
if (div_sect.Val() != NULL) // cas d'une valeur fixe
{ val = *(div_sect.Val());} // recup de la valeur
else if (div_sect.Fct_nD() != NULL) // cas d'une fonction nD
{ nom_fct_nD = *(div_sect.Fct_nD());}
else // sinon il y a un pb
{ cout << "\n *** erreur de definition de la section les infos lues ne sont pas correctes: ";
div_sect.Affiche();
Sortie(1);
};
const Reference & refG = lesRef->Trouve(nomSect,div_sect.NomMaillage()); // recup de la reference
// vérif que la référence s'adresse à des éléments
if ( refG.Indic() != 2)
{ // erreur la référence ne concerne pas des éléments
cout << "\n erreur la reference " << refG.Nom() << " ne concerne pas des elements ";
cout << " \n cas des donnees relatives aux sections ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
const ReferenceNE & ref = (ReferenceNE &) refG;
int ref_Taille=ref.Taille();
for (int jj= 1; jj<= ref_Taille; jj++)
{int nbb = ref.Numero(jj) ; // le numero de l'element dans le maillage
int nnn = ref.Nbmaille(); // le numero du maillage
// recup de l'element
Element * poi = & Element_LesMaille(nnn,nbb);
// creation d'un bloc general contenant des informations
BlocGen bloc(2,1);
bloc.Change_nom(1,"sections");
bloc.Change_nom(2,nom_fct_nD); // s'il contient "_" cela veut dire : pas de fctnD
bloc.Change_val(1, val);
// demande a l'element de se completer
poi = poi->Complete(bloc,lesFonctionsnD);
if (poi == NULL)
{ // cas d'un probleme
cout << "\n erreur la section n'est pas adapte a l\'element ";
poi = & Element_LesMaille(nnn,nbb);
cout << "\n element " << poi->Geometrie() << poi->Interpolation();
cout << "\n LesMaillages::Completer( etc ... " << endl;
Sortie(1);
};
}
}
// cas des variation de section d' elements
int divers_TabVarSect_Taille=divers->TabVarSect().Taille();
for (int ii=1;ii<= divers_TabVarSect_Taille;ii++)
{ string nomVarSect = (divers->TabVarSect())(ii).NomRef(); // recup du nom de la ref
const BlocDdlLim<BlocScal>& div_varsect = (divers->TabVarSect())(ii);
double val = div_varsect.Val(); // recup de la valeur
const Reference & refG = lesRef->Trouve(nomVarSect,div_varsect.NomMaillage()); // recup de la reference
// vérif que la référence s'adresse à des éléments
if ( refG.Indic() != 2)
{ // erreur la référence ne concerne pas des éléments
cout << "\n erreur la reference " << refG.Nom() << " ne concerne pas des elements ";
cout << " \n cas des donnees relatives aux variations de sections ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
const ReferenceNE & ref = (ReferenceNE &) refG;
int ref_Taille=ref.Taille();
for (int jj= 1; jj<= ref_Taille; jj++)
{int nbb = ref.Numero(jj) ; // le numero de l'element dans le maillage
int nnn = ref.Nbmaille(); // le numero du maillage
// recup de l'element
Element * poi = & Element_LesMaille(nnn,nbb);
// creation d'un bloc general contenant des informations
BlocGen bloc(1,1);
bloc.Change_nom(1,"variation_section");
bloc.Change_val(1, val);
// demande a l'element de se completer
poi = poi->Complete(bloc,lesFonctionsnD);
if (poi == NULL)
{ // cas d'un probleme
cout << "\n erreur la variation de section n'est pas adapte a l\'element ";
poi = & Element_LesMaille(nnn,nbb);
cout << "\n element " << poi->Geometrie() <<" "<< poi->Interpolation()<<" "<<poi->TypeProblem();
cout << "\n LesMaillages::Completer( etc ... " << endl;
Sortie(1);
}
}
};
// cas des epaisseurs d' elements
int divers_TabEpaiss_Taille=divers->TabEpaiss().Taille();
for (int ii=1;ii<= divers_TabEpaiss_Taille;ii++)
{ string nomSect = (divers->TabEpaiss())(ii).NomRef(); // recup du nom de la ref
const BlocDdlLim<BlocScal_ou_fctnD>& div_epai = (divers->TabEpaiss())(ii);
// soit c'est une valeur fixe soit une fonction nD
double val = 0; // init par défaut
string nom_fct_nD("_"); // ""
if (div_epai.Val() != NULL) // cas d'une valeur fixe
{ val = *(div_epai.Val());} // recup de la valeur
else if (div_epai.Fct_nD() != NULL) // cas d'une fonction nD
{ nom_fct_nD = *(div_epai.Fct_nD());}
else // sinon il y a un pb
{ cout << "\n *** erreur de definition de l'epaisseur les infos lues ne sont pas correctes: ";
div_epai.Affiche();
Sortie(1);
};
const Reference& refG = lesRef->Trouve(nomSect,div_epai.NomMaillage()); // recup de la reference
// vérif que la référence s'adresse à des éléments
if ( refG.Indic() != 2)
{ // erreur la référence ne concerne pas des éléments
cout << "\n erreur la référence " << refG.Nom() << " ne concerne pas des éléments ";
cout << " \n cas des données relatives aux épaisseurs d'éléments ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
const ReferenceNE & ref = (ReferenceNE &) refG;
int ref_Taille=ref.Taille();
for (int jj= 1; jj<= ref_Taille; jj++)
{int nbb = ref.Numero(jj) ; // le numero de l'element dans le maillage
int nnn = ref.Nbmaille(); // le numero du maillage
// recup de l'element
Element * poi = & Element_LesMaille(nnn,nbb);
// creation d'un bloc general contenant des informations
BlocGen bloc(2,1);
bloc.Change_nom(1,"epaisseurs");
bloc.Change_nom(2,nom_fct_nD); // s'il contient "_" cela veut dire : pas de fctnD
bloc.Change_val(1, val);
// demande a l'element de se completer
poi = poi->Complete(bloc,lesFonctionsnD);
if (poi == NULL)
{ // cas d'un probleme
cout << "\n erreur l\'epaisseur n'est pas adapte a l\'element ";
poi = & Element_LesMaille(nnn,nbb);
cout << "\n element " << poi->Geometrie() << poi->Interpolation();
cout << "\n LesMaillages::Completer( etc ... " << endl;
Sortie(1);
};
}
}
// cas des largeurs d' elements
int divers_TabLargeurs_Taille=divers->TabLargeurs().Taille();
for (int ii=1;ii<= divers_TabLargeurs_Taille;ii++)
{ string nomSect = (divers->TabLargeurs())(ii).NomRef(); // recup du nom de la ref
const BlocDdlLim<BlocScal_ou_fctnD>& div_larg = (divers->TabLargeurs())(ii);
// soit c'est une valeur fixe soit une fonction nD
double val = 0; // init par défaut
string nom_fct_nD("_"); // ""
if (div_larg.Val() != NULL) // cas d'une valeur fixe
{ val = *(div_larg.Val());} // recup de la valeur
else if (div_larg.Fct_nD() != NULL) // cas d'une fonction nD
{ nom_fct_nD = *(div_larg.Fct_nD());}
else // sinon il y a un pb
{ cout << "\n *** erreur de definition de la largeur les infos lues ne sont pas correctes: ";
div_larg.Affiche();
Sortie(1);
};
const Reference& refG = lesRef->Trouve(nomSect,div_larg.NomMaillage()); // recup de la reference
// vérif que la référence s'adresse à des éléments
if ( refG.Indic() != 2)
{ // erreur la référence ne concerne pas des éléments
cout << "\n erreur la référence " << refG.Nom() << " ne concerne pas des éléments ";
cout << " \n cas des données relatives aux largeurs d'éléments ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
const ReferenceNE & ref = (ReferenceNE &) refG;
int ref_Taille=ref.Taille();
for (int jj= 1; jj<= ref_Taille; jj++)
{int nbb = ref.Numero(jj) ; // le numero de l'element dans le maillage
int nnn = ref.Nbmaille(); // le numero du maillage
// recup de l'element
Element * poi = & Element_LesMaille(nnn,nbb);
// creation d'un bloc general contenant des informations
BlocGen bloc(2,1);
bloc.Change_nom(2,nom_fct_nD); // s'il contient "_" cela veut dire : pas de fctnD
bloc.Change_nom(1,"largeurs");
bloc.Change_val(1, val);
// demande a l'element de se completer
poi = poi->Complete(bloc,lesFonctionsnD);
if (poi == NULL)
{ // cas d'un probleme
cout << "\n erreur la largeur n'est pas adapte a l\'element ";
poi = & Element_LesMaille(nnn,nbb);
cout << "\n element " << poi->Geometrie() << poi->Interpolation();
cout << "\n LesMaillages::Completer( etc ... " << endl;
Sortie(1);
};
}
}
// cas des masses volumique d' elements
int divers_TabMasseVolu_Taille=divers->TabMasseVolu().Taille();
for (int ii=1;ii<= divers_TabMasseVolu_Taille;ii++)
{ string nomMasseVol = (divers->TabMasseVolu())(ii).NomRef(); // recup du nom de la ref
const BlocDdlLim<BlocScal_ou_fctnD>& div_massevolu = (divers->TabMasseVolu())(ii);
// soit c'est une valeur fixe soit une fonction nD
double val = 0; // init par défaut
string nom_fct_nD("_"); // ""
if (div_massevolu.Val() != NULL) // cas d'une valeur fixe
{ val = *(div_massevolu.Val());} // recup de la valeur
else if (div_massevolu.Fct_nD() != NULL) // cas d'une fonction nD
{ nom_fct_nD = *(div_massevolu.Fct_nD());}
else // sinon il y a un pb
{ cout << "\n *** erreur de definition de la masse volumique les infos lues ne sont pas correctes: ";
div_massevolu.Affiche();
Sortie(1);
};
const Reference & refG = lesRef->Trouve(nomMasseVol,div_massevolu.NomMaillage()); // recup de la reference
// vérif que la référence s'adresse à des éléments
if ( refG.Indic() != 2)
{ // erreur la référence ne concerne pas des éléments
cout << "\n erreur la référence " << refG.Nom() << " ne concerne pas des éléments ";
cout << " \n cas des données relatives aux masses volumiques ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
const ReferenceNE & ref = (ReferenceNE &) refG;
int ref_Taille=ref.Taille();
for (int jj= 1; jj<= ref_Taille; jj++)
{int nbb = ref.Numero(jj) ; // le numero de l'element dans le maillage
int nnn = ref.Nbmaille(); // le numero du maillage
// recup de l'element
Element * poi = & Element_LesMaille(nnn,nbb);
// creation d'un bloc general contenant des informations
BlocGen bloc(2,1);
bloc.Change_nom(1,"masse_volumique");
bloc.Change_nom(2,nom_fct_nD); // s'il contient "_" cela veut dire : pas de fctnD
bloc.Change_val(1, val);
// demande a l'element de se completer
poi = poi->Complete(bloc,lesFonctionsnD);
if (poi == NULL)
{ // cas d'un probleme
cout << "\n erreur la masse volumique n'est pas adapte a l\'element ";
poi = & Element_LesMaille(nnn,nbb);
cout << "\n element " << poi->Geometrie() << poi->Interpolation();
cout << "\n LesMaillages::Completer( etc ... " << endl;
Sortie(1);
};
}
}
// cas des gestions d'hourglass d'elements
int divers_TabGesHourglass_Taille=divers->TabGesHourglass().Taille();
for (int ii=1;ii<= divers_TabGesHourglass_Taille;ii++)
{ string nomGesHourglass = (divers->TabGesHourglass())(ii).NomRef(); // recup du nom de la ref
const BlocDdlLim<BlocGen_3_1>& div_GesHourglass = (divers->TabGesHourglass())(ii);
// double val = div_GesHourglass.Val(); // recup de la valeur
const Reference & refG = lesRef->Trouve(nomGesHourglass,div_GesHourglass.NomMaillage()); // recup de la reference
// vérif que la référence s'adresse à des éléments
if ( refG.Indic() != 2)
{ // erreur la référence ne concerne pas des éléments
cout << "\n erreur la référence " << refG.Nom() << " ne concerne pas des éléments ";
cout << " \n cas des données relatives aux gestions des modes d'hourglass ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
const ReferenceNE & ref = (ReferenceNE &) refG;
int ref_Taille=ref.Taille();
for (int jj= 1; jj<= ref_Taille; jj++)
{int nbb = ref.Numero(jj) ; // le numero de l'element dans le maillage
int nnn = ref.Nbmaille(); // le numero du maillage
// recup de l'element
Element * poi = & Element_LesMaille(nnn,nbb);
// creation d'un bloc general contenant des informations
BlocGen bloc(1,2);
bloc.Change_nom(1,div_GesHourglass.Nom(2));
bloc.Change_val(1, div_GesHourglass.Val(1));
// récupération éventuelle de la loi si besoin
LoiAbstraiteGeneral * loiHourglass = NULL;
if ( (Id_Nom_StabHourglass(div_GesHourglass.Nom(2).c_str()) == STABHOURGLASS_PAR_COMPORTEMENT)
|| (Id_Nom_StabHourglass(div_GesHourglass.Nom(2).c_str()) == STABHOURGLASS_PAR_COMPORTEMENT_REDUIT))
// le pointeur le loi
{ loiHourglass = lesLois->PtLoi_abstraite(div_GesHourglass.Nom(3));};
// demande a l'element de se completer
poi = poi->Complet_Hourglass(loiHourglass,bloc);
if (poi == NULL)
{ // cas d'un probleme
cout << "\n erreur la gestion d'hourglass: " << div_GesHourglass << " n'est pas adapte a l\'element ";
poi = & Element_LesMaille(nnn,nbb);
cout << "\n element " << poi->Geometrie() << poi->Interpolation();
cout << "\n LesMaillages::Completer( etc ... " << endl;
Sortie(1);
}
};
};
// cas des intégrales sur le volume
int divers_TabIntegVol_Taille=divers->TabIntegVol().Taille();
// on redimentionne les tableaux de sauvegardes
integ_vol_typeQuel.Change_taille(divers_TabIntegVol_Taille);
integ_vol_typeQuel_t.Change_taille(divers_TabIntegVol_Taille);
ref_integ_vol.Change_taille(divers_TabIntegVol_Taille);
for (int ii=1;ii<= divers_TabIntegVol_Taille;ii++)
{ string nomIntegVol = (divers->TabIntegVol())(ii).NomRef(); // recup du nom de la ref
const BlocDdlLim<BlocGen_3_0>& div_IntegVol = (divers->TabIntegVol())(ii);
const Reference & refG = lesRef->Trouve(nomIntegVol,div_IntegVol.NomMaillage()); // recup de la reference
// vérif que la référence s'adresse à des éléments
if ( refG.Indic() != 2)
{ // erreur la référence ne concerne pas des éléments
cout << "\n erreur la référence " << refG.Nom() << " ne concerne pas des éléments ";
cout << " \n cas des données relatives aux integrations sur le volume ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
const ReferenceNE & ref = (ReferenceNE &) refG;
// creation d'un bloc general contenant des informations
// n= nombre de string, m nombre de double
BlocGen bloc(4,1) ; // par defaut
////--- debug
//cout << "\n -- debug LesMaillages::Completer( ";
//div_IntegVol.Affiche(); cout << endl;
////--- fin debug
string nom_inter("integrale_sur_volume_");
bloc.Change_nom(1,nom_inter); // le type d'intégrale: de volume ici
bloc.Change_nom(2,div_IntegVol.Nom(2)); // mot clé : ex: un_ddl_etendu_
bloc.Change_nom(3,div_IntegVol.Nom(3)); // ex: le nom du ddl : ex UX
// construction d'un nom qui servira à discriminer les différents conteneurs
string nom_ref("int_vol_");// init
if ((div_IntegVol.NomMaillage() == NULL) // cas d'un seule maillage
&& (nbMaillageTotal==1)) // enregistré
{nom_ref +=(refG.Nom());}
else if (div_IntegVol.NomMaillage() != NULL) // cas de plusieurs maillages
{nom_ref += (*div_IntegVol.NomMaillage())+"_"+(refG.Nom());}
else // sinon pb
{ cout << "\n erreur il manque le nom de maillage alors qu'il y a plusieurs maillages en cours ";
cout << " \n cas des données relatives aux integrations sur le volume ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
bloc.Change_val(1,ii); // on indique le numéro du stockage global
// on commence par définir le conteneur global qui sera stocké dans LesMaillages
ref_integ_vol(ii) = &refG;
if (bloc.Nom(2) == "un_ddl_etendu_")
{ // il s'agit d'une intégrale d'un ddl étendu de nom: bloc.Nom(3)
nom_ref += "_ddl_etendu_"+bloc.Nom(3);
Ddl_etendu ddl(Ddl_enum_etendu(bloc.Nom(3))) ;// on crée un ddl ad hoc
Grandeur_Ddl_etendu grand_courant(ddl,nom_ref);// le conteneur ad hoc
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(INTEG_SUR_VOLUME,nom_ref,SCALAIRE_DOUBLE);
// TypeQuelconque typQ(INTEG_SUR_VOLUME,EPS11,grand_courant);
TypeQuelconque typQ(enuType,EPS11,grand_courant);
integ_vol_typeQuel(ii) = (typQ);
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ,nom_ref);
// idem pour la grandeur à t
string nom_ref_t = nom_ref + "_t_";
Ddl_etendu ddl_t(Ddl_enum_etendu(bloc.Nom(3))) ;// on crée un ddl ad hoc
Grandeur_Ddl_etendu grand_courant_t(ddl_t,nom_ref_t);// le conteneur ad hoc
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType_t =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(INTEG_SUR_VOLUME,nom_ref_t,SCALAIRE_DOUBLE);
// TypeQuelconque typQ_t(INTEG_SUR_VOLUME,EPS11,grand_courant_t);
TypeQuelconque typQ_t(enuType_t,EPS11,grand_courant_t);
integ_vol_typeQuel_t(ii) = (typQ_t);
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ_t,nom_ref_t);
}
else if (bloc.Nom(2) == "une_fonction_nD_")
{ // il s'agit d'une intégrale d'une fonction nD de nom: bloc.Nom(3)
nom_ref += "_fct_nD_"+bloc.Nom(3);
// on récupère le pointeur de fonction correspondant:
Fonction_nD * fct = lesFonctionsnD->Trouve(bloc.Nom(3));
int nb_composante = fct->NbComposante();
Grandeur_Vecteur_Nommer grand_courant(nom_ref,nb_composante,fct);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(INTEG_SUR_VOLUME,nom_ref,VECTEUR);
// TypeQuelconque typQ(INTEG_SUR_VOLUME,EPS11,grand_courant);
TypeQuelconque typQ(enuType,EPS11,grand_courant);
integ_vol_typeQuel(ii) = (typQ);
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ,nom_ref);
// idem pour la grandeur à t
string nom_ref_t = nom_ref + "_t_";
Grandeur_Vecteur_Nommer grand_courant_t(nom_ref_t,nb_composante,fct);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType_t =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(INTEG_SUR_VOLUME,nom_ref_t,VECTEUR);
// TypeQuelconque typQ_t(INTEG_SUR_VOLUME,EPS11,grand_courant_t);
TypeQuelconque typQ_t(enuType_t,EPS11,grand_courant_t);
integ_vol_typeQuel_t(ii) = (typQ_t);
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ_t,nom_ref_t);
////--- debug
//cout << "\n -- debug LesMaillages::Completer( ";
//if (nom_ref_t == "int_vol_E_tout_fct_nD_fct1_t_")
// { const void* pointe = (ParaGlob::param->GrandeurGlobal(nom_ref_t));
// TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
// cout << "\n gr_quelc= "<< (*gr_quelc) << endl;
// Grandeur_Vecteur_Nommer& gr = *((Grandeur_Vecteur_Nommer*) gr_quelc->Grandeur_pointee()); // pour simplifier
// cout << "\n gr.NbMaxiNumeroOrdre()= "<<gr.NbMaxiNumeroOrdre() << endl;
// }
////cout << "\n (typQ_t)= "<<(typQ_t) << " nom_ref_t= "<<nom_ref_t << endl;
// cout << endl;
////--- fin debug
};
bloc.Change_nom(4,nom_ref); // on indique le nom de référencement global
////--- debug
//cout << "\n -- debug LesMaillages::Completer( ";
//bloc.Affiche(); cout << endl;
////--- fin debug
// puis on alimente les éléments concernés par ces calculs
int ref_Taille=ref.Taille();
for (int jj= 1; jj<= ref_Taille; jj++)
{int nbb = ref.Numero(jj) ; // le numero de l'element dans le maillage
int nnn = ref.Nbmaille(); // le numero du maillage
// recup de l'element
Element * poi = & Element_LesMaille(nnn,nbb);
// demande a l'element de se completer
poi = poi->Complete(bloc,lesFonctionsnD);
if (poi == NULL)
{ // cas d'un probleme
cout << "\n erreur l'integration de ";bloc.Affiche();
cout << " n'est pas adapte a l\'element ";
poi = & Element_LesMaille(nnn,nbb);
cout << "\n element " << poi->Geometrie() << poi->Interpolation();
cout << "\n LesMaillages::Completer( etc ... " << endl;
Sortie(1);
};
};
ref_integ_vol(ii)= &refG; // sauvegarde
};
// cas des intégrales sur le volume et le temps
int divers_TtabIntegVol_et_temps_Taille=divers->TtabIntegVol_et_temps().Taille();
// on redimentionne les tableaux de sauvegardes
integ_vol_t_typeQuel.Change_taille(divers_TtabIntegVol_et_temps_Taille);
integ_vol_t_typeQuel_t.Change_taille(divers_TtabIntegVol_et_temps_Taille);
ref_integ_vol_t.Change_taille(divers_TtabIntegVol_et_temps_Taille);
for (int ii=1;ii<= divers_TtabIntegVol_et_temps_Taille;ii++)
{ string nomIntegVol = (divers->TtabIntegVol_et_temps())(ii).NomRef(); // recup du nom de la ref
const BlocDdlLim<BlocGen_3_0>& div_IntegVol = (divers->TtabIntegVol_et_temps())(ii);
const Reference & refG = lesRef->Trouve(nomIntegVol,div_IntegVol.NomMaillage()); // recup de la reference
// vérif que la référence s'adresse à des éléments
if ( refG.Indic() != 2)
{ // erreur la référence ne concerne pas des éléments
cout << "\n erreur la référence " << refG.Nom() << " ne concerne pas des éléments ";
cout << " \n cas des données relatives aux integrations sur le volume et le temps ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
const ReferenceNE & ref = (ReferenceNE &) refG;
int ref_Taille=ref.Taille();
// creation d'un bloc general contenant des informations
// n= nombre de string, m nombre de double
BlocGen bloc(4,1) ; // par defaut
string nom_inter("integrale_sur_vol_et_temps_");
bloc.Change_nom(1,nom_inter); // le type d'intégrale: de volume ici
bloc.Change_nom(2,div_IntegVol.Nom(2));
bloc.Change_nom(3,div_IntegVol.Nom(3));
// construction d'un nom qui servira à discriminer les différents conteneurs
string nom_ref("int_vol_temps_");// init
if ((div_IntegVol.NomMaillage() == NULL) // cas d'un seule maillage
&& (nbMaillageTotal==1)) // enregistré
{nom_ref +=(refG.Nom());}
else if (div_IntegVol.NomMaillage() != NULL) // cas de plusieurs maillages
{nom_ref += (*div_IntegVol.NomMaillage())+"_"+(refG.Nom());}
else // sinon pb
{ cout << "\n erreur il manque le nom de maillage alors qu'il y a plusieurs maillages en cours ";
cout << " \n cas des données relatives aux integrations sur le volume et le temps ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
bloc.Change_val(1,ii); // on indique le numéro du stockage global
// on commence par définir le conteneur global qui sera stocké dans LesMaillages
ref_integ_vol_t(ii) = &refG;
if (bloc.Nom(2) == "un_ddl_etendu_")
{ // il s'agit d'une intégrale d'un ddl étendu de nom: bloc.Nom(3)
nom_ref += "_ddl_etendu_"+bloc.Nom(3);
Ddl_etendu ddl(Ddl_enum_etendu(bloc.Nom(3))) ;// on crée un ddl ad hoc
Grandeur_Ddl_etendu grand_courant(ddl,nom_ref);// le conteneur ad hoc
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(INTEG_SUR_VOLUME_ET_TEMPS,nom_ref,SCALAIRE_DOUBLE);
// TypeQuelconque typQ(INTEG_SUR_VOLUME_ET_TEMPS,EPS11,grand_courant);
TypeQuelconque typQ(enuType,EPS11,grand_courant);
integ_vol_t_typeQuel(ii) = (typQ);
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ,nom_ref);
// idem pour la grandeur à t
string nom_ref_t = nom_ref + "_t_";
Ddl_etendu ddl_t(Ddl_enum_etendu(bloc.Nom(3))) ;// on crée un ddl ad hoc
Grandeur_Ddl_etendu grand_courant_t(ddl,nom_ref_t);// le conteneur ad hoc
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType_t =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(INTEG_SUR_VOLUME_ET_TEMPS,nom_ref_t,SCALAIRE_DOUBLE);
// TypeQuelconque typQ_t(INTEG_SUR_VOLUME_ET_TEMPS,EPS11,grand_courant_t);
TypeQuelconque typQ_t(enuType_t,EPS11,grand_courant_t);
integ_vol_t_typeQuel_t(ii) = (typQ_t);
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ_t,nom_ref_t);
}
else if (bloc.Nom(2) == "une_fonction_nD_")
{ // il s'agit d'une intégrale d'une fonction nD de nom: bloc.Nom(3)
nom_ref += "_fct_nD_"+bloc.Nom(3);
// on récupère le pointeur de fonction correspondant:
Fonction_nD * fct = lesFonctionsnD->Trouve(bloc.Nom(3));
int nb_composante = fct->NbComposante();
Grandeur_Vecteur_Nommer grand_courant(nom_ref,nb_composante,fct);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(INTEG_SUR_VOLUME_ET_TEMPS,nom_ref,VECTEUR);
// TypeQuelconque typQ(INTEG_SUR_VOLUME_ET_TEMPS,EPS11,grand_courant);
TypeQuelconque typQ(enuType,EPS11,grand_courant);
integ_vol_t_typeQuel(ii) = (typQ);
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ,nom_ref);
// idem pour la grandeur à t
string nom_ref_t = nom_ref + "_t_";
Grandeur_Vecteur_Nommer grand_courant_t(nom_ref_t,nb_composante,fct);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType_t =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(INTEG_SUR_VOLUME_ET_TEMPS,nom_ref_t,VECTEUR);
// TypeQuelconque typQ_t(INTEG_SUR_VOLUME_ET_TEMPS,EPS11,grand_courant_t);
TypeQuelconque typQ_t(enuType_t,EPS11,grand_courant_t);
integ_vol_t_typeQuel_t(ii) = (typQ_t);
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ_t,nom_ref_t);
};
bloc.Change_nom(4,nom_ref); // on indique le nom de référencement global
// puis on alimente les éléments concernés par ces calculs
////--- debug
//cout << "\n -- debug LesMaillages::Completer( ";
//bloc.Affiche(); cout << endl;
////--- fin debug
for (int jj= 1; jj<= ref_Taille; jj++)
{int nbb = ref.Numero(jj) ; // le numero de l'element dans le maillage
int nnn = ref.Nbmaille(); // le numero du maillage
// recup de l'element
Element * poi = & Element_LesMaille(nnn,nbb);
// demande a l'element de se completer
poi = poi->Complete(bloc,lesFonctionsnD);
if (poi == NULL)
{ // cas d'un probleme
cout << "\n erreur l'integration de ";bloc.Affiche();
cout << " n'est pas adapte a l\'element ";
poi = & Element_LesMaille(nnn,nbb);
cout << "\n element " << poi->Geometrie() << poi->Interpolation();
cout << "\n LesMaillages::Completer( etc ... " << endl;
Sortie(1);
};
};
};
// cas de la stabilisation transversale de membrane et ou de biel
int divers_TabStabMembBiel_Taille=divers->TabStabMembBiel().Taille();
// on redimentionne les tableaux de sauvegardes
for (int ii=1;ii<= divers_TabStabMembBiel_Taille;ii++)
{ string nomStabMembBiel = (divers->TabStabMembBiel())(ii).NomRef(); // recup du nom de la ref
// on récupère la taille réel du conteneur
int nb_info = (divers->TabStabMembBiel())(ii).DimNom();
// creation d'un bloc general contenant des informations
// n= nombre de string, m nombre de double
BlocGen bloc(nb_info,0) ; // par defaut
// on récupère le bloc gen qui est par défaut de type 4,0 mais en fait est peut-être différent
// via la lecture. Comme on ramène un pointeur, on récupère le vrai bloc lu, modifié éventuellement en taille
const BlocDdlLim<BlocGen_4_0>& div_TabStabMembBiel = (divers->TabStabMembBiel())(ii);
const Reference & refG = lesRef->Trouve(nomStabMembBiel,div_TabStabMembBiel.NomMaillage()); // recup de la reference
// vérif que la référence s'adresse à des éléments
if ( refG.Indic() != 2)
{ // erreur la référence ne concerne pas des éléments
cout << "\n erreur la référence " << refG.Nom() << " ne concerne pas des éléments ";
cout << " \n cas des données relatives a la stabilisation transversale de membrane ou de biel ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
const ReferenceNE & ref = (ReferenceNE &) refG;
int ref_Taille=ref.Taille();
string nom_inter("stabilisation_transvers_membrane_biel_");
bloc.Change_nom(1,nom_inter); // le mot clé
// ensuite le type de stabilisation
bloc.Change_nom(2,div_TabStabMembBiel.Nom(2));
// puis un des deux mots clés : "une_valeur_numerique_" ou "une_fonction_nD_"
bloc.Change_nom(3,div_TabStabMembBiel.Nom(3));
// un string qui contient: soit la valeur numérique, soit le nom de la fonction nD
bloc.Change_nom(4,div_TabStabMembBiel.Nom(4));
// s'il y a des infos supplémentaires, on les recopie
if (nb_info > 4)
for (int i=4;i<=nb_info;i++)
bloc.Change_nom(i,div_TabStabMembBiel.Nom(i));
// puis on alimente les éléments concernés par ces calculs
////--- debug
//cout << "\n -- debug LesMaillages::Completer( ";
//bloc.Affiche(); cout << endl;
////--- fin debug
for (int jj= 1; jj<= ref_Taille; jj++)
{int nbb = ref.Numero(jj) ; // le numero de l'element dans le maillage
int nnn = ref.Nbmaille(); // le numero du maillage
// recup de l'element
Element * poi = & Element_LesMaille(nnn,nbb);
// demande a l'element de se completer
poi = poi->Complete(bloc,lesFonctionsnD);
};
};
// // retourne le tableau sur la définition d'un repère d'anisotropie aux éléments
// const Tableau < BlocDdlLim<BlocGen_5_0> >& TabRepAnisotrope() const {return tabRepAnisotrope;};
// cas de la définition de repère d'anisotropie
int divers_TabRepAnisotrope_Taille=divers->TabRepAnisotrope().Taille();
// on redimentionne les tableaux de sauvegardes
for (int ii=1;ii<= divers_TabRepAnisotrope_Taille;ii++)
{ string nomRepAnisotrope = (divers->TabRepAnisotrope())(ii).NomRef(); // recup du nom de la ref
const BlocDdlLim<BlocGen_6_0>& div_TabRepAnisotrope = (divers->TabRepAnisotrope())(ii);
const Reference & refG = lesRef->Trouve(nomRepAnisotrope,div_TabRepAnisotrope.NomMaillage()); // recup de la reference
// vérif que la référence s'adresse à des éléments
if ( refG.Indic() != 2)
{ // erreur la référence ne concerne pas des éléments
cout << "\n erreur la reference " << refG.Nom() << " ne concerne pas des elements ";
cout << " \n cas des donnees relatives a la definition de repere d'anisotropie ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
const ReferenceNE & ref = (ReferenceNE &) refG;
int ref_Taille=ref.Taille();
// creation d'un bloc general contenant des informations
// n= nombre de string, m nombre de double
BlocGen bloc(5,0) ; // par defaut
string nom_inter("repere_anisotropie_");
bloc.Change_nom(1,nom_inter); // le mot clé
// ensuite le type l'identificateur de repere
bloc.Change_nom(2,div_TabRepAnisotrope.Nom(2));
// ensuite le type de repere
bloc.Change_nom(3,div_TabRepAnisotrope.Nom(3));
// puis la méthode de définition du repère
bloc.Change_nom(4,div_TabRepAnisotrope.Nom(4));
// un string qui contient le nom de la fonction nD
bloc.Change_nom(5,div_TabRepAnisotrope.Nom(6));
// puis on alimente les éléments concernés par ces calculs
////--- debug
//cout << "\n -- debug LesMaillages::Completer( ";
//bloc.Affiche(); cout << endl;
////--- fin debug
for (int jj= 1; jj<= ref_Taille; jj++)
{int nbb = ref.Numero(jj) ; // le numero de l'element dans le maillage
int nnn = ref.Nbmaille(); // le numero du maillage
// recup de l'element
Element * poi = & Element_LesMaille(nnn,nbb);
// demande a l'element de se completer
poi = poi->Complete(bloc,lesFonctionsnD);
};
};
// cas de statistique d'une ref de noeuds pour une grandeur quelconque
int divers_TabStatistique_Taille=divers->TabStatistique().Taille();
// on redimentionne les tableaux de sauvegardes
statistique_typeQuel.Change_taille(divers_TabStatistique_Taille);
statistique_typeQuel_t.Change_taille(divers_TabStatistique_Taille);
ref_statistique.Change_taille(divers_TabStatistique_Taille);
pour_statistique_de_ddl.Change_taille(divers_TabStatistique_Taille);
for (int ii=1;ii<= divers_TabStatistique_Taille;ii++)
{ string nomStatistique = (divers->TabStatistique())(ii).NomRef(); // recup du nom de la ref
const BlocDdlLim<BlocGen_3_0>& div_Statistique = (divers->TabStatistique())(ii);
const Reference & refG = lesRef->Trouve(nomStatistique,div_Statistique.NomMaillage()); // recup de la reference
// vérif que la référence s'adresse à des noeuds
if ( refG.Indic() != 1)
{ // erreur la référence ne concerne pas des éléments
cout << "\n erreur la reference " << refG.Nom() << " ne concerne pas des Noeuds ";
cout << " \n cas des donnees relatives aux statistiques ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
const ReferenceNE & ref = (ReferenceNE &) refG;
// creation d'un bloc general contenant des informations
// n= nombre de string, m nombre de double
BlocGen bloc(4,1) ; // par defaut
////--- debug
//cout << "\n -- debug LesMaillages::Completer( ";
//div_Statistique.Affiche(); cout << endl;
////--- fin debug
string nom_inter("statistique_");
bloc.Change_nom(1,nom_inter); // le type de statistique
bloc.Change_nom(2,div_Statistique.Nom(2)); // mot clé : ex: un_ddl_etendu_
bloc.Change_nom(3,div_Statistique.Nom(3)); // ex: le nom du ddl : ex UX
// construction d'un nom qui servira à discriminer les différents conteneurs
string nom_ref("statistique_");// init
if ((div_Statistique.NomMaillage() == NULL) // cas d'un seule maillage
&& (nbMaillageTotal==1)) // enregistré
{nom_ref +=(refG.Nom());}
else if (div_Statistique.NomMaillage() != NULL) // cas de plusieurs maillages
{nom_ref += (*div_Statistique.NomMaillage())+"_"+(refG.Nom());}
else // sinon pb
{ cout << "\n erreur il manque le nom de maillage alors qu'il y a plusieurs maillages en cours ";
cout << " \n cas des donnees relatives aux statistiques sur ref de noeuds ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
bloc.Change_val(1,ii); // on indique le numéro du stockage global
// on commence par définir le conteneur global qui sera stocké dans LesMaillages
ref_statistique(ii) = &refG;
if (bloc.Nom(2) == "un_ddl_etendu_")
{ // il s'agit d'une statistique d'un ddl étendu de nom: bloc.Nom(3)
nom_ref += "_ddl_etendu_"+bloc.Nom(3);
// on sauvegarde le Ddl_enum_etendu associé
pour_statistique_de_ddl(ii) = Ddl_enum_etendu(bloc.Nom(3));
// on définit le conteneur résultat: on stocke un vecteur, car pour un ddl -> 10 valeurs
Grandeur_Vecteur_Nommer gvec_courant(nom_ref,10);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(STATISTIQUE,nom_ref,VECTEUR);
TypeQuelconque typQ(enuType,X1,gvec_courant);
statistique_typeQuel(ii) = (typQ); // stockage interne à LesMaillages
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ,nom_ref);
// idem pour la grandeur à t
string nom_ref_t = nom_ref + "__t_";
// on définit le conteneur résultat: on stocke un vecteur, car pour un ddl -> 10 valeurs
Grandeur_Vecteur_Nommer gvec_courant_t(nom_ref_t,10);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType_t =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(STATISTIQUE,nom_ref_t,VECTEUR);
TypeQuelconque typQ_t(enuType_t,X1,gvec_courant_t);
statistique_typeQuel_t(ii) = (typQ_t); // stockage interne à LesMaillages
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ_t,nom_ref_t);
}
else if (bloc.Nom(2) == "une_fonction_nD_")
{ // il s'agit d'une statistique d'une fonction nD de nom: bloc.Nom(3)
nom_ref += "_fct_nD_"+bloc.Nom(3);
// on récupère le pointeur de fonction correspondant:
Fonction_nD * fct = lesFonctionsnD->Trouve(bloc.Nom(3));
int nb_composante = fct->NbComposante();
int dim_necessaire = (6*nb_composante + 4); // cf. la méthode CalStatistique()
Grandeur_Vecteur_Nommer grand_courant(nom_ref,dim_necessaire,fct);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(STATISTIQUE,nom_ref,VECTEUR);
TypeQuelconque typQ(enuType,X1,grand_courant);
statistique_typeQuel(ii) = (typQ);
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ,nom_ref);
// idem pour la grandeur à t
string nom_ref_t = nom_ref + "__t_";
Grandeur_Vecteur_Nommer grand_courant_t(nom_ref_t,dim_necessaire,fct);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType_t =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(STATISTIQUE,nom_ref_t,VECTEUR);
TypeQuelconque typQ_t(enuType_t,X1,grand_courant_t);
statistique_typeQuel_t(ii) = (typQ_t); // stockage interne à LesMaillages
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ_t,nom_ref_t);
////--- debug
//cout << "\n -- debug LesMaillages::Completer( ";
//if (nom_ref_t == "int_vol_E_tout_fct_nD_fct1_t_")
// { const void* pointe = (ParaGlob::param->GrandeurGlobal(nom_ref_t));
// TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
// cout << "\n gr_quelc= "<< (*gr_quelc) << endl;
// Grandeur_Vecteur_Nommer& gr = *((Grandeur_Vecteur_Nommer*) gr_quelc->Grandeur_pointee()); // pour simplifier
// cout << "\n gr.NbMaxiNumeroOrdre()= "<<gr.NbMaxiNumeroOrdre() << endl;
// }
////cout << "\n (typQ_t)= "<<(typQ_t) << " nom_ref_t= "<<nom_ref_t << endl;
// cout << endl;
////--- fin debug
};
bloc.Change_nom(4,nom_ref); // on indique le nom de référencement global
////--- debug
//cout << "\n -- debug LesMaillages::Completer( ";
//bloc.Affiche(); cout << endl;
////--- fin debug
// arrêt des opérations ici .....
//
// // puis on alimente les éléments concernés par ces calculs
// int ref_Taille=ref.Taille();
// for (int jj= 1; jj<= ref_Taille; jj++)
// {int nbb = ref.Numero(jj) ; // le numero de l'element dans le maillage
// int nnn = ref.Nbmaille(); // le numero du maillage
// // recup de l'element
// Element * poi = & Element_LesMaille(nnn,nbb);
// // demande a l'element de se completer
// poi = poi->Complete(bloc,lesFonctionsnD);
// if (poi == NULL)
// { // cas d'un probleme
// cout << "\n erreur l'integration de ";bloc.Affiche();
// cout << " n'est pas adapte a l\'element ";
// poi = & Element_LesMaille(nnn,nbb);
// cout << "\n element " << poi->Geometrie() << poi->Interpolation();
// cout << "\n LesMaillages::Completer( etc ... " << endl;
// Sortie(1);
// };
// };
};
// cas des statistiques sur des ref de noeuds avec cumul en temps
int divers_TabStatistique_et_temps_Taille=divers->TabStatistique_et_temps().Taille();
// on redimentionne les tableaux de sauvegardes
statistique_t_typeQuel.Change_taille(divers_TabStatistique_et_temps_Taille);
statistique_t_typeQuel_t.Change_taille(divers_TabStatistique_et_temps_Taille);
ref_statistique_t.Change_taille(divers_TabStatistique_et_temps_Taille);
pour_statistique_t_de_ddl.Change_taille(divers_TabStatistique_et_temps_Taille,NU_DDL);
for (int ii=1;ii<= divers_TabStatistique_et_temps_Taille;ii++)
{ string nomStatistique = (divers->TabStatistique_et_temps())(ii).NomRef(); // recup du nom de la ref
const BlocDdlLim<BlocGen_3_0>& div_Statistique = (divers->TabStatistique_et_temps())(ii);
const Reference & refG = lesRef->Trouve(nomStatistique,div_Statistique.NomMaillage()); // recup de la reference
// vérif que la référence s'adresse à des noeuds
if ( refG.Indic() != 1)
{ // erreur la référence ne concerne pas des noeuds
cout << "\n erreur la reference " << refG.Nom() << " ne concerne pas des noeuds ";
cout << " \n cas des donnees relatives aux statistiques de ref de noeuds avec cumul en temps ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
const ReferenceNE & ref = (ReferenceNE &) refG;
int ref_Taille=ref.Taille();
// creation d'un bloc general contenant des informations
// n= nombre de string, m nombre de double
BlocGen bloc(4,1) ; // par defaut
string nom_inter("statistique_et_temps_");
bloc.Change_nom(1,nom_inter); // le type de statistique
bloc.Change_nom(2,div_Statistique.Nom(2));
bloc.Change_nom(3,div_Statistique.Nom(3));
// construction d'un nom qui servira à discriminer les différents conteneurs
string nom_ref("statistique_temps_");// init
if ((div_Statistique.NomMaillage() == NULL) // cas d'un seule maillage
&& (nbMaillageTotal==1)) // enregistré
{nom_ref +=(refG.Nom());}
else if (div_Statistique.NomMaillage() != NULL) // cas de plusieurs maillages
{nom_ref += (*div_Statistique.NomMaillage())+"_"+(refG.Nom());}
else // sinon pb
{ cout << "\n erreur il manque le nom de maillage alors qu'il y a plusieurs maillages en cours ";
cout << " \n cas des données relatives aux statistiques sur des ref de noeuds avec cumul en temps ";
cout << "\n LesMaillages::Completer( .... ";
Sortie(1);
};
bloc.Change_val(1,ii); // on indique le numéro du stockage global
// on commence par définir le conteneur global qui sera stocké dans LesMaillages
ref_statistique_t(ii) = &refG;
if (bloc.Nom(2) == "un_ddl_etendu_")
{ // il s'agit d'une statistique d'un ddl étendu de nom: bloc.Nom(3)
nom_ref += "_ddl_etendu_"+bloc.Nom(3);
// on sauvegarde le Ddl_enum_etendu associé
pour_statistique_t_de_ddl(ii) = Ddl_enum_etendu(bloc.Nom(3));
// on définit le conteneur résultat: on stocke un vecteur, car pour un ddl -> 10 valeurs
Grandeur_Vecteur_Nommer gvec_courant(nom_ref,10);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(STATISTIQUE_ET_TEMPS,nom_ref,VECTEUR);
TypeQuelconque typQ(enuType,X1,gvec_courant);
statistique_t_typeQuel(ii) = (typQ); // stockage interne à LesMaillages
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ,nom_ref);
// idem pour la grandeur à t
string nom_ref_t = nom_ref + "__t_";
// on définit le conteneur résultat: on stocke un vecteur, car pour un ddl -> 10 valeurs
Grandeur_Vecteur_Nommer gvec_courant_t(nom_ref_t,10);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType_t =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(STATISTIQUE_ET_TEMPS,nom_ref_t,VECTEUR);
TypeQuelconque typQ_t(enuType_t,X1,gvec_courant_t);
statistique_t_typeQuel_t(ii) = (typQ_t); // stockage interne à LesMaillages
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ_t,nom_ref_t);
}
else if (bloc.Nom(2) == "une_fonction_nD_")
{ // il s'agit d'une statistique d'une fonction nD de nom: bloc.Nom(3)
nom_ref += "_fct_nD_"+bloc.Nom(3);
// on récupère le pointeur de fonction correspondant:
Fonction_nD * fct = lesFonctionsnD->Trouve(bloc.Nom(3));
int nb_composante = fct->NbComposante();
int dim_necessaire = (6*nb_composante + 4); // cf. la méthode CalStatistique()
Grandeur_Vecteur_Nommer grand_courant(nom_ref,dim_necessaire,fct);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(STATISTIQUE_ET_TEMPS,nom_ref,VECTEUR);
TypeQuelconque typQ(enuType,X1,grand_courant);
statistique_t_typeQuel(ii) = (typQ);
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ,nom_ref);
// idem pour la grandeur à t
string nom_ref_t = nom_ref + "__t_";
Grandeur_Vecteur_Nommer grand_courant_t(nom_ref_t,dim_necessaire,fct);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType_t =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(STATISTIQUE_ET_TEMPS,nom_ref_t,VECTEUR);
TypeQuelconque typQ_t(enuType_t,X1,grand_courant_t);
statistique_t_typeQuel_t(ii) = (typQ_t); // stockage interne à LesMaillages
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
ParaGlob::param->Ajout_grandeur_consultable(&typQ_t,nom_ref_t);
};
bloc.Change_nom(4,nom_ref); // on indique le nom de référencement global
// // puis on alimente les éléments concernés par ces calculs
// ////--- debug
// //cout << "\n -- debug LesMaillages::Completer( ";
// //bloc.Affiche(); cout << endl;
// ////--- fin debug
// for (int jj= 1; jj<= ref_Taille; jj++)
// {int nbb = ref.Numero(jj) ; // le numero de l'element dans le maillage
// int nnn = ref.Nbmaille(); // le numero du maillage
// // recup de l'element
// Element * poi = & Element_LesMaille(nnn,nbb);
// // demande a l'element de se completer
// poi = poi->Complete(bloc,lesFonctionsnD);
// if (poi == NULL)
// { // cas d'un probleme
// cout << "\n erreur l'integration de ";bloc.Affiche();
// cout << " n'est pas adapte a l\'element ";
// poi = & Element_LesMaille(nnn,nbb);
// cout << "\n element " << poi->Geometrie() << poi->Interpolation();
// cout << "\n LesMaillages::Completer( etc ... " << endl;
// Sortie(1);
// };
// };
};
// cas des tableaux de ddl pour les noeuds
// InitPositionAssemblage(nb_assemb);
};
// ramene le nombre total de ddl du pb
int LesMaillages::NbTotalDdlActifs() const
{ // init du nombre de ddl actifs du pb
int nb = 0;
// puis boucle sur les maillages et les noeuds
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
nb += Noeud_LesMaille(i1,i2).Nombre_var_ddl_actives();
}
return nb;
};
// ramene le nombre total de ddl actifs du pb
// pour un type de ddl donné, dans le cas de type
// vectoriel on cumule les ddl de l'ensemble de la dimension
int LesMaillages::NbTotalDdlActifs(Enum_ddl enum_ddl) const
{ // init du nombre de ddl actifs du pb
int nb = 0;
// puis boucle sur les maillages et les noeuds
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
nb += Noeud_LesMaille(i1,i2).Nombre_var_ddl_actives(enum_ddl);
}
return nb;
};
// ramene le nombre total de points d'intégration correspondant à un ddl donné
int LesMaillages::NbTotalPtInteg(Enum_ddl enum_ddl) const
{ // init du nombre de points d'intégration
int nb = 0;
// puis boucle sur les maillages et les éléments
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelmax; i2++)
nb += Element_LesMaille_const(i1,i2).NbPtInteg(enum_ddl);
}
return nb;
};
// ramene le nombre total de grandeurs génératrices, calculées aux points d'intégrations,
// correspondant à un ddl donné.
int LesMaillages::NbTotalGrandeursGeneratrices(Enum_ddl enum_ddl) const
{ // init du nombre de grandeurs génératrices
int nb = 0;
// puis boucle sur les maillages et les éléments
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelmax; i2++)
{ // on récupère le nombre de points d'intégrations
int nbptinteg = Element_LesMaille_const(i1,i2).NbPtInteg(enum_ddl);
// on récupère le nombre de grandeurs génératrices pour le ddl
int nbGG = Element_LesMaille_const(i1,i2).NbGrandeurGene(enum_ddl);
// calcul
nb += nbptinteg * nbGG;
}
}
return nb;
};
//récupération d'une grandeur vectoriel de dimension, la dimension
// de l'espace, défini au noeud et transféré dans un vecteur global
// qui cumule de manière séquentielle toutes les grandeurs
// en entrée : enum_ddl donne le type de la grandeur à récupérer
// en fait de la première composante
// duree : indique à quel temps doit s'effectuer le transfert, t=0 ou t ou tdt
// enum_actif : le transfert s'effectue que si le ddl enum_actif est actif
// ce qui permet la différentiation entre les différents ddl
// vect : est le vecteur global de stockage qui normalement a été
// au préalable dimensionné avec NbTotalDdlActifs(Enum_ddl enum_ddl)
// Important: pour chaque famille de ddl, les ddl sont classés de manière croissante, ce qui signifie
// que c'est l'ordre des pointeurs d'assemblage si et seulement si, ces ddl ont été rangés dans les noeuds
// au préalable
// en retour : une référence sur vect
Vecteur & LesMaillages::Vect_loc_vers_glob(Enum_dure duree,Enum_ddl enum_actif
,Vecteur& vect,Enum_ddl enum_ddl)
{ // recup de la dimension
int dimen = ParaGlob::Dimension();
// dans le cas axisymétrique il n'y a pas de variation suivant le dernier axe
if (ParaGlob::AxiSymetrie())
dimen--;
int ivect = 1; // position global
// maintenant on passe en revue les noeuds
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// on regarde si le ddl existe et que le ddl actif est actif
if ((noo->Existe_ici(enum_ddl)) && (noo->En_service(enum_actif))
&& (noo->UneVariable(enum_actif)))
// dans le cas où enum_ddl == X1, on regarde s'il ne faut pas associer l'épaisseur
// l'épaisseur n'est associée que si elle est une variable
switch (duree)
{ case TEMPS_0 :
{ for (int ii=1; ii<= dimen; ii++,ivect++)
vect(ivect) = noo->Valeur_0(Enum_ddl(ii-1 + enum_ddl) );
if ((enum_ddl == X1) && noo->Existe_ici(EPAIS) && (noo->UneVariable(EPAIS)))
{vect(ivect) = noo->Valeur_0(EPAIS);ivect++;};
break;
}
case TEMPS_t :
{ for (int ii=1; ii<= dimen; ii++,ivect++)
vect(ivect) = noo->Valeur_t(Enum_ddl(enum_ddl + ii-1));
if ((enum_ddl == X1) && noo->Existe_ici(EPAIS) && (noo->UneVariable(EPAIS)))
{vect(ivect) = noo->Valeur_t(EPAIS);ivect++;};
break;
}
case TEMPS_tdt :
{ for (int ii=1; ii<= dimen; ii++,ivect++)
vect(ivect) = noo->Valeur_tdt(Enum_ddl(enum_ddl + ii-1));
if ((enum_ddl == X1) && noo->Existe_ici(EPAIS) && (noo->UneVariable(EPAIS)))
{vect(ivect) = noo->Valeur_tdt(EPAIS);ivect++;};
break;
}
default :
cout << "\nErreur : valeur incorrecte du type Enum_dure !\n";
cout << "LesMaillages::Vect_loc_vers_glob(Enum_dure... \n";
Sortie(1);
}
}
}
return vect;
};
// fonction inverse de Vect_loc_vers_glob, il s'agit ici de passer
// de la grandeur globale aux grandeurs locale
void LesMaillages::Vect_glob_vers_local(Enum_dure duree,Enum_ddl enum_actif
,const Vecteur& vect,Enum_ddl enum_ddl)
{ // recup de la dimension
int dimen = ParaGlob::Dimension();
// dans le cas axisymétrique il n'y a pas de variation suivant le dernier axe
if (ParaGlob::AxiSymetrie())
dimen--;
int ivect = 1; // position global
// maintenant on passe en revu les noeuds
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// on regarde si le ddl existe et que le ddl actif est actif
if ((noo->Existe_ici(enum_ddl)) && (noo->En_service(enum_actif))
&& (noo->UneVariable(enum_actif)))
// dans le cas où enum_ddl == X1, on regarde s'il ne faut pas associer l'épaisseur
// l'épaisseur n'est associée que si elle est une variable
switch (duree)
{ case TEMPS_0 :
{ for (int ii=1; ii<= dimen; ii++,ivect++)
noo->Change_val_0(Enum_ddl(ii-1 + enum_ddl),vect(ivect));
if ((enum_ddl == X1) && noo->Existe_ici(EPAIS) && (noo->UneVariable(EPAIS)))
{noo->Change_val_0(EPAIS,vect(ivect));ivect++;};
break;
}
case TEMPS_t :
{ for (int ii=1; ii<= dimen; ii++,ivect++)
noo->Change_val_t(Enum_ddl(ii-1 + enum_ddl),vect(ivect));
if ((enum_ddl == X1) && noo->Existe_ici(EPAIS) && (noo->UneVariable(EPAIS)))
{noo->Change_val_t(EPAIS,vect(ivect));ivect++;};
break;
}
case TEMPS_tdt :
{ for (int ii=1; ii<= dimen; ii++,ivect++)
noo->Change_val_tdt(Enum_ddl(ii-1 + enum_ddl),vect(ivect));
if ((enum_ddl == X1) && noo->Existe_ici(EPAIS) && (noo->UneVariable(EPAIS)))
{noo->Change_val_tdt(EPAIS,vect(ivect));ivect++;};
break;
}
default :
cout << "\nErreur : valeur incorrecte du type Enum_dure !\n";
cout << "LesMaillages::Vect_glob_vers_local(Enum_dure... \n";
Sortie(1);
}
}
}
};
//récupération d'une grandeur vectoriel de dimension, la dimension
// de l'espace, défini au noeud et transféré dans un vecteur global
// qui cumule de manière séquentielle toutes les grandeurs
// en entrée : tab_enum_ddl donne le tableau des type de la grandeur à récupérer
// en fait de la première composante
// duree : indique à quel temps doit s'effectuer le transfert, t=0 ou t ou tdt
// tab_enum_actif : pour chaque élément tab_enum_ddl(i), le transfert s'effectue que si
// le ddl tab_enum_actif(i) est actif
// ce qui permet la différentiation entre les différents ddl
// vect : est le vecteur global de stockage qui normalement a été
// au préalable dimensionné avec somme des NbTotalDdlActifs(Enum_ddl enum_ddl), avec enum_ddl
// qui balaie l'ensemble des éléments de tab_enum_ddl
// Important: pour chaque famille de ddl, les ddl sont classés de manière croissante, ce qui signifie
// que c'est l'ordre des pointeurs d'assemblage si et seulement si, ces ddl ont été rangés dans les noeuds
// au préalable
// en retour : une référence sur vect
Vecteur & LesMaillages::Vect_loc_vers_glob(Enum_dure duree,const Tableau <Enum_ddl>& tab_enum_actif
,Vecteur& vect,const Tableau <Enum_ddl>& tab_enum_ddl)
{ // recup de la dimension
int dimen = ParaGlob::Dimension();
// dans le cas axisymétrique il n'y a pas de variation suivant le dernier axe
if (ParaGlob::AxiSymetrie())
dimen--;
int ivect = 1; // position global
int taill_tab = tab_enum_ddl.Taille();
#ifdef MISE_AU_POINT
if (taill_tab != tab_enum_actif.Taille())
{cout << "\n *** erreur , la dimension: "<<tab_enum_actif.Taille()
<<" du tableau Tableau <Enum_ddl> tab_enum_actif est differente "
<< " de la taille: "<<taill_tab <<" du tableau Tableau <Enum_ddl> tab_enum_ddl "
<< "\n LesMaillages::Vect_loc_vers_glob( ..."<<endl;
Sortie(1);
};
#endif
// maintenant on passe en revue les noeuds
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// on boucle sur les ddl
for (int i=1;i<= taill_tab;i++)
{Enum_ddl enum_actif=tab_enum_actif(i);
Enum_ddl enum_ddl = tab_enum_ddl(i);
// on regarde si le ddl existe et que le ddl actif est actif
if ((noo->Existe_ici(enum_ddl)) && (noo->En_service(enum_actif))
&& (noo->UneVariable(enum_actif)))
// dans le cas où enum_ddl == X1, on regarde s'il ne faut pas associer l'épaisseur
// l'épaisseur n'est associée que si elle est une variable
switch (duree)
{ case TEMPS_0 :
{ for (int ii=1; ii<= dimen; ii++,ivect++)
vect(ivect) = noo->Valeur_0(Enum_ddl(ii-1 + enum_ddl) );
if ((enum_ddl == X1) && noo->Existe_ici(EPAIS) && (noo->UneVariable(EPAIS)))
{vect(ivect) = noo->Valeur_0(EPAIS);ivect++;};
break;
}
case TEMPS_t :
{ for (int ii=1; ii<= dimen; ii++,ivect++)
vect(ivect) = noo->Valeur_t(Enum_ddl(enum_ddl + ii-1));
if ((enum_ddl == X1) && noo->Existe_ici(EPAIS) && (noo->UneVariable(EPAIS)))
{vect(ivect) = noo->Valeur_t(EPAIS);ivect++;};
break;
}
case TEMPS_tdt :
{ for (int ii=1; ii<= dimen; ii++,ivect++)
vect(ivect) = noo->Valeur_tdt(Enum_ddl(enum_ddl + ii-1));
if ((enum_ddl == X1) && noo->Existe_ici(EPAIS) && (noo->UneVariable(EPAIS)))
{vect(ivect) = noo->Valeur_tdt(EPAIS);ivect++;};
break;
}
default :
cout << "\nErreur : valeur incorrecte du type Enum_dure !\n";
cout << "LesMaillages::Vect_loc_vers_glob(Enum_dure... \n";
Sortie(1);
};
};
};
}
return vect;
};
// fonction inverse de Vect_loc_vers_glob, il s'agit ici de passer
// de la grandeur globale aux grandeurs locale
void LesMaillages::Vect_glob_vers_local(Enum_dure duree,const Tableau <Enum_ddl>& tab_enum_actif
,const Vecteur& vect,const Tableau <Enum_ddl>& tab_enum_ddl)
{ // recup de la dimension
int dimen = ParaGlob::Dimension();
// dans le cas axisymétrique il n'y a pas de variation suivant le dernier axe
if (ParaGlob::AxiSymetrie())
dimen--;
int ivect = 1; // position global
int taill_tab = tab_enum_ddl.Taille();
#ifdef MISE_AU_POINT
if (taill_tab != tab_enum_actif.Taille())
{cout << "\n *** erreur , la dimension: "<<tab_enum_actif.Taille()
<<" du tableau Tableau <Enum_ddl> tab_enum_actif est differente "
<< " de la taille: "<<taill_tab <<" du tableau Tableau <Enum_ddl> tab_enum_ddl "
<< "\n LesMaillages::Vect_glob_vers_local( ..."<<endl;
Sortie(1);
};
#endif
// maintenant on passe en revu les noeuds
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// on boucle sur les ddl
for (int i=1;i<= taill_tab;i++)
{Enum_ddl enum_actif=tab_enum_actif(i);
Enum_ddl enum_ddl = tab_enum_ddl(i);
// on regarde si le ddl existe et que le ddl actif est actif
if ((noo->Existe_ici(enum_ddl)) && (noo->En_service(enum_actif))
&& (noo->UneVariable(enum_actif)))
// dans le cas où enum_ddl == X1, on regarde s'il ne faut pas associer l'épaisseur
// l'épaisseur n'est associée que si elle est une variable
switch (duree)
{ case TEMPS_0 :
{ for (int ii=1; ii<= dimen; ii++,ivect++)
noo->Change_val_0(Enum_ddl(ii-1 + enum_ddl),vect(ivect));
if ((enum_ddl == X1) && noo->Existe_ici(EPAIS) && (noo->UneVariable(EPAIS)))
{noo->Change_val_0(EPAIS,vect(ivect));ivect++;};
break;
}
case TEMPS_t :
{ for (int ii=1; ii<= dimen; ii++,ivect++)
noo->Change_val_t(Enum_ddl(ii-1 + enum_ddl),vect(ivect));
if ((enum_ddl == X1) && noo->Existe_ici(EPAIS) && (noo->UneVariable(EPAIS)))
{noo->Change_val_t(EPAIS,vect(ivect));ivect++;};
break;
}
case TEMPS_tdt :
{ for (int ii=1; ii<= dimen; ii++,ivect++)
noo->Change_val_tdt(Enum_ddl(ii-1 + enum_ddl),vect(ivect));
if ((enum_ddl == X1) && noo->Existe_ici(EPAIS) && (noo->UneVariable(EPAIS)))
{noo->Change_val_tdt(EPAIS,vect(ivect));ivect++;};
break;
}
default :
cout << "\nErreur : valeur incorrecte du type Enum_dure !\n";
cout << "LesMaillages::Vect_glob_vers_local(Enum_dure... \n";
Sortie(1);
};
};
};
};
};
//récupération d'une grandeur scalaire
// défini au noeud et transféré dans un vecteur global
// qui cumule de manière séquentielle toutes les grandeurs
// en entrée : enum_ddl donne le type de la grandeur à récupérer
// duree : indique à quel temps doit s'effectuer le transfert, t=0 ou t ou tdt
// enum_actif : le transfert s'effectue que si le ddl enum_actif est actif
// ce qui permet la différentiation entre les différents ddl
// vect : est le vecteur global de stockage qui normalement a été
// au préalable dimensionné avec NbTotalDdlActifs(Enum_ddl enum_ddl)
// en retour : une référence sur vect
Vecteur & LesMaillages::Scalaire_loc_vers_glob(Enum_dure duree,Enum_ddl enum_actif
,Vecteur& vect,Enum_ddl enum_ddl)
{ int ivect = 1; // position global
// maintenant on passe en revu les noeuds
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++,ivect++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
if (noo->Existe_ici(enum_actif)) // ellimine les noeuds non concernés
{// on regarde si le ddl existe et que le ddl actif est actif
if ((noo->Existe_ici(enum_ddl)) && (noo->En_service(enum_actif))
&& (noo->UneVariable(enum_actif)))
switch (duree)
{ case TEMPS_0 : {vect(ivect) = noo->Valeur_0(enum_ddl); break;}
case TEMPS_t : {vect(ivect) = noo->Valeur_t(enum_ddl); break;}
case TEMPS_tdt : {vect(ivect) = noo->Valeur_tdt(enum_ddl); break;}
default :
cout << "\nErreur : valeur incorrecte du type Enum_dure !\n";
cout << "LesMaillages::Scalaire_loc_vers_glob(Enum_dure... \n";
Sortie(1);
}
}
}
}
return vect;
};
// fonction inverse de Scalaire_loc_vers_glob, il s'agit ici de passer
// de la grandeur globale à la grandeur locale
void LesMaillages::Scalaire_glob_vers_local(Enum_dure duree,Enum_ddl enum_actif
,Vecteur& vect,Enum_ddl enum_ddl)
{ int ivect = 1; // position global
// maintenant on passe en revu les noeuds
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++,ivect++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
if (noo->Existe_ici(enum_actif)) // élimine les noeuds non concernés
{// on regarde si le ddl existe et que le ddl actif est actif
if ((noo->Existe_ici(enum_ddl)) && (noo->En_service(enum_actif))
&& (noo->UneVariable(enum_actif)))
switch (duree)
{ case TEMPS_0 : {noo->Change_val_0(enum_ddl,vect(ivect)); break;}
case TEMPS_t : {noo->Change_val_t(enum_ddl,vect(ivect)); break;}
case TEMPS_tdt : {noo->Change_val_tdt(enum_ddl,vect(ivect)); break;}
default :
cout << "\nErreur : valeur incorrecte du type Enum_dure !\n";
cout << "LesMaillages::Scalaire_glob_vers_local(Enum_dure... \n";
Sortie(1);
};
}
}
}
};
// fonctions idem que pour les ddl : mais pour un Ddl_etendu
Vecteur & LesMaillages::Scalaire_loc_vers_glob(Enum_ddl enum_actif
,Vecteur& vect,const Ddl_enum_etendu& enum_ddl_etend)
{ int ivect = 1; // position global
// maintenant on passe en revu les noeuds
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++,ivect++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
if (noo->Existe_ici(enum_actif)) // ellimine les noeuds non concernés
// on regarde si le ddl existe et que le ddl actif est actif
{if ((noo->Existe_ici_ddlEtendu(enum_ddl_etend)) && (noo->En_service(enum_actif)))
vect(ivect) = (noo->DdlEtendue(enum_ddl_etend)).ConstValeur();
}
}
}
return vect;
};
// fonctions idem que pour les ddl : mais pour un Ddl_etendu
void LesMaillages::Scalaire_glob_vers_local(Enum_ddl enum_actif
,Vecteur& vect,const Ddl_enum_etendu& enum_ddl_etend)
{ int ivect = 1; // position global
#ifdef MISE_AU_POINT
// on vérifie qu'il y a le bon nombre d'informations
int nb_info = 0;
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
nb_info += tabMaillage(i1)->Nombre_noeud();
if (vect.Taille() != nb_info)
{cout << "\nerreur en affectation de grandeurs vers les maillages: vecteur globale ";
cout << " dim vecteur = " << vect.Taille() << " alorq qu'il faut " << nb_info <<'\n';
cout << "\n LesMaillages::Scalaire_glob_vers_local(Enum_ddl enum_actif" << endl;
Sortie(1);
};
#endif
// maintenant on passe en revu les noeuds
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++,ivect++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
if ((noo->Existe_ici_ddlEtendu(enum_ddl_etend)) && (noo->En_service(enum_actif)))
// on récupère le ddl étendu pour le modifier
(noo->ModifDdl_etendu(enum_ddl_etend)).Valeur() = vect(ivect);
}
}
};
// fonctions idem que pour les ddl_etendu : mais pour une grandeur quelconque
Vecteur & LesMaillages::Quelconque_loc_vers_glob(Enum_ddl enum_actif,Vecteur& vect,const TypeQuelconque& type_generique)
//Vecteur & LesMaillages::Scalaire_loc_vers_glob(Enum_ddl enum_actif
// ,Vecteur& vect,const Ddl_enum_etendu& enum_ddl_etend)
{ int ivect = 1; // position global
int dim = ParaGlob::Dimension(); // dimension du pb
// maintenant on passe en revue les noeuds
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++,ivect++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// on regarde si le conteneur existe, si oui on transfert, si non, on passe les valeurs
TypeQuelconque_enum_etendu enuq = type_generique.EnuTypeQuelconque();
if (noo->Existe_ici(enum_actif)) // ellimine les noeuds non concernés
{if ((noo->Existe_ici(enuq)) && (noo->En_service(enum_actif)))
{// dépend du type de grandeur
EnumTypeGrandeur enuGrandeur = type_generique.EnuTypeGrandeur();
switch (enuGrandeur)
{case COORDONNEE:
{TypeQuelconque& typQ = noo->ModifGrandeur_quelconque(enuq); // récup du conteneur du noeud
// récup de la grandeur
Grandeur_coordonnee* gcoor = (Grandeur_coordonnee*) typQ.Grandeur_pointee();
Coordonnee& conoe = *(gcoor->ConteneurCoordonnee()); // les coordonnées
switch (dim) // on rempli le vecteur
{ case 3: vect(ivect)=conoe(3);ivect++;
case 2: vect(ivect)=conoe(2);ivect++;
case 1: vect(ivect)=conoe(1);ivect++;
};
}
default:
cout << "\n ** erreur, pour l'instant le transfert depuis les noeuds de "
<< (enuq.NomPlein()) << " n'est pas implante ... le demander !! "
<< "\n LesMaillages::Quelconque_loc_vers_glob(..."<<endl;
Sortie(1);
}
}
else //on ne fait que décaler le pointeur dans le vecteur pour la suite
{ ivect += dim;};
};
};
};
return vect;
};
// fonctions idem que pour les ddl_etendu : mais pour une grandeur quelconque
void LesMaillages::Quelconque_glob_vers_local(Enum_ddl enum_actif,Vecteur& vect,const TypeQuelconque& type_generique)
{ int ivect = 1; // position global
int dim = ParaGlob::Dimension(); // dimension du pb
if(ParaGlob::AxiSymetrie())
dim--; // en axisymétrie on récupère uniquement les forces en x et y
int nb_val_typeQuelconque = type_generique.NbMaxiNumeroOrdre();
// maintenant on passe en revue les noeuds
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// on regarde si le conteneur existe, si oui on transfert, si non, on passe les valeurs
TypeQuelconque_enum_etendu enuq = type_generique.EnuTypeQuelconque();
if (noo->Existe_ici(enum_actif)) // ellimine les noeuds non concernés
{
////-------- debug
//if (!((noo->Existe_ici(enuq)) && (noo->En_service(enum_actif))))
// {cout << "\n debug LesMaillages::Quelconque_glob_vers_local( ";
// cout << "\n enuq: " << enuq.NomPlein()<< " noo->Existe_ici(enuq) "<< (noo->Existe_ici(enuq))
// << "\n enum_actif: " << Nom_ddl(enum_actif) << " noo->En_service(enum_actif) " << noo->En_service(enum_actif)
// << flush;
// };
////-------- fin debug
if ((noo->Existe_ici(enuq)) && (noo->En_service(enum_actif)))
{// dépend du type de grandeur
EnumTypeGrandeur enuGrandeur = type_generique.EnuTypeGrandeur();
switch (enuGrandeur)
{case COORDONNEE:
{TypeQuelconque& typQ = noo->ModifGrandeur_quelconque(enuq); // récup du conteneur du noeud
// récup de la grandeur
Grandeur_coordonnee* gcoor = (Grandeur_coordonnee*) typQ.Grandeur_pointee();
Coordonnee& conoe = *(gcoor->ConteneurCoordonnee()); // les coordonnées
switch (dim) // on rempli les coordonnées
{ case 3: conoe(3)=vect(ivect+2);
case 2: conoe(2)=vect(ivect+1);
case 1: conoe(1)=vect(ivect);
};
ivect +=dim;
break;
}
default:
cout << "\n ** erreur, pour l'instant le transfert vers les noeuds de "
<< (enuq.NomPlein()) << " n'est pas implante ... le demander !! "
<< "\n LesMaillages::Quelconque_glob_vers_local(..."<<endl;
Sortie(1);
}
}
else //on ne fait que décaler le pointeur dans le vecteur pour la suite
{ ivect += nb_val_typeQuelconque;};
};
};
};
};
// retourne la liste des types de ddl principaux actuellement utilisé
// aux noeuds pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les noeud du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau <List_io <Ddl_enum_etendu> > LesMaillages::Les_type_de_ddl_par_noeud(bool absolue)
{ // def de la liste de retour
Tableau <List_io <Ddl_enum_etendu> > tab_ret_enum(nbMaillageTotal);
// on boucle sur les maillages
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ // vecteur intermédiaire dont la taille peut augmenter
List_io <Enum_ddl> tab_enu_final;
// on boucle sur les noeuds
int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// recup du tableau de type de ddl associé
List_io <Enum_ddl> tab_enum_ddl(noo->Les_type_de_ddl(absolue));
tab_enum_ddl.sort(); // ordonne la liste
tab_enu_final.merge(tab_enum_ddl); // ajout de la liste
tab_enu_final.unique(); // supprime les doublons
};
// mise à jour du tableau global
List_io <Ddl_enum_etendu> tab_enu_etendu_final;
List_io <Ddl_enum_etendu> tab_inter = Ddl_enum_etendu::TransfoList_io(tab_enu_final);
tab_inter.sort();
tab_enu_etendu_final.merge(tab_inter);tab_enu_etendu_final.unique();
tab_ret_enum(i1) = tab_enu_etendu_final;
}
return tab_ret_enum; // retour du tableau
};
// retourne la liste des types de ddl étendu actuellement utilisé
// aux noeuds pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les noeud du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau <List_io <Ddl_enum_etendu> > LesMaillages::Les_type_de_ddl_etendu_par_noeud(bool absolue)
{ // def de la liste de retour
Tableau <List_io <Ddl_enum_etendu> > tab_ret_enum(nbMaillageTotal);
// on boucle sur les maillages
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ // vecteur intermédiaire dont la taille peut augmenter pour les ddl étendus
List_io <Ddl_enum_etendu> tab_enu_etendu_final;
// on boucle sur les noeuds
int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// recup du tableau de type de ddl étendues
List_io <Ddl_enum_etendu> tab_enum_etendu_ddl(noo->Les_type_de_ddl_etendu( absolue));
tab_enum_etendu_ddl.sort(); // ordonne la liste
tab_enu_etendu_final.merge(tab_enum_etendu_ddl); // ajout de la liste
tab_enu_etendu_final.unique(); // supprime les doublons
};
// mise à jour du tableau global
tab_ret_enum(i1) = tab_enu_etendu_final;
}
return tab_ret_enum; // retour du tableau
};
// retourne la liste des types quelconque actuellement utilisé
// aux noeuds pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les noeud du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau <List_io <TypeQuelconque> > LesMaillages::Les_type_de_TypeQuelconque_par_noeud(bool absolue)
{ // def de la liste de retour
Tableau <List_io <TypeQuelconque> > tab_ret_enum(nbMaillageTotal);
// grandeurs de travail
int dim = ParaGlob::Dimension();
Coordonnee coor(dim); // un type coordonnee typique
// maintenant on définit une grandeur typique de type Grandeur_coordonnee
Grandeur_coordonnee gt(coor);
TypeQuelconque typQ(VECT_REAC_N,X1,gt);
// // idem pour la variation de position entre t et t+dt
// TypeQuelconque typQ2(DELTA_XI,X1,gt);
// on boucle sur les maillages
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ // vecteur intermédiaire dont la taille peut augmenter pour les ddl étendus
List_io <TypeQuelconque> tab_enu_etendu_final;
// on boucle sur les noeuds
int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// recup du tableau de tous les TypeQuelconque disponibles au noeud
List_io <TypeQuelconque> tab_enum_etendu_ddl(noo->Les_TypeQuelconque(absolue));
// --- on rajoute les réactions par défaut
// sous forme d'un vecteur
tab_enum_etendu_ddl.push_back(typQ);
// Pour l'instant ce n'est pas fini donc on met en commentaire, sinon c'est pas clair
// pour l'utilisateur !!
// // --- on ajoute le delta des positions
// tab_enum_etendu_ddl.push_back(typQ2);
// -- on traite
tab_enum_etendu_ddl.sort(); // ordonne la liste
tab_enu_etendu_final.merge(tab_enum_etendu_ddl); // ajout de la liste
tab_enu_etendu_final.unique(); // supprime les doublons
};
// mise à jour du tableau global
tab_ret_enum(i1) = tab_enu_etendu_final;
}
return tab_ret_enum; // retour du tableau
};
// intro de certains conteneurs internes en relation par exemple avec les demandes de visualisation
// ou autre
// exemple: si VECT_REAC_N qui est un type quelconque, a été choisit
// il faut qu'il soit présent aux noeuds, alors qu'il est alimenter par les ddl pur ...
// on introduit donc le type quelconque associé
// NB: le conteneur passé en paramètre ne sert que pour localiser les grandeurs
void LesMaillages::Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur
( const List_io < TypeQuelconque > & glob_noeud_evol_retenu)
{
// grandeurs de travail
int dim = ParaGlob::Dimension();
Coordonnee coor(dim); // un type coordonnee typique
// maintenant on définit une grandeur typique de type Grandeur_coordonnee
Grandeur_coordonnee gt(coor);
TypeQuelconque typQ2(VECT_REAC_N,X1,gt);
List_io <TypeQuelconque>::const_iterator il,ilfin=glob_noeud_evol_retenu.end();
for (int i= 1;i<= nbMaillageTotal; i++)
{for (il=glob_noeud_evol_retenu.begin();il != ilfin; il++)
{ TypeQuelconque_enum_etendu enuQ = (*il).EnuTypeQuelconque();
// on passe en revue les types concernés
if (enuQ == VECT_REAC_N)
// il faut alors vérifier que le conteneur existe aux noeuds
{// on boucle sur les noeuds
int nbnoeudmax = tabMaillage(i)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i,i2);
if (!(noo->Existe_ici(enuQ)))
// cas où on n'a pas le type présent, on l'introduit
{noo->AjoutUnTypeQuelconque(typQ2);};
};
};
};
};
};
// idem que Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur
// mais ciblé en fonction d'un tableau indicé sur les maillages
void LesMaillages::Intro_Conteneurs_internes_noeud_relier_auto_autres_grandeur
( const Tableau < List_io < TypeQuelconque > > & tab_noeud_evol_retenu)
{
// grandeurs de travail
int dim = ParaGlob::Dimension();
Coordonnee coor(dim); // un type coordonnee typique
// maintenant on définit une grandeur typique de type Grandeur_coordonnee
Grandeur_coordonnee gt(coor);
TypeQuelconque typQ2(VECT_REAC_N,X1,gt);
for (int i= 1;i<= nbMaillageTotal; i++)
{List_io <TypeQuelconque>::const_iterator il,ilfin=tab_noeud_evol_retenu(i).end();
for (il=tab_noeud_evol_retenu(i).begin();il != ilfin; il++)
{TypeQuelconque_enum_etendu enuQ = (*il).EnuTypeQuelconque();
// on passe en revue les types concernés
if (enuQ == VECT_REAC_N)
// il faut alors vérifier que le conteneur existe aux noeuds
{// on boucle sur les noeuds
int nbnoeudmax = tabMaillage(i)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i,i2);
if (!(noo->Existe_ici(enuQ)))
// cas où on n'a pas le type présent, on l'introduit
{noo->AjoutUnTypeQuelconque(typQ2);};
};
};
};
};
};
// retourne la liste des types de ddl actuellement utilisé
// aux éléments pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les éléments du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
Tableau <List_io <Ddl_enum_etendu> > LesMaillages::Les_type_de_ddl_par_element(bool absolue)
{ // def de la liste de retour
Tableau <List_io <Ddl_enum_etendu> > tab_ret_enum(nbMaillageTotal);
// on boucle sur les maillages
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ // vecteur intermédiaire dont la taille peut augmenter
List_io <Ddl_enum_etendu> tab_enu_final;
// on définit une liste de signature d'élément, ce qui permet de tester que les types d'éléments différents
list <Element::Signature> list_signature_elem;
// on boucle sur les elements
int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ // recup du element
Element * nee = & Element_LesMaille(i1,i2);
// recup du tableau de type de ddl associé
// on regarde si un élément de même type n'a pas déjà été considéré
if (find(list_signature_elem.begin(),list_signature_elem.end(),nee->Signature_element())==list_signature_elem.end())
{ // nouveau type d'élément , on récupère les données particulières
List_io <Ddl_enum_etendu> tab_enum_ddl(nee->Les_type_de_ddl_internes(absolue));
tab_enu_final.sort(); // ordonne la liste
tab_enu_final.merge(tab_enum_ddl); // ajout de la liste
tab_enu_final.unique(); // supprime les doublons
// on ajoute la signature
list_signature_elem.push_back(nee->Signature_element());
};
}
// mise à jour du tableau global
tab_ret_enum(i1) = tab_enu_final;
}
return tab_ret_enum; // retour du tableau
};
// retourne la liste des grandeurs évoluées interne actuellement utilisés
// par les éléments, c'est-à-dire comme les ddl mais directement sous forme de vecteur, tenseurs ...,
// la liste est exhaustive, elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que la donnée particulière en question soit présent
// pour tous les éléments du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
// absolue: indique si oui ou non on sort les tenseurs dans la base absolue ou une base particulière
Tableau <List_io <TypeQuelconque> > LesMaillages::Les_type_de_donnees_evolues_internes_par_element(bool absolue)
{ // def de la liste de retour
Tableau <List_io <TypeQuelconque> > tab_ret_enum(nbMaillageTotal);
// on définit une liste de signature d'élément, ce qui permet de tester que les types d'éléments différents
list <Element::Signature> list_signature_elem;
// on boucle sur les maillages
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ // liste intermédiaire dont la taille peut augmenter
List_io <TypeQuelconque> tab_enu_final;
list_signature_elem.clear();
// on boucle sur les elements
int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ // recup de l'element
Element * nee = & Element_LesMaille(i1,i2);
// on regarde si un élément de même type n'a pas déjà été considéré
if (find(list_signature_elem.begin(),list_signature_elem.end(),nee->Signature_element())==list_signature_elem.end())
{ // nouveau type d'élément , on récupère les données particulières
// les opérations qui suivent sont assez longues mais normalement n'arrives pas souvent
// recup du tableau de type de données particulières associées
List_io <TypeQuelconque> tab_enum_parti(nee->Les_type_evolues_internes(absolue));
tab_enu_final.sort(); // ordonne la liste
tab_enum_parti.sort(); // idem la nouvelle
tab_enu_final.merge(tab_enum_parti); // ajout de la liste
tab_enu_final.unique(); // supprime les doublons
// on ajoute la signature
list_signature_elem.push_back(nee->Signature_element());
};
};
// mise à jour du tableau global
tab_ret_enum(i1) = tab_enu_final;
};
return tab_ret_enum; // retour du tableau
};
// retourne la liste des types de données particulières actuellement utilisés
// aux éléments pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que la donnée particulière en question soit présent
// pour tous les éléments du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau <List_io <TypeQuelconque> > LesMaillages::Les_type_de_donnees_particulieres_par_element(bool absolue)
{ // def de la liste de retour
Tableau <List_io <TypeQuelconque> > tab_ret_enum(nbMaillageTotal);
// on boucle sur les maillages
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ // vecteur intermédiaire dont la taille peut augmenter
List_io <TypeQuelconque> tab_enu_final;
// on définit une liste de signature d'élément, ce qui permet de tester que les types d'éléments différents
list <Element::Signature> list_signature_elem;
// on boucle sur les elements
int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ // recup du element
Element * nee = & Element_LesMaille(i1,i2);
// on regarde si un élément de même type n'a pas déjà été considéré
if (find(list_signature_elem.begin(),list_signature_elem.end(),nee->Signature_element())==list_signature_elem.end())
{ // nouveau type d'élément , on récupère les données particulières
// les opérations qui suivent sont assez longues mais normalement n'arrives pas souvent
// recup du tableau de type de données particulières associées
List_io <TypeQuelconque> tab_enum_parti(nee->Les_types_particuliers_internes(absolue));
tab_enu_final.sort(); // ordonne la liste
tab_enu_final.merge(tab_enum_parti); // ajout de la liste
tab_enu_final.unique(); // supprime les doublons
// on ajoute la signature
list_signature_elem.push_back(nee->Signature_element());
};
};
// mise à jour du tableau global
tab_ret_enum(i1) = tab_enu_final;
};
//----- debug
// cout << "\n debug LesMaillages::Les_type_de_donnees_particulieres_par_element "
// << tab_ret_enum << endl;
// ------ fin debug
return tab_ret_enum; // retour du tableau
};
// Au niveau des noeuds: transfert des coordonnées de grandeurs vectorielles à des grandeurs évoluées
// stockée sous forme de grandeurs TypeQuelconque
// exemple: les réactions qui sont naturellement stockée en composantes
// le principe est que ce passage s'effectue si les conteneurs existent au niveau des noeuds
void LesMaillages::PassageInterneDansNoeud_composantes_vers_vectorielles()
{
int dim = ParaGlob::Dimension(); // dimension du pb
if(ParaGlob::AxiSymetrie())
dim--; // en axisymétrie on récupère uniquement les forces en x et y
// on boucle sur les maillages puis sur les noeuds
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// --- cas des réactions:
{// on regarde si le conteneur existe, si oui on transfert, si non, on passe les valeurs
EnumTypeQuelconque enuq = VECT_REAC_N;
if ((noo->Existe_ici(enuq)) && (noo->Existe_ici(R_X1)))
{TypeQuelconque& typQ = noo->ModifGrandeur_quelconque(enuq); // récup du conteneur du noeud
// récup de la grandeur
Grandeur_coordonnee* gcoor = (Grandeur_coordonnee*) typQ.Grandeur_pointee();
Coordonnee& conoe = *(gcoor->ConteneurCoordonnee()); // les coordonnées
switch (dim) // on rempli les coordonnées
{ case 3: conoe(3)=noo->Valeur_tdt(R_X3);
case 2: conoe(2)=noo->Valeur_tdt(R_X2);
case 1: conoe(1)=noo->Valeur_tdt(R_X1);
};
};
};
};
};
};
// retourne la liste des types de grandeur quelconque actuellement utilisé
// aux faces élément pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que la grandeur en question soit présent
// pour tous les éléments du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau <List_io <TypeQuelconque> > LesMaillages::Les_type_de_donnees_evolues_internes_par_face_element(bool absolue)
{ // def de la liste de retour
Tableau <List_io <TypeQuelconque> > tab_ret_enum(nbMaillageTotal);
// on boucle sur les maillages
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ // vecteur intermédiaire dont la taille peut augmenter
List_io <TypeQuelconque> tab_enu_final;
// on définit une liste de signature d'élément, ce qui permet de tester que les types d'éléments différents
list <Element::Signature> list_signature_elem;
// on boucle sur les elements
int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ // recup du element
Element * nee = & Element_LesMaille(i1,i2);
// on regarde si un élément de même type n'a pas déjà été considéré
if (find(list_signature_elem.begin(),list_signature_elem.end(),nee->Signature_element())==list_signature_elem.end())
{ // nouveau type d'élément , on récupère les données particulières
// les opérations qui suivent sont assez longues mais normalement n'arrives pas souvent
// recup du tableau de type de données particulières associées
List_io <TypeQuelconque> tab_enum_parti(nee->Les_type_quelconque_de_face(absolue));
tab_enu_final.sort(); // ordonne la liste
tab_enu_final.merge(tab_enum_parti); // ajout de la liste
tab_enu_final.unique(); // supprime les doublons
// on ajoute la signature
list_signature_elem.push_back(nee->Signature_element());
};
};
// mise à jour du tableau global
tab_ret_enum(i1) = tab_enu_final;
};
//----- debug
// cout << "\n debug LesMaillages::Les_type_de_donnees_evolues_internes_par_face_element "
// << tab_ret_enum << endl;
// ------ fin debug
return tab_ret_enum; // retour du tableau
};
// retourne la liste des types de grandeur quelconque actuellement utilisé
// aux arêtes élément pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que la grandeur en question soit présent
// pour tous les éléments du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
Tableau <List_io <TypeQuelconque> > LesMaillages::Les_type_de_donnees_evolues_internes_par_arete_element(bool absolue)
{ // def de la liste de retour
Tableau <List_io <TypeQuelconque> > tab_ret_enum(nbMaillageTotal);
// on boucle sur les maillages
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ // vecteur intermédiaire dont la taille peut augmenter
List_io <TypeQuelconque> tab_enu_final;
// on définit une liste de signature d'élément, ce qui permet de tester que les types d'éléments différents
list <Element::Signature> list_signature_elem;
// on boucle sur les elements
int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ // recup du element
Element * nee = & Element_LesMaille(i1,i2);
// on regarde si un élément de même type n'a pas déjà été considéré
if (find(list_signature_elem.begin(),list_signature_elem.end(),nee->Signature_element())==list_signature_elem.end())
{ // nouveau type d'élément , on récupère les données particulières
// les opérations qui suivent sont assez longues mais normalement n'arrives pas souvent
// recup du tableau de type de données particulières associées
List_io <TypeQuelconque> tab_enum_parti(nee->Les_type_quelconque_de_arete(absolue));
tab_enu_final.sort(); // ordonne la liste
tab_enu_final.merge(tab_enum_parti); // ajout de la liste
tab_enu_final.unique(); // supprime les doublons
// on ajoute la signature
list_signature_elem.push_back(nee->Signature_element());
};
};
// mise à jour du tableau global
tab_ret_enum(i1) = tab_enu_final;
};
//----- debug
// cout << "\n debug LesMaillages::Les_type_de_donnees_evolues_internes_par_arete_element "
// << tab_ret_enum << endl;
// ------ fin debug
return tab_ret_enum; // retour du tableau
};
// initialisation d'un ou ne plusieurs nouveaux cas d'assemblage
// ramène le numéro du premier nouveau cas d'assemblage
Nb_assemb LesMaillages::InitNouveauCasAssemblage(int nb_cas)
{ // on récupère le nombre actuel de cas d'assemblage
int nb_actuel = tab_nb_assemb;
// on parcours le noeud pour les dimensionner aux nouveaux cas d'assemblage
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// initialisation
noo->InitNouveauCasAssemb(nb_cas);
}
}
// dans le cas ou nb_cas est null pb
#ifdef MISE_AU_POINT
if (nb_cas == 0)
{ cout << "\n erreur, le nombre de nouveau cas d'assemblage demandé est nul !!"
<< " \n LesMaillages::InitNouveauCasAssemblage(int nb_cas) " ;
Sortie(1);
}
#endif
// mise à jour du nombre de cas d'assemblage
tab_nb_assemb += nb_cas;
// mise à jour du tableau t_i_n
t_i_n.Change_taille(tab_nb_assemb);
// retour du premier nouveau cas d'assemblage
nb_actuel++;
return Nb_assemb(nb_actuel);
};
// met a jour les pointeurs d'assemblage dans les noeuds
// et enregistre les ddl_actifs et leurs ordres au niveau des noeuds
// a effectuer si l'on a changer de nb de noeuds, de nb de ddl, de nb de maillage
// casAssemb : donne le cas d'assemblage qui est a considérer
void LesMaillages::MiseAJourPointeurAssemblage(const Nb_assemb& casAssemb)
{ // pour la construction du tableau t_i_n pour le cas d'assemblage
// on utilise une liste intermédiaire car on ne connait pas le nombre d'élément final
list <Posi_ddl_noeud> list_in ;
// definition de la position globale d'assemblage
int pointeur=0 ; // position d'assemblage
int nb_assemb = casAssemb.n;
bool absolue = true; // par défaut on travaille en absolu, mais en fait
// cela n'a pas d'importance ici, car on n'utilise que le type
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// enregistrement des variables ddl actives
noo->Enreg_ordre_variable_ddl_actives(nb_assemb);
// on change le pointeur
noo->ChangePosiAssemb(pointeur,nb_assemb);
// récup de tous les ddl du noeud
List_io <Enum_ddl> list_ddl = noo->Les_type_de_ddl(absolue);
// on définit le tableau d'indexage t_in
List_io <Enum_ddl>::iterator ie,iefin=list_ddl.end();
for(ie=list_ddl.begin();ie!=iefin;ie++)
{ if (noo->En_service(*ie) && noo->UneVariable(*ie))
// si le ddl est en service on l'enregistre
{Posi_ddl_noeud posi(i1,*ie,noo->Num_noeud());
list_in.push_back(posi);
pointeur++;
}
}
}
}
// construction du tableau t_i_n pour le cas d'assemblage
Tableau <Posi_ddl_noeud> & t_in = t_i_n(nb_assemb); // pour simplifier
int taille_tab = (int) list_in.size(); // la taille finale
t_in.Change_taille(taille_tab); int i;
list<Posi_ddl_noeud>::iterator ile;
for (i=1,ile=list_in.begin();i<=taille_tab;i++,ile++)
t_in(i) = (*ile);
};
// met a jour les pointeurs d'assemblage dans les noeuds pour un cas d'assemblage
// a effectuer si l'on a changer de nb de noeuds, de nb de ddl, de nb de maillage
// casAssemb : donne le cas d'assemblage qui est a considérer
// ici, l'assemblage suit l'ordre du tableau de noeud passé en paramètre
// le tableau de noeuds rassemble tous les noeuds des maillages mais avec une numérotation propre
void LesMaillages::MiseAJourPointeurAssemblage_interne
(const Nb_assemb& casAssemb,Tableau <Noeud* >& tab_N_final)
{ // pour la construction du tableau t_i_n pour le cas d'assemblage
// on utilise une liste intermédiaire car on ne connait pas le nombre d'élément final
list <Posi_ddl_noeud> list_in ;
// definition de la position globale d'assemblage
int pointeur=0 ; // position d'assemblage
int nb_assemb = casAssemb.n;
bool absolue = true; // par défaut on travaille en absolu, mais en fait
// cela n'a pas d'importance ici, car on n'utilise que le type
int nb_noeud = tab_N_final.Taille();
for (int i = 1; i<= nb_noeud; i++)
{ // recup du noeud
Noeud * noo = tab_N_final(i);
//if (noo->Num_noeud() != i)
// cout << "\n debug LesMaillages::MiseAJourPointeurAssemblage_interne "
// << " noo->Num_noeud()= "<< noo->Num_noeud() << " i= " << i << endl;
// enregistrement des variables ddl actives
noo->Enreg_ordre_variable_ddl_actives(nb_assemb);
// on change le pointeur
noo->ChangePosiAssemb(pointeur,nb_assemb);
// récup de tous les ddl du noeud
List_io <Enum_ddl> list_ddl = noo->Les_type_de_ddl(absolue);
// on définit le tableau d'indexage t_in
List_io <Enum_ddl>::iterator ie,iefin=list_ddl.end();
for(ie=list_ddl.begin();ie!=iefin;ie++)
{ if (noo->En_service(*ie) && noo->UneVariable(*ie))
// si le ddl est en service on l'enregistre
{Posi_ddl_noeud posi(noo->Num_Mail(),*ie,noo->Num_noeud());
list_in.push_back(posi);
pointeur++;
}
};
};
// construction du tableau t_i_n pour le cas d'assemblage
Tableau <Posi_ddl_noeud> & t_in = t_i_n(nb_assemb); // pour simplifier
int taille_tab = (int) list_in.size(); // la taille finale
t_in.Change_taille(taille_tab); int i;
list<Posi_ddl_noeud>::iterator ile;
for (i=1,ile=list_in.begin();i<=taille_tab;i++,ile++)
t_in(i) = (*ile);
};
// remise à jour des tableaux de pointeurs t_i_n uniquement, due à un changement de numéro de noeud
// en fonction d'un changement de num de noeud (mais pas de changement de pointeur d'assemblage
// 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()
void LesMaillages::MiseAJourTableau_t_i_n(const Nb_assemb& nb_casAssemb,Tableau <Noeud* >& tab_N_final)
{ int nb_assemb = nb_casAssemb.n;
// le tableau t_i_n pour le cas d'assemblage
Tableau <Posi_ddl_noeud> & t_in = t_i_n(nb_assemb); // pour simplifier
// pour mémoire un élément Posi_ddl_noeud // données
// int nb_maillage; // le numéro du maillage
// int nb_noeud; // le numéro du noeud
// Enum_ddl enu; // l'identifieur du ddl
int taille_tab = t_in.Taille();
for (int i=1;i<= taille_tab;i++)
{ int ancien_num_noeud = t_in(i).Nb_noeud();
int nouveau_num_noeud = tab_N_final(ancien_num_noeud)->Num_noeud();
t_in(i).Nb_noeud() = nouveau_num_noeud;
////--- vérif debug
//Coordonnee co = Noeud_LesMaille(t_in(i).Nb_maillage(),t_in(i).Nb_noeud()).Coord0();
//if (i==taille_tab)
// cout << "\n debug LesMaillages::MiseAJourTableau_t_i_n "<< co << endl;
////-- fin debug
};
};
// mise a zero de tous les ddl actifs autres que les deplacements
// si indic = false; pas de creation des tableaux a t+dt
// si indic = true; creation des tableaux a t+dt
// cas = true; les coordonnées à t et éventuellement à t+dt sont initialisées
// aux valeurs de t=0, sinon on ne les modifies pas
void LesMaillages::ZeroDdl(bool indic,bool cas)
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// if (i2 >= 583)
// {
// //debug
// cout << "\n debug LesMaillages::ZeroDdl ";
// cout << "\n pb coordonnee 2 noeud 583 ";
// // fin debug
// }
if (indic) // construit les tableaux de ddl a t+dt selon indic
noo->Travail_tdt();
// if ((i2 >= 583)&&(!(tabMaillage(1)->Noeud_mail(583).ExisteCoord2())))
// {
// //debug
// cout << "\n debug LesMaillages::ZeroDdl ";
// cout << "\n pb coordonnee 2 noeud 583 ";
// // fin debug
// }
noo->ZeroVariablesDdl(cas);
}
}
////debug
//cout << "\n debug LesMaillages::ZeroDdl ";
//cout << "\n coordonnees0 du noeud 583 ";
//tabMaillage(1)->Noeud_mail(583).Coord0().Affiche();
//
//tabMaillage(1)->Noeud_mail(583).Coord2().Affiche();
//// fin debug
};
// ramene la demi largeur de bande en ddl et la largeur de bande
// casAssemb : donne le cas d'assemblage qui est a considérer
void LesMaillages::Largeur_Bande(int& demi, int& total,const Nb_assemb& casAssemb)
{ int demib =0;
int totalb = 0;
demi = 0; total = 0;
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ demib =0;
totalb = 0;
tabMaillage(i1)->Largeur_Bande(demib,totalb,casAssemb);
if (demib > demi) demi = demib;
if (totalb > total ) total = totalb;
}
};
// méthode permettant le calcul des matrices de connexion pour chaque
// élément ceci par rapport à la numérotation absolu des ddl
// casAssemb : donne le cas d'assemblage qui est a considérer
// les petites matrices sont carrées, ils sont définit par un tableau ligne qui contiend
// la position d'un terme de la petite matrice dans la grande matrice
// exemple : pet_mat(k)(i), pet_mat(k)(j) : indique le numéro de ligne et le numéro de colonne
// d'un élément non nul dans la grande matrice
void LesMaillages::Table_connexion
(Tableau < Tableau <int> >& pet_mat_mat,const Nb_assemb& casAssemb) const
{ // calcul du nombre d'élément totaux
int nbelem=0;
for (int i = 1; i<= nbMaillageTotal; i++)
nbelem += Nombre_element(i);
// on dimensionne le tableau en conséquence
pet_mat_mat.Change_taille(nbelem);
// récup du numéro d'assemblage
int nb_casAssemb = casAssemb.n;
// on passe en revue tous les éléments et on rempli de tableau
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelmax = Nombre_element(i1);
for (int jel = 1; jel <= nbelmax; jel++)
{ // récup de l'élément
Element& elem = tabMaillage(i1)->Element_mail(jel);
Tableau <int> & tabb = (pet_mat_mat(jel)); // simplification
const Tableau<Noeud *>& tab_noeud = elem.Tab_noeud (); // recup tab_noeud
const DdlElement & tab_ddl = elem.TableauDdl(); // tableau des ddl
// dimensionnement du tableau de connexion
tabb.Change_taille(tab_ddl.NbDdl());
// differents indices de lignes
int iloc, inoeud ;
// boucle sur les noeuds de l'element
int inoeud_max = tab_noeud.Taille();
for ( inoeud=1,iloc=1; inoeud<= inoeud_max; inoeud++)
{Noeud& noei = *(tab_noeud(inoeud)); // simplification
// boucle sur les ddl du noeudElement
int ni_nbddl = tab_ddl.NbDdl(inoeud);
for (int i = 1;i<= ni_nbddl ;i++,iloc++)
// enregistrement de la position si le pointeur d'assemblage est valide
{ int pt = noei.Pointeur_assemblage(tab_ddl(inoeud,i),nb_casAssemb);
if (pt != -1)
tabb(iloc) = pt;
}
} // fin de la boucle sur les noeuds de l'élément
} // fin de la boucle sur les éléments d'un maillage
} // fin de la boucle sur les maillages
};
// actualisation des ddl et des grandeurs actives de t+dt vers t
void LesMaillages::TdtversT()
{// tout d'abord on s'occupe des ddl
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
Noeud_LesMaille(i1,i2).TdtversT();
};
// puis on s'occupe des éléments
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ Element & elem = Element_LesMaille(i1,i2);
elem.TdtversT();
}
}
// cas des intégrales et on alimente les grandeurs globales
{int taille = integ_vol_typeQuel.Taille();
for (int il =1;il <= taille ;il++)
if (ref_integ_vol(il) != NULL) // si NULL => la grandeur reste fixe et n'est pas intégrée
{TypeQuelconque& TQ_t = integ_vol_typeQuel_t(il); // pour simplifier
TypeQuelconque& TQ = integ_vol_typeQuel(il); // pour simplifier
// transfert des intégrales finalisées
(TQ_t.Grandeur_pointee())->Affectation_numerique(*(TQ.Grandeur_pointee()));
// !! non ce sera fait dans l'intégration, et il vaut mieux garder une valeur correcte
// TQ.Grandeur_pointee()->InitParDefaut(); // on initialise pour le prochain calcul
// cas des grandeurs à t: on alimente les grandeurs globales
// le conteneur qui contient le résultat globalisé
// --> au début les grandeurs auront les mêmes valeurs à t et tdt
TypeQuelconque::Grandeur* g_TG_t = TQ_t.Grandeur_pointee();
const string* nom_de_ref = g_TG_t->Nom_ref();
#ifdef MISE_AU_POINT
if (nom_de_ref == NULL)
{ cout << "\n *** pb dans l'integration !! "
<< " nom_de_ref est nul, on ne peut pas continuer "
<< "\n LesMaillages::TdtversT()"<<endl;
Sortie(1);
};
#endif
// récup du pointeur de conteneur
const void* pointe = (ParaGlob::param->GrandeurGlobal(*nom_de_ref));
#ifdef MISE_AU_POINT
if (pointe == NULL)
{ cout << "\n *** pb dans l'integration !! "
<< " la variable globale "<< (*nom_de_ref)
<< ", n'est pas disponible, on ne peut pas continuer "
<< "\n LesMaillages::TdtversT()"<<endl;
Sortie(1);
};
#endif
// on l'affecte
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
(gr_quelc->Grandeur_pointee())->Affectation_numerique(*(g_TG_t));
};
};
// on réinitialise également les grandeurs à 0, car le calcul est fait dans les éléments
// et le stockage à t est sauvegardé dans les éléments, du coup si on n'initialise pas ici
// au final on aura 2 fois l'intégrale à chaque pas de temps !!
{int taille = integ_vol_t_typeQuel.Taille();
for (int il =1;il <= taille ;il++)
if (ref_integ_vol_t(il) != NULL) // si ==NULL => la grandeur reste fixe et n'est pas intégrée
{TypeQuelconque& TQ_t = integ_vol_t_typeQuel_t(il); // pour simplifier
TypeQuelconque& TQ = integ_vol_t_typeQuel(il); // pour simplifier
// transfert des intégrales finalisées
(TQ_t.Grandeur_pointee())->Affectation_numerique(*(TQ.Grandeur_pointee()));
// !! non ce sera fait dans l'intégration, et il vaut mieux garder une valeur correcte
// TQ.Grandeur_pointee()->InitParDefaut(); // on initialise pour le prochain calcul
// cas des grandeurs à t: on alimente les grandeurs globales
// le conteneur qui contient le résultat globalisé
// --> au début les grandeurs auront les mêmes valeurs à t et tdt
TypeQuelconque::Grandeur* g_TG_t = TQ_t.Grandeur_pointee();
const string* nom_de_ref = g_TG_t->Nom_ref();
#ifdef MISE_AU_POINT
if (nom_de_ref == NULL)
{ cout << "\n *** pb dans l'integration !! "
<< " nom_de_ref est nul, on ne peut pas continuer "
<< "\n LesMaillages::TdtversT()"<<endl;
Sortie(1);
};
#endif
// récup du pointeur de conteneur
const void* pointe = (ParaGlob::param->GrandeurGlobal(*nom_de_ref));
#ifdef MISE_AU_POINT
if (pointe == NULL)
{ cout << "\n *** pb dans l'integration !! "
<< " la variable globale "<< (*nom_de_ref)
<< ", n'est pas disponible, on ne peut pas continuer "
<< "\n LesMaillages::TdtversT()"<<endl;
Sortie(1);
};
#endif
// on l'affecte
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
(gr_quelc->Grandeur_pointee())->Affectation_numerique(*(g_TG_t));
};
};
// cas des statistiques et on alimente les grandeurs globales
{int taille = statistique_typeQuel.Taille();
for (int il =1;il <= taille ;il++)
if (ref_statistique(il) != NULL) // si NULL => la grandeur reste fixe et n'est pas calculée
{TypeQuelconque& TQ_t = statistique_typeQuel_t(il); // pour simplifier
TypeQuelconque& TQ = statistique_typeQuel(il); // pour simplifier
// transfert des statistiques finalisées
(TQ_t.Grandeur_pointee())->Affectation_numerique(*(TQ.Grandeur_pointee()));
// cas des grandeurs à t: on alimente les grandeurs globales
// le conteneur qui contient le résultat globalisé
// --> au début les grandeurs auront les mêmes valeurs à t et tdt
TypeQuelconque::Grandeur* g_TG_t = TQ_t.Grandeur_pointee();
const string* nom_de_ref = g_TG_t->Nom_ref();
#ifdef MISE_AU_POINT
if (nom_de_ref == NULL)
{ cout << "\n *** pb dans statistique !! "
<< " nom_de_ref est nul, on ne peut pas continuer "
<< "\n LesMaillages::TdtversT()"<<endl;
Sortie(1);
};
#endif
// récup du pointeur de conteneur
const void* pointe = (ParaGlob::param->GrandeurGlobal(*nom_de_ref));
#ifdef MISE_AU_POINT
if (pointe == NULL)
{ cout << "\n *** pb dans statistique !! "
<< " la variable globale "<< (*nom_de_ref)
<< ", n'est pas disponible, on ne peut pas continuer "
<< "\n LesMaillages::TdtversT()"<<endl;
Sortie(1);
};
#endif
// on l'affecte
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
(gr_quelc->Grandeur_pointee())->Affectation_numerique(*(g_TG_t));
};
};
// on réinitialise également les grandeurs à 0, car le calcul est fait dans les éléments
// et le stockage à t est sauvegardé dans les éléments, du coup si on n'initialise pas ici
// au final on aura 2 fois l'intégrale à chaque pas de temps !!
{int taille = statistique_t_typeQuel.Taille();
for (int il =1;il <= taille ;il++)
if (ref_statistique_t(il) != NULL) // si ==NULL => la grandeur reste fixe et n'est pas intégrée
{TypeQuelconque& TQ_t = statistique_t_typeQuel_t(il); // pour simplifier
TypeQuelconque& TQ = statistique_t_typeQuel(il); // pour simplifier
// transfert des statistiques finalisées
(TQ_t.Grandeur_pointee())->Affectation_numerique(*(TQ.Grandeur_pointee()));
// !! non ce sera fait dans l'intégration, et il vaut mieux garder une valeur correcte
// TQ.Grandeur_pointee()->InitParDefaut(); // on initialise pour le prochain calcul
// cas des grandeurs à t: on alimente les grandeurs globales
// le conteneur qui contient le résultat globalisé
// --> au début les grandeurs auront les mêmes valeurs à t et tdt
TypeQuelconque::Grandeur* g_TG_t = TQ_t.Grandeur_pointee();
const string* nom_de_ref = g_TG_t->Nom_ref();
#ifdef MISE_AU_POINT
if (nom_de_ref == NULL)
{ cout << "\n *** pb dans statistique avec cumul en temps !! "
<< " nom_de_ref est nul, on ne peut pas continuer "
<< "\n LesMaillages::TdtversT()"<<endl;
Sortie(1);
};
#endif
// récup du pointeur de conteneur
const void* pointe = (ParaGlob::param->GrandeurGlobal(*nom_de_ref));
#ifdef MISE_AU_POINT
if (pointe == NULL)
{ cout << "\n *** pb dans statistique avec cumul en temps !! "
<< " la variable globale "<< (*nom_de_ref)
<< ", n'est pas disponible, on ne peut pas continuer "
<< "\n LesMaillages::TdtversT()"<<endl;
Sortie(1);
};
#endif
// on l'affecte
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
(gr_quelc->Grandeur_pointee())->Affectation_numerique(*(g_TG_t));
};
};
};
// actualisation des ddl et des grandeurs actives de t vers tdt
void LesMaillages::TversTdt()
{// tout d'abord on s'occupe des ddl
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
Noeud_LesMaille(i1,i2).TversTdt();
};
// puis on s'occupe des éléments
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ Element & elem = Element_LesMaille(i1,i2);
elem.TversTdt();
}
};
// -- cas des intégrales de volumes
// on réinitialise les grandeurs qui vont être calculée
// ceux à t ne changent pas
{int taille = integ_vol_typeQuel.Taille();
for (int il =1;il <= taille ;il++)
if (ref_integ_vol(il) != NULL) // si == NULL => la grandeur reste fixe et n'est pas intégrée
{TypeQuelconque& TQ = integ_vol_typeQuel(il); // pour simplifier
TypeQuelconque& TQ_t = integ_vol_typeQuel_t(il); // pour simplifier
// transfert des intégrales finalisées
(TQ.Grandeur_pointee())->Affectation_numerique(*(TQ_t.Grandeur_pointee()));
// !! non ce sera fait dans l'intégration, et il vaut mieux garder une valeur correcte
// TQ.Grandeur_pointee()->InitParDefaut();
// cas des grandeurs à tdt: on alimente les grandeurs globales
// le conteneur qui contient le résultat globalisé
// donc on le remet à du pas précédent à t
TypeQuelconque::Grandeur* g_TG = TQ.Grandeur_pointee();
TypeQuelconque::Grandeur* g_TG_t = TQ_t.Grandeur_pointee();
const string* nom_de_ref = g_TG->Nom_ref();
#ifdef MISE_AU_POINT
if (nom_de_ref == NULL)
{ cout << "\n *** pb dans l'integration !! "
<< " nom_de_ref est nul, on ne peut pas continuer "
<< "\n LesMaillages::TversTdt()"<<endl;
Sortie(1);
};
#endif
// récup du pointeur de conteneur
const void* pointe = (ParaGlob::param->GrandeurGlobal(*nom_de_ref));
#ifdef MISE_AU_POINT
if (pointe == NULL)
{ cout << "\n *** pb dans l'integration !! "
<< " la variable globale "<< (*nom_de_ref)
<< ", n'est pas disponible, on ne peut pas continuer "
<< "\n LesMaillages::TversTdT()"<<endl;
Sortie(1);
};
#endif
// on l'affecte
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
(gr_quelc->Grandeur_pointee())->Affectation_numerique(*(g_TG_t));
};
};
// -- cas des intégrales de volumes et en temps
// on réinitialise également les grandeurs à 0, car le calcul est fait dans les éléments
// et le stockage à t est sauvegardé dans les éléments, du coup si on n'initialise pas ici
// au final on aura 2 fois l'intégrale à la fin du pas de temps !!
// par contre avant l'initialisation, on met à jour la variable globale
{int taille = integ_vol_t_typeQuel.Taille();
for (int il =1;il <= taille ;il++)
if (ref_integ_vol_t(il) != NULL) // si NULL => la grandeur reste fixe et n'est pas intégrée
{TypeQuelconque& TQ_t = integ_vol_t_typeQuel_t(il); // pour simplifier
TypeQuelconque& TQ = integ_vol_t_typeQuel(il); // pour simplifier
// on remet à t les grandeurs globales
TypeQuelconque::Grandeur* g_TG = TQ.Grandeur_pointee();
TypeQuelconque::Grandeur* g_TG_t = TQ_t.Grandeur_pointee();
const string* nom_de_ref = g_TG->Nom_ref();
#ifdef MISE_AU_POINT
if (nom_de_ref == NULL)
{ cout << "\n *** pb dans l'integration !! "
<< " nom_de_ref est nul, on ne peut pas continuer "
<< "\n LesMaillages::TdtversT()"<<endl;
Sortie(1);
};
#endif
// récup du pointeur de conteneur
const void* pointe = (ParaGlob::param->GrandeurGlobal(*nom_de_ref));
#ifdef MISE_AU_POINT
if (pointe == NULL)
{ cout << "\n *** pb dans l'integration !! "
<< " la variable globale "<< (*nom_de_ref)
<< ", n'est pas disponible, on ne peut pas continuer "
<< "\n LesMaillages::TversTdT()"<<endl;
Sortie(1);
};
#endif
// on réaffecte la grandeur à tdt à la valeur de t
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
(gr_quelc->Grandeur_pointee())->Affectation_numerique(*(g_TG_t));
// !! non ce sera fait dans l'intégration, et il vaut mieux garder une valeur correcte
// // maintenant on initialise le conteneur local
// TQ.Grandeur_pointee()->InitParDefaut(); // on initialise pour le prochain calcul
};
};
// -- cas des statistiques sur des ref de noeuds
// on réinitialise les grandeurs qui vont être calculée
// ceux à t ne changent pas
{int taille = statistique_typeQuel.Taille();
for (int il =1;il <= taille ;il++)
if (ref_statistique(il) != NULL) // si == NULL => la grandeur reste fixe et n'est pas intégrée
{TypeQuelconque& TQ = statistique_typeQuel(il); // pour simplifier
TypeQuelconque& TQ_t = statistique_typeQuel_t(il); // pour simplifier
// transfert des intégrales finalisées
(TQ.Grandeur_pointee())->Affectation_numerique(*(TQ_t.Grandeur_pointee()));
// !! non ce sera fait dans l'intégration, et il vaut mieux garder une valeur correcte
// TQ.Grandeur_pointee()->InitParDefaut();
// cas des grandeurs à tdt: on alimente les grandeurs globales
// le conteneur qui contient le résultat globalisé
// donc on le remet à du pas précédent à t
TypeQuelconque::Grandeur* g_TG = TQ.Grandeur_pointee();
TypeQuelconque::Grandeur* g_TG_t = TQ_t.Grandeur_pointee();
const string* nom_de_ref = g_TG->Nom_ref();
#ifdef MISE_AU_POINT
if (nom_de_ref == NULL)
{ cout << "\n *** pb dans l'integration !! "
<< " nom_de_ref est nul, on ne peut pas continuer "
<< "\n LesMaillages::TversTdt()"<<endl;
Sortie(1);
};
#endif
// récup du pointeur de conteneur
const void* pointe = (ParaGlob::param->GrandeurGlobal(*nom_de_ref));
#ifdef MISE_AU_POINT
if (pointe == NULL)
{ cout << "\n *** pb dans l'integration !! "
<< " la variable globale "<< (*nom_de_ref)
<< ", n'est pas disponible, on ne peut pas continuer "
<< "\n LesMaillages::TversTdT()"<<endl;
Sortie(1);
};
#endif
// on l'affecte
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
(gr_quelc->Grandeur_pointee())->Affectation_numerique(*(g_TG_t));
};
};
// -- cas des statistiques sur des refs de noeuds avec cumul en temps
//**** à voir si c'est vrai pour les statistiques
// on réinitialise également les grandeurs à 0, car le calcul est fait dans les éléments
// et le stockage à t est sauvegardé dans les éléments, du coup si on n'initialise pas ici
// au final on aura 2 fois l'intégrale à la fin du pas de temps !!
// par contre avant l'initialisation, on met à jour la variable globale
{int taille = statistique_t_typeQuel.Taille();
for (int il =1;il <= taille ;il++)
if (ref_statistique_t(il) != NULL) // si NULL => la grandeur reste fixe
{TypeQuelconque& TQ_t = statistique_t_typeQuel_t(il); // pour simplifier
TypeQuelconque& TQ = statistique_t_typeQuel(il); // pour simplifier
// on remet à t les grandeurs globales
TypeQuelconque::Grandeur* g_TG = TQ.Grandeur_pointee();
TypeQuelconque::Grandeur* g_TG_t = TQ_t.Grandeur_pointee();
const string* nom_de_ref = g_TG->Nom_ref();
#ifdef MISE_AU_POINT
if (nom_de_ref == NULL)
{ cout << "\n *** pb dans statistique avec cumul en temps !! "
<< " nom_de_ref est nul, on ne peut pas continuer "
<< "\n LesMaillages::TdtversT()"<<endl;
Sortie(1);
};
#endif
// récup du pointeur de conteneur
const void* pointe = (ParaGlob::param->GrandeurGlobal(*nom_de_ref));
#ifdef MISE_AU_POINT
if (pointe == NULL)
{ cout << "\n *** pb dans statistique avec cumul en temps !! "
<< " la variable globale "<< (*nom_de_ref)
<< ", n'est pas disponible, on ne peut pas continuer "
<< "\n LesMaillages::TversTdT()"<<endl;
Sortie(1);
};
#endif
// on réaffecte la grandeur à tdt à la valeur de t
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
(gr_quelc->Grandeur_pointee())->Affectation_numerique(*(g_TG_t));
// !! non ce sera fait dans l'intégration, et il vaut mieux garder une valeur correcte
// // maintenant on initialise le conteneur local
// TQ.Grandeur_pointee()->InitParDefaut(); // on initialise pour le prochain calcul
};
};
};
// actualisation des ddl actifs a t+dt, a partir du resultat de la resolution
// casAssemb : donne le cas d'assemblage qui est a considérer
void LesMaillages::PlusDelta_tdt(Vecteur& sol,const Nb_assemb& casAssemb)
{ // on balaie le tableau d'indexage
Tableau <Posi_ddl_noeud> & ti_n = t_i_n(casAssemb.n); // pour simplifier
int ti_nTaille = ti_n.Taille();
for (int i=1;i<=ti_nTaille;i++)
{ Posi_ddl_noeud& a = ti_n(i);
Noeud_LesMaille(a.Const_Nb_maillage(),a.Const_Nb_noeud()).Ajout_val_tdt(a.Const_Enu(),sol(i));
};
};
// actualisation des ddl actifs a t, a partir du resultat de la resolution
// casAssemb : donne le cas d'assemblage qui est a considérer
void LesMaillages::PlusDelta_t(Vecteur& sol,const Nb_assemb& casAssemb)
{ // on balaie le tableau d'indexage
Tableau <Posi_ddl_noeud> & ti_n = t_i_n(casAssemb.n); // pour simplifier
int ti_nTaille = ti_n.Taille();
for (int i=1;i<=ti_nTaille;i++)
{ Posi_ddl_noeud& a = ti_n(i);
Noeud_LesMaille(a.Const_Nb_maillage(),a.Const_Nb_noeud()).Ajout_val_t(a.Const_Enu(),sol(i));
};
};
// récupération du vecteur correspondant à l'incrément de déplacement entre t et tdt
// en paramètre le vecteur vide et en sortie le vecteur rempli
// casAssemb : donne le cas d'assemblage qui est a considérer
Vecteur& LesMaillages::RecupDepde_tatdt(Vecteur& sol,const Nb_assemb& casAssemb)
{ // on balaie le tableau d'indexage
Tableau <Posi_ddl_noeud> & ti_n = t_i_n(casAssemb.n); // pour simplifier
int ti_nTaille = ti_n.Taille();
for (int i=1;i<=ti_nTaille;i++)
{ Posi_ddl_noeud& a = ti_n(i);
Noeud & noe = Noeud_LesMaille(a.Const_Nb_maillage(),a.Const_Nb_noeud());
sol(i) = noe.Valeur_tdt(a.Const_Enu()) - noe.Valeur_t(a.Const_Enu());
};
return sol;
};
// changement des ddl à tdt par ceux correspondant au vecteur passé en paramètre
// casAssemb : donne le cas d'assemblage qui est a considérer
void LesMaillages::ChangeDdla_tdt(Vecteur& sol,const Nb_assemb& casAssemb)
{ // on balaie le tableau d'indexage
Tableau <Posi_ddl_noeud> & ti_n = t_i_n(casAssemb.n); // pour simplifier
int ti_nTaille = ti_n.Taille();
for (int i=1;i<=ti_nTaille;i++)
{ Posi_ddl_noeud& a = ti_n(i);
Noeud_LesMaille(a.Const_Nb_maillage(),a.Const_Nb_noeud()).Change_val_tdt(a.Const_Enu(),sol(i));
};
};
// retrouver le ddl correspondant a un pointeur de position
// d'assemblage, le nb du noeud et du maillage
// insol = le pointeur d'assemblage;
// ddl = le ddl en sortie; a t+dt si elle il existe
// sinon la valeur a t
// casAssemb : donne le cas d'assemblage qui est a considérer
Ddl LesMaillages::NoeudIndice(int inSol,int& nbNoeud, int& nbMaillage,const Nb_assemb& casAssemb)
{ // on utilise le tableau d'indexage
Posi_ddl_noeud& a = t_i_n(casAssemb.n)(inSol);
nbNoeud = a.Const_Nb_noeud(); nbMaillage = a.Const_Nb_maillage();
Noeud & noe = Noeud_LesMaille(a.Const_Nb_maillage(),a.Const_Nb_noeud());
if (noe.Tdt())
return noe.Ddl_noeud_tdt(a.Const_Enu());
else
return noe.Ddl_noeud_t(a.Const_Enu());
};
// idem en ramenant en plus la valeur du ddl a 0
Ddl LesMaillages::NoeudIndice(int inSol,int& nbNoeud, int& nbMaillage, double& val0
,const Nb_assemb& casAssemb)
{ // on utilise le tableau d'indexage
Posi_ddl_noeud& a = t_i_n(casAssemb.n)(inSol);
nbNoeud = a.Const_Nb_noeud(); nbMaillage = a.Const_Nb_maillage();
Noeud & noe = Noeud_LesMaille(a.Const_Nb_maillage(),a.Const_Nb_noeud());
val0=noe.Valeur_0(a.Const_Enu());
if (noe.Tdt())
return noe.Ddl_noeud_tdt(a.Const_Enu());
else
return noe.Ddl_noeud_t(a.Const_Enu());
};
// creation des elements frontiere
// creation des elements frontiere: cela n'a lieu qu'une seule fois
// si les frontières existent déjà, --> aucune action, --> ramène 0
// sinon il y a réellement création, et --> ramène 1
int LesMaillages::CreeElemFront()
{ int retour = 0;
if ((listFrontiere.Taille() == 0) || (tt_noeud_front.Taille() == 0))
{ for (int nbmail=1;nbmail<=nbMaillageTotal;nbmail++)
tabMaillage(nbmail)->CreeElemFront();
listFrontiere.Change_taille(nbMaillageTotal);
tt_noeud_front.Change_taille(nbMaillageTotal);
for (int nbmail=1;nbmail<=nbMaillageTotal;nbmail++)
{listFrontiere(nbmail) = tabMaillage(nbmail)->ListFront();
tt_noeud_front(nbmail) = &(tabMaillage(nbmail)->Tab_noeud_front());
};
retour = 1;
}
else
{retour = 0;};
//// pour le débug
//for (int nbmail=1;nbmail<=nbMaillageTotal;nbmail++)
// {int nbfront = listFrontiere(nbmail)->size();
// cout << "\n maillage " << nbmail << " -------- ";
// LaLIST <Front>::iterator iff,iffin = listFrontiere(nbmail)->end();
// iff=listFrontiere(nbmail)->begin();
//// for (iff=listFrontiere(nbmail)->begin();iff !=iffin;iff++)
// Front& titi = (*iff);
// titi.Affiche(); cout << "\n";
//
// };
//
// Sortie(1);
//// fin débug
//// pour le débug
//for (int nbmail=1;nbmail<=nbMaillageTotal;nbmail++)
// {int nbfront = listFrontiere(nbmail)->size();
// cout << "\n maillage " << nbmail << " -------- ";
// LaLIST <Front>::iterator iff,iffin = listFrontiere(nbmail)->end();
// for (iff=listFrontiere(nbmail)->begin();iff !=iffin;iff++)
// {(*iff).Affiche(); cout << "\n";};
// };
// Sortie(1);
//// fin débug
// retour
return retour;
};
// ramene le tableau des noeuds des frontières des maillages esclaves
Tableau < Tableau <Noeud*> *> LesMaillages::Tab_noeud_frontiere_esclave()
{ Tableau < Tableau <Noeud*> *> ret(domEsclave);
if ((domEsclave)&&(ParaGlob::NiveauImpression()>2))
cout << "\n >>>> Information maillages : ";
for (int i=1;i<=domEsclave;i++)
{ret(i) = tt_noeud_front(i);
if (ParaGlob::NiveauImpression()>2)
cout << "\n il y a "<<ret(i)->Taille()
<< " noeuds esclaves possible sur front. du maillage " << i ;
};
return ret;
};
// calcul et ramene le tableau de tous les noeuds des maillages esclaves
// noeuds de la frontière et noeuds internes
// s'ils existent, sinon le tableau est vide
// le tableau n'est pas sauvegarde
const Tableau<Noeud *> LesMaillages::Esclave()
{ // tout d'abord on cherche la taille du tableau
int tail = 0;
for (int i=1;i<= domEsclave;i++)
tail += tabMaillage(i)->Nombre_noeud();
// tail += tabMaillage(i)->Nombre_noeud();
// dimensionnement du tableau
Tableau<Noeud *> tab(tail);
// remplissage du tableau
int indice =1;
for (int i=1;i<= domEsclave;i++)
{int nbnimax = tabMaillage(i)->Nombre_noeud();
for (int j=1; j<= nbnimax;j++,indice++)
tab(indice) = &(tabMaillage(i)->Noeud_mail(j));
};
// retour
return tab;
};
// inactive tous les ddl et les données
void LesMaillages::Inactive_ddl_et_donnees()
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
Noeud_LesMaille(i1,i2).Met_hors_service();
}
};
// inactive tous les ddl mais pas les données
void LesMaillages::Inactive_ddl()
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
Noeud_LesMaille(i1,i2).Met_hors_service_ddl();
}
};
// inactive les ddl primaires
void LesMaillages::Inactive_ddl_primaire()
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
Element_LesMaille(i1,i2).Inactive_ddl_primaire();
}
};
// active les ddl primaires
void LesMaillages::Active_ddl_primaire()
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
Element_LesMaille(i1,i2).Active_ddl_primaire();
}
};
// introduction des ddl de contraintes si cela veut dire quelques chose
// pour l'élément
void LesMaillages::Plus_ddl_Sigma()
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ Element & elem = Element_LesMaille(i1,i2);
if (elem.Id_TypeProblem() == MECA_SOLIDE_DEFORMABLE)
((ElemMeca&) elem).Plus_ddl_Sigma();
}
}
};
// inactivation des ddls de contraintes si cela veut dire quelques chose
// pour l'élément
void LesMaillages::Inactive_ddl_Sigma()
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ Element & elem = Element_LesMaille(i1,i2);
if (elem.Id_TypeProblem() == MECA_SOLIDE_DEFORMABLE)
((ElemMeca&) elem).Inactive_ddl_Sigma();
}
}
};
// activation des ddls de contraintes si cela veut dire quelques chose
// pour l'élément
void LesMaillages::Active_ddl_Sigma()
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ Element & elem = Element_LesMaille(i1,i2);
if (elem.Id_TypeProblem() == MECA_SOLIDE_DEFORMABLE)
((ElemMeca&) elem).Active_ddl_Sigma();
}
}
};
// activation du premier ddl de contraintes si cela veut dire quelques chose
// pour l'élément
void LesMaillages::Active_premier_ddl_Sigma()
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ Element & elem = Element_LesMaille(i1,i2);
if (elem.Id_TypeProblem() == MECA_SOLIDE_DEFORMABLE)
((ElemMeca&) elem).Active_premier_ddl_Sigma();
}
}
};
// introduction des ddl d'erreur si cela veut dire quelques chose
// pour l'élément
void LesMaillages::Plus_ddl_Erreur()
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ Element & elem = Element_LesMaille(i1,i2);
if (elem.Id_TypeProblem() == MECA_SOLIDE_DEFORMABLE)
((ElemMeca&) elem).Plus_ddl_Erreur();
}
}
};
// inactivation des ddls d'erreur si cela veut dire quelques chose
// pour l'élément
void LesMaillages::Inactive_ddl_Erreur()
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ Element & elem = Element_LesMaille(i1,i2);
if (elem.Id_TypeProblem() == MECA_SOLIDE_DEFORMABLE)
((ElemMeca&) elem).Inactive_ddl_Erreur();
}
}
};
// activation des ddls d'erreur si cela veut dire quelques chose
// pour l'élément
void LesMaillages::Active_ddl_Erreur()
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelementmax = tabMaillage(i1)->Nombre_element();
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ Element & elem = Element_LesMaille(i1,i2);
if (elem.Id_TypeProblem() == MECA_SOLIDE_DEFORMABLE)
((ElemMeca&) elem).Active_ddl_Erreur();
}
}
};
// d'une manière plus générique une fonction pour activer une série de ddl
// donnée par un identificateur, si c'est une grandeur vectoriel c'est l'ensemble
// des ddl du vecteur qui sont inactivé.
void LesMaillages::Active_un_type_ddl_particulier(Enum_ddl eni)
{ // on retient le premier ddl de la famille
Enum_ddl en = PremierDdlFamille(eni);
// il y a deux versions suivant que le ddl est une grandeur vectorielle ou pas
if (FoncDim(en))
// oui c'est une fonction vectorielle
{ // recup de la dimension
int dimen = ParaGlob::Dimension();
// dans le cas où le calcul est axisymétrique on décrémente de 1
if (ParaGlob::AxiSymetrie())
dimen--;
// création du tableau de ddl de travail
Tableau <Enum_ddl> taben(dimen);
for (int ii=1; ii<= dimen; ii++)
taben(ii) = Enum_ddl(en + ii-1);
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// on regarde si le ddl existe
if (noo->Existe_ici(en))
// si oui on l'active
noo->Met_en_service(taben);
// dans le cas où en = X1, on regarde le cas des épaisseurs
// celles-ci sont par exemple utilisées pour les coques et plaques et correspondent
// à une dimension du même ordre que Xi
if (en == X1)
if ( noo->Existe_ici(EPAIS) && noo->UneVariable(EPAIS))
noo->Met_en_service(EPAIS);
}
}
}
else // cas où il s'agit d'une grandeur scalaire
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// on regarde si le ddl existe
if (noo->Existe_ici(en))
// si oui on l'active
noo->Met_en_service(en);
}
}
};
//idem pour un tableau
void LesMaillages::Active_un_type_ddl_particulier(Tableau <Enum_ddl>& tab_en)
{ int tab_enTaille = tab_en.Taille();
for (int it=1;it<=tab_enTaille;it++) Active_un_type_ddl_particulier(tab_en(it));
};
//idem pour une liste
void LesMaillages::Active_un_type_ddl_particulier(const list <Enum_ddl>& list_en)
{ list <Enum_ddl>::const_iterator il,ilfin=list_en.end();
for (il = list_en.begin();il != ilfin;il++) Active_un_type_ddl_particulier((*il));
};
// idem la fonction Active_ddl_noeud mais ici pour l'inactivation
void LesMaillages::Inactive_un_type_ddl_particulier(Enum_ddl eni)
{ // on retient le premier ddl de la famille
Enum_ddl en = PremierDdlFamille(eni);
// il y a deux versions suivant que le ddl est une grandeur vectorielle ou pas
if (FoncDim(en))
// oui c'est une fonction vectorielle
{ // recup de la dimension
int dimen = ParaGlob::Dimension();
// dans le cas où le calcul est axisymétrique on décrémente de 1
if (ParaGlob::AxiSymetrie())
dimen--;
// création du tableau de ddl de travail
Tableau <Enum_ddl> taben(dimen);
for (int ii=1; ii<= dimen; ii++)
taben(ii) = Enum_ddl(en + ii-1);
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// on regarde si le ddl existe
if (noo->Existe_ici(en))
// si oui on l'inactive
noo->Met_hors_service(taben);
// dans le cas où en = X1, on regarde le cas des épaisseurs
// celles-ci sont par exemple utilisées pour les coques et plaques et correspondent
// à une dimension du même ordre que Xi
if (PremierDdlFamille(en) == X1)
if ( noo->Existe_ici(EPAIS) && noo->UneVariable(EPAIS))
noo->Met_hors_service(EPAIS);
}
}
}
else // cas où il s'agit d'une grandeur scalaire
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// on regarde si le ddl existe
if (noo->Existe_ici(en))
// si oui on l'inactive
noo->Met_hors_service(en);
}
}
};
//idem pour un tableau
void LesMaillages::Inactive_un_type_ddl_particulier(Tableau <Enum_ddl>& tab_en)
{ int tab_enTaille = tab_en.Taille();
for (int it=1;it<=tab_enTaille;it++) Inactive_un_type_ddl_particulier(tab_en(it));
};
//idem pour une liste
void LesMaillages::Inactive_un_type_ddl_particulier(const list <Enum_ddl>& list_en)
{ list <Enum_ddl>::const_iterator il,ilfin=list_en.end();
for (il = list_en.begin();il != ilfin;il++) Inactive_un_type_ddl_particulier((*il));
};
// Calcul de l'erreur sur l'ensemble des éléments
// type indique le type d'erreur retenue
// type = 1 : cas d'un calcul aux moindres carrés
// et retour un tableau de tableau de grandeurs sur les maillages en cours
// ret(i) : concerne le maillage i
// ret(i)(1) : somme des erreurs sur l'ensemble des éléments: est homogêne à
// un |delta contrainte| * domaine
// ret(i)(2) : somme de la grandeur de ref du calcul d'erreur sur l'ensemble des
// éléments: est homogêne à une |contrainte| * domaine
// ret(i)(3) : le maxi pour les tous les éléments de |delta contrainte| * domaine
// ret(i)(4) : le maxi pour les tous les éléments de |contrainte| * domaine
// ret(i)(5) : le maxi pour les tous les éléments de l'erreur relative
Tableau <Tableau <double > > LesMaillages::ErreurSurChaqueElement(int type)
{ double errElemRelative; // variable de travail
Tableau <Tableau <double > > ret(nbMaillageTotal); // init du tableau de retour
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelementmax = tabMaillage(i1)->Nombre_element();
double ErreurTot = 0.; // erreur totale
ret(i1).Change_taille(5);
double numerateur,denominateur;
double numtot = 0.; double denotot = 0.;
double maxi_numerateur = 0.; double maxi_denominateur = 0.;
double maxi_relatif = 0.;
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ Element & elem = Element_LesMaille(i1,i2);
if (elem.Id_TypeProblem() == MECA_SOLIDE_DEFORMABLE)
{ // calcul des elements d'erreur
((ElemMeca&) elem).ErreurElement(type,errElemRelative
,numerateur,denominateur);
numtot += numerateur; denotot += denominateur;
maxi_numerateur = DabsMaX(maxi_numerateur,numerateur);
maxi_denominateur = DabsMaX(maxi_denominateur, denominateur);
double relatif = 0.;
if (Dabs(denominateur) > ConstMath::petit)
{ relatif = numerateur/denominateur;}
else
{ relatif = numerateur; }; // on prend les valeurs non relatives si
maxi_relatif = DabsMaX(maxi_relatif, relatif);
};
};
ret(i1)(1)=numtot;
ret(i1)(2)=denotot;
ret(i1)(3)=maxi_numerateur;
ret(i1)(4)=maxi_denominateur;
// ret(i1)(5)=maxi_relatif;
}
// maintenant on va calculer la vraie erreur relative et on l'attribue aux éléments
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbelementmax = tabMaillage(i1)->Nombre_element();
double maxi_relatif = 0.;
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ Element & elem = Element_LesMaille(i1,i2);
if (elem.Id_TypeProblem() == MECA_SOLIDE_DEFORMABLE)
{ double erreur_absolue = ((ElemMeca&) elem).Erreur_sigma();
double erreur_relative = erreur_absolue/ret(i1)(4);
((ElemMeca&) elem).Change_erreur_relative(erreur_relative);
maxi_relatif = DabsMaX(maxi_relatif, erreur_relative);
};
};
ret(i1)(5)=maxi_relatif;
};
////--- debug
//cout << "\n debug LesMaillages::ErreurSurChaqueElement "
// << "\n Int_(delta sig)^2= " << numtot << ", int_sig^2= "<<denotot<<endl;
////---fin debug
return ret;
};
// lecture de donnée en fonction d'un indicateur : type
// type = 1 , on lit les tenseurs de contrainte
// type = 2 , on lit les déplacements
void LesMaillages::LectureDonneesExternes(const int type ,const string& nomMaillage)
{ // tout d'abord on cré un tableau d'indicateur qui est utilisé pour l'initialisatione
// des noeuds de manière à éviter plusieurs fois la même opération
static Tableau<bool> indicTravail_t(nbMaillageTotal,false);
// cas des contraintes
if (type == 1)
{ // on parcours les éléments pour trouver le bon fichier
int i1;
for (i1 = 1; i1<= nbMaillageTotal; i1++)
// on regarde si le nom de maillage correspond
if ( tabMaillage(i1)->NomDuMaillage() == nomMaillage)
break;
if (i1 == nbMaillageTotal+1)
{ cout << "\n erreur, on n'a pas trouve un nom de maillage utilisable pour la lecture de "
<< "\n de donnees externes sur fichier !";
entreePrinc->MessageBuffer(" LesMaillages::LectureDonneesExternes(...");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// on initialise le travail à t, nécessaire pour le calcul des métriques avec
// les coordonnées à t
if (!indicTravail_t(i1))
{ Travail_t(i1);
ZeroDdl(false); // mise à zéro des ddl sauf les déplacements qui sont = coord0
// et mémorisation
indicTravail_t(i1) = true;
}
// maintenant passage de l'entête
entreePrinc->NouvelleDonnee();
int toto,nbe;
*(entreePrinc->entree) >> toto >> nbe;
// passage des identificateurs des contraintes
entreePrinc->NouvelleDonnee();
// lecture des données pour chaque élément
int nbelementmax = tabMaillage(i1)->Nombre_element();
// vérif du nombre d'élément
if (nbe != nbelementmax)
{ // cas d'une différence
cout << "\n erreur (1) dans la lecture externe des contraintes, le nombre d'element interne"
<< "\n au calcul, et le nombre externe sur fichier est different!";
entreePrinc->MessageBuffer(" LesMaillages::LectureDonneesExternes(...");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
for (int i2 = 1; i2 <= nbelementmax; i2++)
{ // lecture d'un premier enregistrement
entreePrinc->NouvelleDonnee();
Element & elem = Element_LesMaille(i1,i2);
// lecture du type d'élément (ne sert à rien ici)
int typelem;
*(entreePrinc->entree) >> typelem;
// lecture des contraintes
if (elem.Id_TypeProblem() == MECA_SOLIDE_DEFORMABLE)
((ElemMeca&) elem).LectureContraintes(entreePrinc);
}
}
// cas des déplacements
if (type == 2)
{ // on parcours les éléments pour trouver le bon fichier
int i1;
for (i1 = 1; i1<= nbMaillageTotal; i1++)
// on regarde si le nom de maillage correspond
if ( tabMaillage(i1)->NomDuMaillage() == nomMaillage)
break;
// on initialise le travail à t, nécessaire pour le calcul des métriques avec
// les coordonnées à t
if (!indicTravail_t(i1))
{ Travail_t(i1);
ZeroDdl(false); // mise à zéro des ddl sauf les déplacements qui sont = coord0
// et mémorisation
indicTravail_t(i1) = true;
}
// maintenant on lit le nombre de déplacements enregistrés dans le fichier
entreePrinc->NouvelleDonnee();
int nbenreg;
*(entreePrinc->entree) >> nbenreg;
// récup du nombre de noeud du maillage
int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
if (nbnoeudmax != nbenreg)
{ // cas d'une différence
cout << "\n erreur (2) dans la lecture externe des contraintes, le nombre de noeuds interne"
<< "\n au calcul, et le nombre externe sur fichier est different!";
cout << "\n LesMaillages::LectureDonneesExternes( etc ... " << endl;
entreePrinc->MessageBuffer(" LesMaillages::LectureDonneesExternes(...");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
// lecture des données pour chaque noeud
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // lecture d'un premier enregistrement
entreePrinc->NouvelleDonnee();
Noeud_LesMaille(i1,i2).LectureDeplacements(entreePrinc);
}
}
};
// mise en place du travail à t sur les maillages
// indique que l'on va utiliser les ddl en 0, t
// si les grandeurs en tdt existaient, elles sont supprimées
void LesMaillages::Travail_t()
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// construit les tableaux de ddl a t
noo->Travail_t();
}
}
};
// mise en place du travail à t tdt sur les maillages
// indique que l'on va utiliser les ddl en 0, t, tdt
void LesMaillages::Travail_tdt()
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// construit les tableaux de ddl a t
noo->Travail_tdt();
}
}
};
// idem pour un maillage donné de numéro num
void LesMaillages::Travail_t(int num)
{ int nbnoeudmax = tabMaillage(num)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(num,i2);
// construit les tableaux de ddl a t
noo->Travail_t();
}
};
// définition des coordonnées à t identiques à ceux à t=0,
void LesMaillages::Insert_coord1()
{ for (int i1 = 1; i1<= nbMaillageTotal; i1++)
{ int nbnoeudmax = tabMaillage(i1)->Nombre_noeud();
for (int i2 = 1; i2 <= nbnoeudmax; i2++)
{ // recup du noeud
Noeud * noo = & Noeud_LesMaille(i1,i2);
// construit les coordonnées de ddl a t
noo->Insert_coord1();
}
}
};
// ramène le maximum de variation de coordonnée entre t et tdt de tous les noeuds du maillage
double LesMaillages::Max_var_dep_t_a_tdt() const
{ double ret=0.;
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
ret=MaX(tabMaillage(i1)->Max_var_dep_t_a_tdt(),ret);
return ret;
};
// ramène le minimum de la distance entre deux noeuds de l'ensemble des éléments pour tous les maillages
double LesMaillages::Min_dist2Noeud_des_elements(Enum_dure temps) const
{ double ret=ConstMath::tresgrand;
for (int i1 = 1; i1<= nbMaillageTotal; i1++)
ret=MiN(tabMaillage(i1)->Min_dist2Noeud_des_elements(temps),ret);
return ret;
};
Reference in a new issue View git blame Copy permalink