// 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 "AlgoUmatAbaqus.h"
#include "ConstMath.h"
#include "ElemPoint.h"
#include "ElemPoint_CP.h"
#include <vector>
// CONSTRUCTEURS :
AlgoUmatAbaqus::AlgoUmatAbaqus () : // par defaut
Algori()
{ };
// constructeur en fonction du type de calcul et du sous type
// il y a ici lecture des parametres attaches au type
AlgoUmatAbaqus::AlgoUmatAbaqus (const bool avec_typeDeCal
,const list <EnumSousTypeCalcul>& soustype
,const list <bool>& avec_soustypeDeCal
,UtilLecture& entreePrinc) :
Algori(UMAT_ABAQUS,avec_typeDeCal,soustype,avec_soustypeDeCal,entreePrinc)
{ // lecture des paramètres attachés au type de calcul (ici aucun)
switch (entreePrinc.Lec_ent_info())
{ case 0 :
{// pour signaler à Algori qu'il n'y a pas eu de lecture de paramètre
deja_lue_entete_parametre=0;
// puis appel de la méthode de la classe mère
Algori::lecture_Parametres(entreePrinc); break;}
case -11 : // cas de la création d'un fichier de commande
{ Info_commande_parametres(entreePrinc); break;}
case -12 : // cas de la création d'un schéma XML, on ne fait rien à ce niveau
{ break;}
default:
Sortie(1);
}
};
// constructeur de copie
AlgoUmatAbaqus::AlgoUmatAbaqus (const AlgoUmatAbaqus& algo):
Algori(algo)
{ };
// destructeur
AlgoUmatAbaqus::~AlgoUmatAbaqus ()
{
};
// execution de l'algorithme dans le cas non dynamique, implicit, sans contact
void AlgoUmatAbaqus::Execution(ParaGlob * paraGlob,LesMaillages * lesMail
,LesReferences* lesRef,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,VariablesExporter* varExpor,LesLoisDeComp* lesLoisDeComp, DiversStockage* divStock
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts,Resultats* resultats)
{ // on traite le cas particulier de maillage avec des éléments points, sans noeud référencé
// dans le cas où il n'y a pas de noeud rattaché, on ajoute un noeud par défaut
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(UMAT_ABAQUS); // transfert info
int nbmaillage = lesMail->NbMaillage();
int dima = ParaGlob::Dimension();
string nom_rien("");
Element::Signature elempoint(CONSTANT,POINT, MECA_SOLIDE_DEFORMABLE,nom_rien);
Element::Signature elempoint_CP(CONSTANT,POINT_CP, MECA_SOLIDE_DEFORMABLE,nom_rien);
for (int im = 1;im<=nbmaillage;im++)
{ list <Noeud*> listeNoeudSup; // liste des noeuds supplémentaires
int num_noeud = 0;
// le traitement ne concerne que le cas où il n'existe aucun noeud dans le maillage
if ((lesMail->Nombre_element(im) !=0) && (lesMail->Nombre_noeud(im) == 0))
{ int nbN=lesMail->Nombre_element(im);
for (int ine=1;ine<=nbN;ine++)
{ Element & elem = lesMail->Element_LesMaille(im,ine);
Element::Signature signa = elem.Signature_element();
// le traitement ne concerne que les éléments points
if (signa == elempoint)
{ ElemPoint& elemP = *((ElemPoint *) &elem);
// on crée un noeud par défaut qui sera ajouté au maillage à la fin
Coordonnee coorRef(dima); // un point en 0 par défaut
num_noeud++;
Noeud* nevez_noeud = new Noeud(num_noeud,coorRef,im);
listeNoeudSup.push_back(nevez_noeud);
// on complète l'élément
elemP.Associer_noeud (nevez_noeud);
nevez_noeud->Travail_tdt(); // a priori on travaillera à tdt aussi
}
else if (signa == elempoint_CP)
{ ElemPoint_CP& elemP = *((ElemPoint_CP *) &elem);
// on crée un noeud par défaut qui sera ajouté au maillage à la fin
Coordonnee coorRef(dima); // un point en 0 par défaut
num_noeud++;
Noeud* nevez_noeud = new Noeud(num_noeud,coorRef,im);
listeNoeudSup.push_back(nevez_noeud);
// on complète l'élément
elemP.Associer_noeud (nevez_noeud);
nevez_noeud->Travail_tdt(); // a priori on travaillera à tdt aussi
};
};
};
// on s'occupe maintenant d'ajouter les noeuds
lesMail->Ajout_de_Noeuds(listeNoeudSup,im);
};
// on définit le type de calcul a effectuer :
// ici par défaut (pour l'instant) on ne calcul que l'umat
Calcul_Umat(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,lesLoisDeComp
,divStock,charge,lesCondLim,lesContacts,resultats );
};
// Calcul: umat abaqus -> en fait uniquement la loi de comportement pour un point d'intégration
void AlgoUmatAbaqus::Calcul_Umat(ParaGlob * paraGlob,LesMaillages * lesMail,
LesReferences* lesRef,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,LesLoisDeComp* lesLois,DiversStockage* diversStockage,
Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts
,Resultats* resultats)
{ // on met en route une boucle qui ne s'arrête normalement que si on reçoit le signal:
// incre = -1
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(UMAT_ABAQUS); // transfert info
// dans une première étape on effectue une lecture des grandeurs umat transmises par abaqus
// ceci dans le conteneur commun de tous les éléments ElemPoint
// ceci permet d'initialiser le processus
bool utilisation_umat_interne = false; // on utilise des pipes
// on utilise le premier élément du premier maillage pour faire le choix entre POINT et POINT_CP
const ElemPoint::inNeNpti* inne = NULL;
Enum_geom type_point = lesMail->Element_LesMaille(1,1).Id_geometrie();
switch (type_point)
{case POINT: inne =
(ElemPoint::inNeNpti*) & ElemPoint::Lecture_Abaqus(utilisation_umat_interne);
break;
case POINT_CP:inne =
(ElemPoint::inNeNpti*) & ElemPoint_CP::Lecture_Abaqus(utilisation_umat_interne);
break;
default:
cout << "\n *** erreur de def d'un element point, le type "
<< Nom_geom(type_point)
<< " n'est pas pris en compte !! "
<< "\n AlgoUmatAbaqus::Calcul_Umat(...";
Sortie(1);
break;
};
// const ElemPoint::inNeNpti& inne = ElemPoint::Lecture_Abaqus(utilisation_umat_interne);
int nb_maillage_umat = 0; // le numéro de maillage umat
int dernier_increment = *(inne->incre);
int increment_courant = *(inne->incre);
int der_iteration = 0; // = 0 la première fois par défaut car on n'a aucune info sur ce point
int iteration_courante = 0; // avec les paramètes de l'umat
int nbmaillage = lesMail->NbMaillage(); //le nombre actuel de maillage
bool premier_passage = true;
OrdreVisu::EnumTypeIncre type_incre = OrdreVisu::PREMIER_INCRE; // pour la visualisation au fil du calcul
vector <Element*> tab_element; // pour n'attribuer qu'une fois chaque élément
int nb_max_element_enreg=0;
// on vérifie que le premier numéro est non nul
if (*(inne->nbe) <= 0)
{ cout << "\n erreur **** le numero de l'element lu= " << *(inne->nbe)
<< "\n n'est pas utilisable avec la version actuelle d'herezh++ "
<< "\n AlgoUmatAbaqus::Calcul_Umat(..." << endl;
Sortie(1);
};
// --- on complète le maillage initiale: température, loi de comp etc. ---
// def éventuelle de la loi de comp à partir des données du .info
lesMail->Completer(diversStockage,lesLois,lesFonctionsnD);
// deux refs d'éléments qui servent pour les tests
ElemPoint el_ref_point;
ElemPoint_CP el_ref_point_cp;
// normalement on ne sort plus de la boucle suivante
do
{ // affichage pour la mise au point
if (ParaGlob::NiveauImpression() > 6)
{ cout << "\n numero de l'increment = " << *(inne->incre)
<< "\n numero du step = " << *(inne->step)
<< "\n numero de l'element = " << *(inne->nbe)
<< "\n numero du pt integ = " << *(inne->nbpti) << endl;
};
if (premier_passage) // premier passage
{ // création de la liste des éléments
list <Element*> list_elem; // liste de tous les éléments
list <Noeud* > li_noeud; // liste de tous les noeuds
// on récupère "le" noeud lu, qui contient éventuellement des initialisations
// telles que la présence du ddl température, ce qui nous permettra de répercuter
// ces infos sur tous les noeuds créés
Noeud & noeud_de_reference = lesMail->Noeud_LesMaille(1, 1);
// idem pour l'élément
Element & elem_de_reference = lesMail->Element_LesMaille(1,1);
int dima = ParaGlob::Dimension();
int num_noeud=0;
int num_nouveau_maillage=nbmaillage+1;
// // on crée un nouveau maillage vide
// string nom_maillage_N="maillage_intermediaire";
// int num_nouveau_maillage = lesMail->Creation_nouveau_maillage(li_noeud,list_elem,nom_maillage_N);
// modification du temps de manière arbitraire
pa.Modif_temps(*(inne->temps_tdt),*(inne->delta_t));
// deux variables pour sauvegarder les temps utilisés au premier passage
double temps_tdt_premier_passage = *(inne->temps_tdt);
double delta_t_premier_passage = *(inne->delta_t);
do
{ // création de la liste des éléments
Element* elnevez = NULL;
bool element_a_creer = true;
// tout d'abord on regarde si le numéro d'élément a déjà été affecté
// si oui on se sert de l'élément, sinon, on crée un élément nouveau
int nbe = *(inne->nbe);
if (nbe <= nb_max_element_enreg)
{// cas où le numéro est succeptible d'être enregistré
if (tab_element[nbe-1] != NULL)
{ elnevez = tab_element[nbe-1];
element_a_creer = false; // on signale qu'il ne faut pas creer de nouvel élément
};
// sinon l'élément n'existe pas mais la place dans le tableau est disponible
}
else
{// cas où l'élément n'existe pas et la place dans le tableau non plus
// on crée donc la place
Element* elnull = NULL;
for (int i=nb_max_element_enreg+1;i<=nbe;i++)
tab_element.push_back(elnull);
nb_max_element_enreg = nbe;
};
// maintenant on crée si necessaire un nouvel élément
if (element_a_creer)
{ switch (type_point)
{case POINT:
{if (!(el_ref_point.Signature_element() == elem_de_reference.Signature_element()))
{cout << "\n *** erreur: l'element du maillage de base doit etre de type POINT ";
Sortie(1);
};
// sinon c'est ok
ElemPoint& el_ref_po = *((ElemPoint*) &elem_de_reference);
elnevez = new ElemPoint(el_ref_po); // création d'un nouvel élément
break;
}
case POINT_CP:
{if (!(el_ref_point_cp.Signature_element() == elem_de_reference.Signature_element()))
{cout << "\n *** erreur: l'element du maillage de base doit etre de type POINT_CP ";
Sortie(1);
};
// sinon c'est ok
ElemPoint_CP& el_ref_po = *((ElemPoint_CP*) &elem_de_reference);
elnevez = new ElemPoint_CP(el_ref_po); // création d'un nouvel élément
break;
}
// elnevez = new ElemPoint_CP(); // création d'un nouvel élément
// break;
default:
cout << "\n *** erreur de def d'un element point, le type "
<< Nom_geom(type_point)
<< " n'est pas pris en compte !! "
<< "\n AlgoUmatAbaqus::Calcul_Umat(...";
Sortie(1);
break;
};
list_elem.push_back(elnevez);
// on ajoute un noeud par défaut
num_noeud++;
Coordonnee coorRef(dima); // un point en 0 par défaut
//Noeud* nevez_noeud = new Noeud(num_noeud,coorRef,num_nouveau_maillage);
// ** modif 18 avril 2016 : on recopie le noeud initial plutôt qu'une
// création entièrement nouvelle, ceci nous permet d'intégrer des ddl que l'utilisation
// veut, par exemple la température
Noeud* nevez_noeud = new Noeud(noeud_de_reference);
nevez_noeud->Change_num_noeud(num_noeud);
nevez_noeud->Change_num_Mail(num_nouveau_maillage);
nevez_noeud->Change_coord0(coorRef);
li_noeud.push_back(nevez_noeud) ;
// on complète l'élément
ElemPoint* elnew = NULL; // pour simplifier
switch (type_point)
{case POINT: elnew = (ElemPoint*) elnevez; break; // pour simplifier
case POINT_CP: elnew = (ElemPoint_CP*) elnevez; break; // pour simplifier
default:break;
};
elnew->Associer_noeud (nevez_noeud);
nevez_noeud->Travail_tdt(); // a priori on travaillera à tdt aussi
// affichage pour la mise au point
if (ParaGlob::NiveauImpression() > 8)
cout << "\n creation element = " << *(inne->nbe) << endl;
tab_element[nbe-1] = elnevez;
elnevez->Change_num_elt (*(inne->nbe));
// // ------ ensuite l'idée est de complèter l'élément avec les infos lues
// // cependant le nouvel élément n'appartient encore à aucun maillage,
// //donc on l'ajoute au
// // au premier maillage
// list <Noeud *> taN; // liste de noeud à ajouter ici le nouveau
// taN.push_back(nevez_noeud);
// list <Element *> taE;taE.push_back(elnevez); // l'élément à ajouter
// list <const Reference*>* lref=NULL; // rien ici
// lesMail->Ajout_elements_et_noeuds(taN,taE,lref,lesRef,num_nouveau_maillage);
// // ---- cas de la loi de comp -----
// // on complète l'élément éventuellement: en particulier
// // def éventuelle de la loi de comp à partir des données du .info
// lesMail->Completer(diversStockage,lesLois,lesFonctionsnD);
// en fait la vérif suivante ne fonctionne pas, car à ce stade l'élément créé n'appartient
// à aucun maillage, donc la loi choisit dans le .info n'est pas affecté
// donc seule la loi définie par l'appel d'umat, est toujours prise en compte
// on laisse la vérif quand même pour l'instant bien que cela ne sert à rien
// -- vérif de la définition de la loi de comportement
// recup du pointeur le loi
LoiAbstraiteGeneral * pt = lesLois->PtLoi_abstraite(*(inne->nom_loi));
if (pt == NULL)
{ cout << "\n *** erreur, la loi definie dans le .info "<< (*(inne->nom_loi))
<< " n'existe pas !! "
" on stoppe l'execution pour eviter des pb de coherence eventuelles ";
Sortie(1);
};
// récup de la loi éventuellement déjà enregistrée
const Loi_comp_abstraite* loi_actuelle = elnew->LoiDeComportement();
if (loi_actuelle == NULL) // s'il n'y a aucune loi de définie on le fait
{ elnew->DefLoi(pt); }
else if ((pt) != (loi_actuelle))
{ cout << "\n *** erreur, la loi definie dans le .info pour l'element est differente "
" de celle demandee par le programme utilisateur de l'UMAT !! "
" on stoppe l'execution pour eviter des pb de coherence eventuelles ";
Sortie(1);
};
};
// arrivée ici on a l'élément adoc on peut donc calculer
ElemPoint* elnew = (ElemPoint*) elnevez; // pour simplifier
// les cas en initialisation, calcul et écriture sont identique
// pour ElemPoint et ElemPoint_CP donc on garde le pointeur sur
// ElemPoint
// initialisation éventuelle: en particulier def de la loi de comp
// en fonction du nombre de pt d'integ qui a pu changer
elnew->InitialisationUmatAbaqus();
// calcul de l'UMat pour abaqus
elnew->CalculUmatAbaqus(pa);
// écriture du résultat
elnew->Ecriture_Abaqus(utilisation_umat_interne);
// modif: 12 nov 2018: on affiche le num d'incrément avant la lecture pour le prochain
// calcul
increment_courant = *(inne->incre);
if ((ParaGlob::NiveauImpression() > 2) && premier_passage)
{cout << "\n======================================================================"
<< "\nINCREMENT DE CHARGE : " << (*(inne->incre))
<< "\n======================================================================"
<< endl;
};
// comme la lecture est une méthode statique donc non virtualisable
// il est nécessaire de différencier le cas ElemPoint avec le cas ElemPoint_CP
switch (type_point)
{case POINT:
{ElemPoint* elnew1 = (ElemPoint*) elnevez; // pour simplifier
// lecture de nouvelles données
elnew1->Lecture_Abaqus(utilisation_umat_interne);
break;
}
case POINT_CP:
{ElemPoint_CP* elnew1 = (ElemPoint_CP*) elnevez; // pour simplifier
// lecture de nouvelles données
elnew1->Lecture_Abaqus(utilisation_umat_interne);
break;
}
default:break;
};
// increment_courant = *(inne->incre);
// if ((ParaGlob::NiveauImpression() > 2) && premier_passage)
// {cout << "\n======================================================================"
// << "\nINCREMENT DE CHARGE : " << (*(inne->incre))
// << "\n======================================================================"
// << endl;
// };
premier_passage = false;
iteration_courante = elnew->NbIteration();
// on affiche éventuellement si l'on passe d'une itération à l'autre
if (iteration_courante != der_iteration)
{ der_iteration = iteration_courante;
if (ParaGlob::NiveauImpression() > 3)
cout << "\n ITERATION : " << iteration_courante << endl;
};
}
while ( increment_courant == dernier_increment);
// maintenant on a changé de numéro d'incrément, et l'increment est > 1
// on crée le maillage correspondant, avec les noeuds et éléments déjà créé
// (il n'y a pas de création de nouveaux noeuds ou de nouveaux éléments, ainsi
// toutes les infos déjà calculées et stockées sont gardées)
string nom_maillage="maillage_umat";
nb_maillage_umat = lesMail->Creation_nouveau_maillage(li_noeud,list_elem,nom_maillage);
// on supprime les 2 maillages initiaux, sans supprimer les noeuds et éléments créés,
// car ce sont également les noeuds et éléments du nouveau maillage
bool sans_conservation_noeuds_elements = false;
// for (int i=1;i<nb_maillage_umat;i++)
// lesMail->Suppression_maillage(lesMail->NomMaillage(i),sans_conservation_noeuds_elements);
lesMail->Suppression_maillage(lesMail->NomMaillage(1),sans_conservation_noeuds_elements);
// on met à jour le compteur d'itération
der_iteration = iteration_courante;
// modification du temps correspondant au premier passage
pa.Modif_temps(temps_tdt_premier_passage,delta_t_premier_passage);
// on s'occupe d'une sortie si necessaire
if (this->Active_sauvegarde())
{ // si le fichier base_info n'est pas en service on l'ouvre
entreePrinc->Ouverture_base_info("ecriture");
// dans le cas ou se n'est pas un restart on sauvegarde l'incrément actuel
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ entreePrinc->Sort_BI_Positionnement_offset(entreePrinc->position_debut_fichier);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
(cas,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,lesLois,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::INCRE_0);
// visualisation éventuelle au fil du calcul
VisuAuFilDuCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,lesLois,diversStockage,charge
,lesCondLim,lesContacts,resultats,type_incre,(*(inne->incre)-1));
};
};
}
else
{ // ----- cas des incréments courants > 1------
// récupération de l'élément
if (ParaGlob::NiveauImpression() > 8)
cout << "\n numero de l'element = " <<*(inne->nbe) << endl;
//Element& elem = lesMail->Element_LesMaille(nb_maillage_umat,*(inne->nbe));
// pour éviter des pb d'adressage indirecte on utilise directement le tableau
// de pointeur pour retrouver l'élément plutôt que lesMail
Element* elem = NULL;
if (tab_element[*(inne->nbe)-1] != NULL)
{elem = tab_element[*(inne->nbe)-1];}
else
{ cout << "\n erreur l'element demande (nb=" << *(inne->nbe)-1 << ") n'a pas ete attribue "
<< "dans la phase d'initialisation c-a-d lors du premier increment"
<< "\n AlgoUmatAbaqus::Calcul_Umat(...";
Sortie(1);
};
ElemPoint* el = (ElemPoint*) elem; // pour simplifier
// calcul de l'UMat pour abaqus
el->CalculUmatAbaqus(pa);
// écriture du résultat
el->Ecriture_Abaqus(utilisation_umat_interne);
// comme la lecture est une méthode statique donc non virtualisable
// il est nécessaire de différencier le cas ElemPoint avec le cas ElemPoint_CP
switch (type_point)
{case POINT:
{ElemPoint* el1 = (ElemPoint*) elem; // pour simplifier
// lecture de nouvelles données
el1->Lecture_Abaqus(utilisation_umat_interne);
break;
}
case POINT_CP:
{ElemPoint_CP * el1 = (ElemPoint_CP*) elem; // pour simplifier
// lecture de nouvelles données
el1->Lecture_Abaqus(utilisation_umat_interne);
break;
}
default:break;
};
// // lecture de nouvelles données
// el->Lecture_Abaqus(utilisation_umat_interne);
increment_courant = *(inne->incre);
iteration_courante = el->NbIteration();;
};
// on note si l'on passe d'une itération à l'autre
if (iteration_courante != der_iteration)
{ der_iteration = iteration_courante;
if (ParaGlob::NiveauImpression() > 3)
cout << "\n ITERATION : " << iteration_courante << endl;
};
// mise à jour de t à tdt
if (increment_courant != dernier_increment)
{// modification du temps
pa.Modif_temps(*(inne->temps_tdt),*(inne->delta_t));
lesMail->TdtversT();
dernier_increment = increment_courant;
// --- traitement des sauvegardes éventuelles ---
// sauvegarde de l'incrément si nécessaire
Ecriture_base_info(2,lesMail,lesRef,lesCourbes1D,lesFonctionsnD
,lesLois,diversStockage,charge,lesCondLim,lesContacts
,resultats,type_incre,(*(inne->incre)-1));
// enregistrement du num d'incrément et du temps correspondant
list_incre_temps_calculer.push_front(Entier_et_Double((*(inne->incre)-1),pa.Variables_de_temps().TempsCourant()));
// visualisation éventuelle au fil du calcul
VisuAuFilDuCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,lesLois,diversStockage,charge
,lesCondLim,lesContacts,resultats,type_incre,(*(inne->incre)-1));
// on affiche éventuellement le prochain incrément
if (ParaGlob::NiveauImpression() > 1)
{cout << "\n======================================================================"
<< "\nINCREMENT DE CHARGE : " << (*(inne->incre))
<< "\n======================================================================"
<< endl;
};
};
} while (*(ElemPoint::IncreElemPtint_encours().incre)!=-1);
// fin
};
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void AlgoUmatAbaqus::Ecrit_Base_info_Parametre(ostream& sort,const int& cas)
{
// récup du flot
// ofstream * sort = entreePrinc.Sort_BI();
// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
// ecriture: rien pour l'instant
// if (cas == 1)
// {
// } ;
// (*sort) << "\n fin_parametres_algo_specifiques_ ";
};
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void AlgoUmatAbaqus::Lecture_Base_info_Parametre(istream& ent,const int& cas,bool choix)
{if (cas == 1)
{if (choix)
{// cas d'une lecture normale
// récup du flot
// ifstream * ent = entreePrinc.Ent_BI();
// pour l'instant on ne lit rien
}
}
};
// création d'un fichier de commande: cas des paramètres spécifiques
void AlgoUmatAbaqus::Info_commande_parametres(UtilLecture& entreePrinc)
{ // écriture dans le fichier de commande
ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
sort << "\n#--------------------------------------------------------------------"
<< "\n| parametres (falcultatifs) associes l'algorithme umat pour abaqus |"
<< "\n#--------------------------------------------------------------------"
<< "\n"
<< "\n # aucun parametre pour l'instant ";
sort << "\n" << endl;
};