// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "Mail_initiale_Gid.h"
#include <iomanip>
#include "ReferenceNE.h"
// CONSTRUCTEURS :
// par defaut
Mail_initiale_Gid::Mail_initiale_Gid () :
OrdreVisu("","visualisation des maillages initiaux","")
// OrdreVisu(".................................maillage initiale"
// ,"visualisation des maillages initiaux","mi")
,tabtab_sous_mesh(),tabli_sig_elem(),tabli_sous_mesh()
,decal_noeud(),decal_element()
{};
// constructeur de copie
Mail_initiale_Gid::Mail_initiale_Gid (const Mail_initiale_Gid& ord) :
OrdreVisu(ord),tabtab_sous_mesh(ord.tabtab_sous_mesh)
,tabli_sig_elem(ord.tabli_sig_elem)
,tabli_sous_mesh(ord.tabli_sous_mesh)
,decal_noeud(ord.decal_noeud),decal_element(ord.decal_element)
{};
// DESTRUCTEUR :
Mail_initiale_Gid::~Mail_initiale_Gid ()
{};
// METHODES PUBLIQUES :
// initialisation : permet d'initialiser les différents paramètres de l'ordre
// lors d'un premier passage des différents incréments
// en virtuelle, a priori est défini si nécessaire dans les classes dérivées
void Mail_initiale_Gid::Initialisation(ParaGlob * paraGlob,LesMaillages * lesmail,LesReferences* lesRef
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage,Charge* charge
,LesCondLim* lesCondLim,LesContacts* lesContacts
,Resultats* resultats,EnumTypeIncre type_incre,int incre
,const map < string, const double * , std::less <string> >& listeVarGlob
,const List_io < TypeQuelconque >& listeVecGlob
,bool fil_calcul)
{ // initialisation des tableaux
int nb_maillage = lesmail->NbMaillage();
tabtab_sous_mesh.Change_taille(nb_maillage);
tabli_sig_elem.Change_taille(nb_maillage);
tabli_sous_mesh.Change_taille(nb_maillage);
//appel de l'ordre d'initialisation de la classe mère
OrdreVisu::Initialisation(paraGlob,lesmail,lesRef,lesLoisDeComp,diversStockage,charge
,lesCondLim,lesContacts,resultats,type_incre,incre
,listeVarGlob,listeVecGlob,fil_calcul);
// la sortie du maillage initial est a priori obligatoire donc on effectue le choix par défaut
Mail_initiale_Gid::ChoixOrdre();
// on calcule le décalage de numéros de noeud, du au fait qu'il peut y avoir plusieurs maillages
decal_noeud.Change_taille(nb_maillage); decal_element.Change_taille(nb_maillage);
int decal_n = 0; int decal_e=0; // variables intermédiaires
for (int nm=1;nm<=nb_maillage;nm++)
{decal_noeud(nm)=decal_n; decal_element(nm)=decal_e;
decal_n += lesmail->Nombre_noeud(nm);
decal_e += lesmail->Nombre_element(nm);
};
};
// execution de l'ordre
// tab_mail : donne les numéros de maillage concerné
// incre : numéro d'incrément qui en cours
// type_incre : indique si c'est le premier le dernier ou l'incrément courant a visualiser ou pas
// animation : indique si l'on est en animation ou pas
// unseul_incre : indique si oui ou non il y a un seul increment à visualiser
void Mail_initiale_Gid::ExeOrdre(ParaGlob * ,const Tableau <int>& tab_mail,LesMaillages * lesMail,bool
,LesReferences* lesRef,LesLoisDeComp* ,DiversStockage*,Charge*,LesCondLim*
// ,LesContacts*,Resultats*,ostream & sort,EnumTypeIncre type_incre,int incre
,LesContacts*,Resultats*,UtilLecture & entreePrinc,OrdreVisu::EnumTypeIncre ,int incre
// ,bool animation)
,bool,const map < string, const double * , std::less <string> >&
,const List_io < TypeQuelconque >& listeVecGlob)
{ // --- la partie qui suie est systématiquement exécutée, que ce soit actif, ou pas et quelque soit l'incrément --
// constitue une initialisation pour les autres ordres, mais que l'on ne peut pas mettre dans Initialisation
// car dépend de tab_mail, qui dépend du choix de l'utilisateur
// on recalcule les décalages de noeuds en fonction des maillages actifs, car c'est utilisé par les isovaleurs et autres
// ordres, les maillages qui ne sont pas concerné, ont des décal_noe et éléments inchangé donc quelconques, ceci permet de garder les mêmes tailles
int decal_n = 0; int decal_e=0; // variables intermédiaires
int nbmail = tab_mail.Taille();
for (int nm=1;nm<=nbmail;nm++)
{int numMail=tab_mail(nm);
decal_noeud(numMail)=decal_n; decal_element(numMail)=decal_e;
decal_n += lesMail->Nombre_noeud(numMail);
decal_e += lesMail->Nombre_element(numMail);
};
if (incre==0) // dans tous les cas on sort le maillage initiale au premier incrément
{ostream &sort = entreePrinc.Sort_initial_Gid();
// on boucle sur les maillages
int nbmail = tab_mail.Taille();
for (int im=1;im<=nbmail;im++)
{ int numMail=tab_mail(im);
// écriture d'une entete
sort << "\n // ========================================="
<< "\n // | definition du maillage initiale |"
<< "\n // =========================================";
int decal_noe=decal_noeud(numMail); // pour simplifier
int decal_ele =decal_element(numMail); // pour simplifier
// on cherche tout d'abord le nombre d'éléments différents dans le maillage
List_io <Element::Signature>& li_sig_elem=tabli_sig_elem(numMail);
li_sig_elem.erase(li_sig_elem.begin(),li_sig_elem.end());
// on initialise également tabli_sous_mesh(numMail)
tabli_sous_mesh(numMail).erase(tabli_sous_mesh(numMail).begin(),tabli_sous_mesh(numMail).end());
// on balaie tous les éléments du maillage
int nbmaxiElement = lesMail->Nombre_element(numMail);
List_io <Element::Signature>::iterator ipos;
for (int numElem=1; numElem<= nbmaxiElement;numElem++)
{ // recup de la signature de l'élément
Element::Signature sig_elem = lesMail->Element_LesMaille(numMail,numElem).Signature_element();
// on regarde s'il existe déjà
ipos = find(li_sig_elem.begin(),li_sig_elem.end(),sig_elem);
if (ipos == li_sig_elem.end()) // enregistrement s'il n'existe pas
li_sig_elem.push_back(sig_elem);
};
// dimensionne le tableau de sous maillages
tabtab_sous_mesh(numMail).Change_taille(li_sig_elem.size());
// simplification et préparation
Tableau < List_io < Element* > >& tab_sous_mesh = tabtab_sous_mesh(numMail);
// maintenant on boucle sur les types d'éléments
List_io <Element::Signature>::iterator ifin=li_sig_elem.end();
int num_type = 1;
for (ipos= li_sig_elem.begin();ipos!=ifin;ipos++,num_type++)
{ // initialisation
tab_sous_mesh(num_type).erase(tab_sous_mesh(num_type).begin(),tab_sous_mesh(num_type).end());
// maintenant on sort la partie d'élément correspondante avec pour la première partie
//la liste de tous les noeuds
sort << "\n # maillage: " << lesMail->NomMaillage(numMail) << "\n";
// création du nom du sous maillage
ostrstream tab_out;
tab_out << lesMail->NomMaillage(numMail) << "_" << num_type << ends;
string nom_sous_maillage = tab_out.str() ; // le nom
tabli_sous_mesh(numMail).push_back(nom_sous_maillage); // sauvegarde
// sortie sur fichier
sort << "\n MESH \""<< nom_sous_maillage << "\" ";
int dim = ParaGlob::Dimension(); // récup de la dimension
if (dim != 1)
{sort <<" dimension " << ParaGlob::Dimension() << " ";}
else
// le cas dim = 1 ne semble pas fonctionner par contre avec 3 c'est ok
// on met donc 3, car de toute façon on rajoute des coordonnées nulles
{sort <<" dimension " << 3 << " ";};
// définition du type d'élément
sort << "Elemtype " ; bool erreur = false;
switch ((*ipos).id_geom)
{ case TRIANGLE : case TRIA_AXI:
{ sort << "Triangle ";
switch ((*ipos).id_interpol)
{ case LINEAIRE : {sort << " Nnode 3 "; break;}
case QUADRACOMPL :{ sort << " Nnode 6 "; break;}
case SFE3C: case SFE3 : case SFE2: case SFE1 : // on ne considère que les noeuds centraux
case SFE3C_3D: case SFE3_3D : case SFE2_3D: case SFE1_3D :{ sort << " Nnode 3 "; break;}
case QSFE1: case QSFE3: // on ne considère que les noeuds centraux
{ sort << " Nnode 6 "; break;}
default : erreur = true;
};
break;
}
case QUADRANGLE : case QUAD_AXI:
{ sort << "Quadrilateral ";
switch ((*ipos).id_interpol)
{ case LINEAIRE : {sort << " Nnode 4 "; break;}
case QUADRATIQUE : {sort << " Nnode 8 "; break;}
case QUADRACOMPL : {sort << " Nnode 9 "; break;}
default : erreur = true;
};
break;
}
case TETRAEDRE :
{ sort << "Tetrahedra ";
switch ((*ipos).id_interpol)
{ case LINEAIRE : {sort << " Nnode 4 "; break;}
case QUADRACOMPL : {sort << " Nnode 10 "; break;}
default : erreur = true;
};
break;
}
case HEXAEDRE :
{ sort << "Hexahedra ";
switch ((*ipos).id_interpol)
{ case LINEAIRE : {sort << " Nnode 8 "; break;}
case QUADRATIQUE : {sort << " Nnode 20 "; break;}
case QUADRACOMPL : {sort << " Nnode 27 "; break;}
default : erreur = true;
};
break;
}
case POUT : case SEGMENT : case SEG_AXI:
{ sort << "Linear ";
switch ((*ipos).id_interpol)
{ case BIE1 : sort << " Nnode 2 "; break;
case LINEAIRE : sort << " Nnode 2 "; break;
case QUADRATIQUE : case BIE2 : sort << " Nnode 3 "; break;
default : erreur = true;
};
break;
}
case POINT : sort << "Point Nnode 1 "; break;
case PENTAEDRE :
{ // il n'y a pas de pentaèdre dans gid, on modélise donc à l'aide d'hexaèdre dont deux arrêtes
// sont confondu
sort << "Hexahedra ";
switch ((*ipos).id_interpol)
{ case LINEAIRE : {sort << " Nnode 8 "; break;}
case QUADRATIQUE : {sort << " Nnode 20 "; break;}
case QUADRACOMPL : {sort << " Nnode 27 "; break;}
default : erreur = true;
};
break;
}
default :
cout << "\nErreur : cas d'element non traite par Gid ! " << Nom_geom((*ipos).id_geom)
<< " ********** attention, le fichier maillage initial ne sera pas exploitable !!!\n";
};
if (erreur)
cout << "\nErreur : cas d'element + interpolation non traite par Gid !" << Nom_geom((*ipos).id_geom)
<< " " << Nom_interpol((*ipos).id_interpol)
<< " ********** attention, le fichier de sortie ne sera pas exploitable !!!\n";
// maintenant on sort la liste de tous les noeuds dans le cas de la première partie
if (ipos == li_sig_elem.begin())
{ sort << "\n \n # tous les noeuds du maillage: " << lesMail->NomMaillage(numMail) << "\n";
int nbmaxinoeud = lesMail->Nombre_noeud(numMail);
sort << "\n Coordinates ";
for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++)
{// recup du noeud
Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
sort << "\n" << noe.Num_noeud()+decal_noe << " " ;
const Coordonnee& co = noe.Coord0();
co.Affiche(sort,ParaGlob::NbdigdoGR());
switch (dim) // dans le cas d'une dimension diff de 3, on complète avec des 0
{ case 1: sort << " 0. ";
case 2: sort << " 0. ";
};
};
sort << "\n end coordinates ";
};
// on sort les éléments
sort << "\n \n # tous les element du maillage: " << lesMail->NomMaillage(numMail)
<< " du meme type " << Nom_geom((*ipos).id_geom) << " " << Nom_interpol((*ipos).id_interpol)
<< "\n";
int nbmaxinoeud = lesMail->Nombre_noeud(numMail);
sort << "\n Elements ";
int nbmaxiElement = lesMail->Nombre_element(numMail);
for (int numElem=1; numElem<= nbmaxiElement;numElem++)
{ // recup de l'élément
Element & elem = lesMail->Element_LesMaille(numMail,numElem);
// si c'est la bonne signature on sort l'élément
if (elem.Signature_element() == *ipos)
{sort << "\n" << elem.Num_elt() + decal_ele << " ";
Tableau<Noeud *>& tab_noeud = elem.Tab_noeud();
int nb_n = tab_noeud.Taille();
// dans le cas des pentaèdres on a un traitement spécial pour sortir sous forme d'hexaèdres
if ((*ipos).id_geom == PENTAEDRE)
{if ((*ipos).id_interpol == LINEAIRE)
{for (int j=1;j<=3;j++) // les 3 premiers noeuds
sort << tab_noeud(j)->Num_noeud()+decal_noe<< " " ;
sort << tab_noeud(3)->Num_noeud()+decal_noe << " " ; // le 4h = 3p
for (int j=4;j<=6;j++) // les 3 derniers noeuds
sort << tab_noeud(j)->Num_noeud()+decal_noe << " " ;
sort << tab_noeud(6)->Num_noeud()+decal_noe << " " ; // le 8h = 6p
}
else if((*ipos).id_interpol == QUADRATIQUE)
{for (int j=1;j<=3;j++) // les 3 premiers noeuds
sort << tab_noeud(j)->Num_noeud()+decal_noe << " " ;
sort << tab_noeud(3)->Num_noeud()+decal_noe << " " ; // le 4h = 3p
for (int j=4;j<=6;j++) // les 3 noeuds du dessus
sort << tab_noeud(j)->Num_noeud()+decal_noe << " " ;
sort << tab_noeud(6)->Num_noeud()+decal_noe << " " ; // le 8h = 6p
for (int j=7;j<=9;j++) // les 3 noeuds intermédiaires du bas
sort << tab_noeud(j)->Num_noeud()+decal_noe << " " ;
sort << tab_noeud(9)->Num_noeud()+decal_noe << " " ; // le 12h = 9p
for (int j=10;j<=12;j++) // les 3 noeuds à mi-hauteur
sort << tab_noeud(j)->Num_noeud()+decal_noe << " " ;
sort << tab_noeud(12)->Num_noeud()+decal_noe << " " ; // le 16h = 12p
for (int j=13;j<=15;j++) // les 3 noeuds intermédiaires du dessus
sort << tab_noeud(j)->Num_noeud()+decal_noe << " " ;
sort << tab_noeud(15)->Num_noeud()+decal_noe << " " ; // le 20h = 15p
}
else if((*ipos).id_interpol == QUADRACOMPL)
{for (int j=1;j<=3;j++) // les 3 premiers noeuds
sort << tab_noeud(j)->Num_noeud()+decal_noe << " " ;
sort << tab_noeud(3)->Num_noeud()+decal_noe << " " ; // le 4h = 3p
for (int j=4;j<=6;j++) // les 3 noeuds du dessus
sort << tab_noeud(j)->Num_noeud()+decal_noe << " " ;
sort << tab_noeud(6)->Num_noeud()+decal_noe << " " ; // le 8h = 6p
for (int j=7;j<=9;j++) // les 3 noeuds intermédiaires du bas
sort << tab_noeud(j)->Num_noeud()+decal_noe << " " ;
sort << tab_noeud(9)->Num_noeud()+decal_noe << " " ; // le 12h = 9p
for (int j=10;j<=12;j++) // les 3 noeuds à mi-hauteur
sort << tab_noeud(j)->Num_noeud()+decal_noe << " " ;
sort << tab_noeud(12)->Num_noeud()+decal_noe << " " ; // le 16h = 12p
for (int j=13;j<=15;j++) // les 3 noeuds intermédiaires du dessus
sort << tab_noeud(j)->Num_noeud()+decal_noe << " " ;
sort << tab_noeud(15)->Num_noeud()+decal_noe << " " ; // le 20h = 15p
sort << tab_noeud(9)->Num_noeud()+decal_noe << " " ; // le 21h = 9p
sort << tab_noeud(16)->Num_noeud()+decal_noe << " " ; // le 22h = 16p
sort << tab_noeud(17)->Num_noeud()+decal_noe << " " ; // le 23h = 17p
sort << tab_noeud(18)->Num_noeud()+decal_noe << " " ; // le 24h = 18p
sort << tab_noeud(18)->Num_noeud()+decal_noe << " " ; // le 25h = 18p idem
sort << tab_noeud(15)->Num_noeud()+decal_noe << " " ; // le 21h = 15p
sort << tab_noeud(18)->Num_noeud()+decal_noe << " " ; // le 27h = 18p
};
}
else if (ElementSfe((*ipos).id_interpol))
// dans le cas des sfe on ne sort que les noeuds du centre
{for (int j=1;j<=3;j++) // 3 noeuds centraux
sort << tab_noeud(j)->Num_noeud()+decal_noe << " " ;
}
else
// cas normal
{for (int j=1;j<=nb_n;j++)
sort << tab_noeud(j)->Num_noeud()+decal_noe << " " ;
};
// le nb de matériau: pour l'instant on met le numéro de maillage
sort << numMail;
// et on sauvegarde la ref à l'élément
tab_sous_mesh(num_type).push_back(&elem);
};
};
sort << "\n end elements ";
// et on vide le buffer de sortie
sort << endl;
}; // -- fin de la boucle sur les types différents de signatures
//----------------------------------------------------------------
// cas des références
//----------------------------------------------------------------
int numero_reference=1;
// 1 -- cas des références de noeuds
ostream &sart = entreePrinc.Sort_resultat_Gid();
sart << "\n # ============================================="
<< "\n # | definition des references de noeuds |"
<< "\n # ============================================="
<< "\n # maillage : " << lesMail->NomMaillage(numMail) << "\n"
<< "\n # decalage des numeros de noeuds : " << decal_noe << " "
<< "\n # decalage des numeros d'elements : " << decal_ele << " ";
// on va boucler sur les références et sortir les références de noeuds
const Reference* reff =NULL; bool prempass = true;
do { if (prempass)
{ reff= lesRef->Init_et_Premiere();} // récup de la ref 1 et init
else
{ reff = lesRef->Reference_suivante();} // récup de la ref courante
// sortie de la ref si c'est le bon maillage, et si c'est une ref de noeud
if (reff != NULL)
if ((reff->Nbmaille() == numMail) && (reff->Indic() == 1))
{// on a récupérer une référence de noeud du maillage
ReferenceNE * refNE =((ReferenceNE*) reff);
// sortie sur fichier
sart << "\n\n Result \""<< reff->Nom() <<"_" << numMail << "_\" ";
sart <<" \"ref_de_noeud\" " << incre << " Scalar OnNodes ";
// définition du type d'élément
sart << "\n ComponentNames \"" << reff->Nom()<<"_" << numMail << "\" ";
// pas de coordonné car on utilise les coordonnées déjà données
sart << "\n Values ";
int reftaille = refNE->Taille();
for (int nn =1; nn<= reftaille;nn++) // nn = position des num de noeud
sart << "\n " << refNE->Numero(nn) + decal_noe << " "<< numero_reference <<" ";
sart << "\n End Values ";
};
prempass = false;
} while (reff != NULL);
};//-- fin de la boucle sur les maillages
}; //-- fin de if ((actif)&&(incre==0))
};
// choix de l'ordre, cet méthode peut entraîner la demande d'informations
// supplémentaires si nécessaire. qui sont ensuite gérer par la classe elle même
void Mail_initiale_Gid::ChoixOrdre()
{ // demande de précision
// appel de la méthode de la classe mère
OrdreVisu::ChoixOrdre();
};
// lecture des paramètres de l'ordre dans un flux
void Mail_initiale_Gid::Lecture_parametres_OrdreVisu(UtilLecture & entreePrinc)
{ // si dans le flot il existe l'identificateur adoc on lit sinon on passe
if (strstr(entreePrinc.tablcarCVisu,"debut_maillage_initial")!=NULL)
{// sauvegarde des paramètres actuelles
// essaie de lecture
try
{ string nom;
(*entreePrinc.entCVisu) >> nom ;
if (nom != "debut_maillage_initial")
{ cout << "\n Erreur en lecture des parametres du maillage initial a partir d'un fichier .CVisu,"
<< " le premier enregistrement doit etre le mot clef: debut_maillage_initial "
<< " on ne tiens pas compte des parametres fournies !! ";
}
else
{ // appel de l'ordre de la classe mère
OrdreVisu::Lect_para_OrdreVisu_general(entreePrinc);
while (nom != "fin_maillage_initial")
{ (*entreePrinc.entCVisu) >> nom;
entreePrinc.NouvelleDonneeCVisu();
}
}
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch (...)// erreur de lecture
{ cout << "\n Erreur en lecture des parametres du maillage initial a partir d'un fichier .CVisu,"
<< " on ne tiens pas compte des parametres fournies !! ";
// récup des infos sauvées
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Mail_initiale_Gid::Lecture_parametres_OrdreVisu(..";
}
}
};
// écriture des paramètres de l'ordre dans un flux
void Mail_initiale_Gid::Ecriture_parametres_OrdreVisu(UtilLecture & entreePrinc)
{ // récup du flot
ostream & sort = (*(entreePrinc.Sort_CommandeVisu()));
// on commente le fonctionnement
sort << "\n # ----------------------------- definition des parametres du maillage initial: ---------------- "
<< "\n debut_maillage_initial # un mot cle de debut de liste ";
// appel de l'ordre de la classe mère
OrdreVisu::Ecrit_para_OrdreVisu_general(entreePrinc);
// fin
sort << "\n fin_maillage_initial " << " # le mot cle de fin \n";
};