1210 lines
57 KiB
C++
1210 lines
57 KiB
C++
|
|
// 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 "DiversStockage.h"
|
|
#include "CharUtil.h"
|
|
#include "Ddl_enum_etendu.h"
|
|
|
|
|
|
DiversStockage::DiversStockage () : // constructeur par defaut
|
|
tabEpaiss(),tabLargeurs(),tabSection(),tabMasseAddi(),tabMasseVolu(),tabCoefDila()
|
|
,tabGesHourglass(),tabIntegVol(),tabIntegVol_et_temps(),tabStabMembraneBiel()
|
|
,tabRepAnisotrope(),tabStatistique(),tabStatistique_et_temps()
|
|
{
|
|
}
|
|
|
|
// affichage des infos
|
|
void DiversStockage::Affiche () const // affichage de tous les infos
|
|
{ Affiche1();
|
|
Affiche2();
|
|
}
|
|
|
|
void DiversStockage::Affiche1 () const
|
|
{ bool te = false;
|
|
if (tabEpaiss.Taille() != 0)
|
|
{if (!te)
|
|
{cout << "\n ******** DiversStockages 1er lecture ******** \n";te = true;}
|
|
cout << tabEpaiss.Taille() << " reference(s) d epaisseur lue \n";
|
|
for (int i=1; i<=tabEpaiss.Taille(); i++)
|
|
tabEpaiss(i).Affiche();
|
|
cout << "\n\n";
|
|
}
|
|
if (tabLargeurs.Taille() != 0)
|
|
{if (!te)
|
|
{cout << "\n ******** DiversStockages 1er lecture ******** \n";te = true;}
|
|
cout << tabLargeurs.Taille() << " reference(s) de largeur lue \n";
|
|
for (int i=1; i<=tabLargeurs.Taille(); i++)
|
|
tabLargeurs(i).Affiche();
|
|
cout << "\n\n";
|
|
}
|
|
if (tabSection.Taille() != 0)
|
|
{if (!te)
|
|
{cout << "\n ******** DiversStockages 1er lecture ******** \n";te = true;}
|
|
cout << tabSection.Taille() << " reference(s) de section lue \n";
|
|
for (int i=1; i<=tabSection.Taille(); i++)
|
|
tabSection(i).Affiche();
|
|
cout << "\n\n";
|
|
}
|
|
if (tabVarSection.Taille() != 0)
|
|
{if (!te)
|
|
{cout << "\n ******** DiversStockages 1er lecture ******** \n";te = true;}
|
|
cout << tabVarSection.Taille() << " reference(s) de variation de section lue \n";
|
|
for (int i=1; i<=tabVarSection.Taille(); i++)
|
|
tabVarSection(i).Affiche();
|
|
cout << "\n\n";
|
|
}
|
|
if (tabMasseVolu.Taille() != 0)
|
|
{if (!te)
|
|
{cout << "\n ******** DiversStockages 1er lecture ******** \n";te = true;}
|
|
cout << tabMasseVolu.Taille() << " reference(s) de masse volumique lue \n";
|
|
for (int i=1; i<=tabMasseVolu.Taille(); i++)
|
|
tabMasseVolu(i).Affiche();
|
|
cout << "\n\n";
|
|
}
|
|
if (tabCoefDila.Taille() != 0)
|
|
{if (!te)
|
|
{cout << "\n ******** DiversStockages 1er lecture ******** \n";te = true;}
|
|
cout << tabCoefDila.Taille() << " reference(s) de coefficient de dilatation thermique lue \n";
|
|
for (int i=1; i<=tabCoefDila.Taille(); i++)
|
|
tabCoefDila(i).Affiche();
|
|
cout << "\n\n";
|
|
}
|
|
if (tabGesHourglass.Taille() != 0)
|
|
{if (!te)
|
|
{cout << "\n ******** DiversStockages 1er lecture ******** \n";te = true;}
|
|
cout << tabGesHourglass.Taille() << " reference(s) de blocage d'hourglass lue \n";
|
|
for (int i=1; i<=tabGesHourglass.Taille(); i++)
|
|
tabGesHourglass(i).Affiche();
|
|
cout << "\n\n";
|
|
}
|
|
if (tabIntegVol.Taille() != 0)
|
|
{if (!te)
|
|
{cout << "\n ******** DiversStockages 1er lecture ******** \n";te = true;}
|
|
cout << tabIntegVol.Taille() << " reference(s) de grandeur a integrer sur le volume \n";
|
|
for (int i=1; i<=tabIntegVol.Taille(); i++)
|
|
tabIntegVol(i).Affiche();
|
|
cout << "\n\n";
|
|
};
|
|
if (tabIntegVol_et_temps.Taille() != 0)
|
|
{if (!te)
|
|
{cout << "\n ******** DiversStockages 1er lecture ******** \n";te = true;}
|
|
cout << tabIntegVol_et_temps.Taille() << " reference(s) de grandeur a integrer sur le volume et dans le temps \n";
|
|
for (int i=1; i<=tabIntegVol_et_temps.Taille(); i++)
|
|
tabIntegVol_et_temps(i).Affiche();
|
|
cout << "\n\n";
|
|
};
|
|
if (tabStabMembraneBiel.Taille() != 0)
|
|
{if (!te)
|
|
{cout << "\n ******** DiversStockages 1er lecture ******** \n";te = true;}
|
|
cout << tabStabMembraneBiel.Taille() << " reference(s) de stabilisation transversale \n";
|
|
for (int i=1; i<=tabStabMembraneBiel.Taille(); i++)
|
|
tabStabMembraneBiel(i).Affiche();
|
|
cout << "\n\n";
|
|
};
|
|
if (tabRepAnisotrope.Taille() != 0)
|
|
{if (!te)
|
|
{cout << "\n ******** DiversStockages 1er lecture ******** \n";te = true;}
|
|
cout << tabRepAnisotrope.Taille() << " reference(s) de def de repere d'anisotropie \n";
|
|
for (int i=1; i<=tabRepAnisotrope.Taille(); i++)
|
|
tabRepAnisotrope(i).Affiche();
|
|
cout << "\n\n";
|
|
};
|
|
if (tabStatistique.Taille() != 0)
|
|
{if (!te)
|
|
{cout << "\n ******** DiversStockages 1er lecture ******** \n";te = true;}
|
|
cout << tabStatistique.Taille()
|
|
<< " reference(s) d'une statistique d'une ref de noeuds pour une grandeur quelconque \n";
|
|
for (int i=1; i<=tabStatistique.Taille(); i++)
|
|
tabStatistique(i).Affiche();
|
|
cout << "\n\n";
|
|
};
|
|
if (tabStatistique_et_temps.Taille() != 0)
|
|
{if (!te)
|
|
{cout << "\n ******** DiversStockages 1er lecture ******** \n";te = true;}
|
|
cout << tabStatistique_et_temps.Taille()
|
|
<< " reference(s) d'une statistique d'une ref de noeuds cumulee en temps pour une grandeur queconque \n";
|
|
for (int i=1; i<=tabStatistique_et_temps.Taille(); i++)
|
|
tabStatistique_et_temps(i).Affiche();
|
|
cout << "\n\n";
|
|
};
|
|
|
|
cout << endl;
|
|
};
|
|
|
|
void DiversStockage::Affiche2 () const
|
|
{ bool te = false;
|
|
if (tabMasseAddi.Taille() != 0)
|
|
{if (!te)
|
|
{cout << "\n ******** DiversStockages 2ieme lecture ******** \n"; te = true;}
|
|
cout << tabMasseAddi.Taille() << " reference(s) de masse additionnelle lue \n";
|
|
for (int i=1; i<=tabMasseAddi.Taille(); i++)
|
|
tabMasseAddi(i).Affiche();
|
|
cout << "\n\n";
|
|
}
|
|
|
|
cout << endl;
|
|
};
|
|
|
|
// lecture des infos
|
|
void DiversStockage::Lecture1(UtilLecture & entreePrinc,LesReferences& lesRef)
|
|
{ MotCle motCle; // ref aux mots cle
|
|
// on se positionne sur un mot cle
|
|
while ( !motCle.SimotCle(entreePrinc.tablcar))
|
|
entreePrinc.NouvelleDonnee();
|
|
bool sortie_info = false;
|
|
if ( (strstr(entreePrinc.tablcar,"epaisseurs")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"largeurs")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"masse_volumique")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"dilatation_thermique")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"hourglass_gestion_")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"sections")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"variation_section")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"integrale_sur_volume_")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"integrale_sur_vol_et_temps_")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"stabilisation_transvers_membrane_biel_")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"repere_anisotropie_")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"statistique_sur_RefNoeuds_")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"statistique_sur_RefNoeuds_et_temps_")!=NULL)
|
|
)
|
|
{if (ParaGlob::NiveauImpression() >= 4)
|
|
cout << " debut de la lecture des divers stockages 1 " << endl;
|
|
sortie_info = true;
|
|
};
|
|
// def d'une classe de lecture de bloc scalaire
|
|
LectBloc < BlocDdlLim<BlocScal> > lecScal;
|
|
// def d'une classe de lecture de bloc BlocScal_ou_fctnD
|
|
LectBloc < BlocDdlLim<BlocScal_ou_fctnD> > lecBlocScal_ou_fctnD;
|
|
// def d'une classe de lecture de bloc généraux
|
|
LectBloc < BlocDdlLim<BlocGen_3_1> > lecGen;
|
|
// def d'une classe de lecture de bloc généraux pour les intégrales
|
|
LectBloc < BlocDdlLim<BlocGen_3_0> > lecGen3_0;
|
|
// def d'une classe de lecture de bloc généraux pour la stabilisation membrane et/ou biel
|
|
// ici par défaut c'est un bloc 4,0 mais peut s'agrandir en fonction de la lecture
|
|
// cependant on garde le type BlocGen_4_0 car on ne peut pas faire de BlocDdlLim
|
|
// d'un bloc gen (4,0)
|
|
LectBloc < BlocDdlLim<BlocGen_4_0> > lecGen4_0;
|
|
// def d'une classe de lecture de bloc généraux pour la définition de repère d'anisotropie
|
|
LectBloc < BlocDdlLim<BlocGen_6_0> > lecGen6_0;
|
|
// maintenant il faut gérer le fait que l'on peut avoir les infos dans le désordre
|
|
// c'est à dire par exemple épaisseurs puis largeur, ou encore l'inverse etc..
|
|
// on doit arrêter la procédure de lecture lorqu'il n'y a plus a lire
|
|
while ( (strstr(entreePrinc.tablcar,"epaisseurs")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"largeurs")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"masse_volumique")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"dilatation_thermique")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"hourglass_gestion_")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"sections")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"variation_section")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"integrale_sur_volume_")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"integrale_sur_vol_et_temps_")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"stabilisation_transvers_membrane_biel_")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"repere_anisotropie_")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"statistique_sur_RefNoeuds_")!=NULL) ||
|
|
(strstr(entreePrinc.tablcar,"statistique_sur_RefNoeuds_et_temps_")!=NULL)
|
|
)
|
|
|
|
{
|
|
// lecture eventuelle des epaisseurs
|
|
lecBlocScal_ou_fctnD.Lecture(entreePrinc,lesRef,"epaisseurs",
|
|
" lecture des epaisseurs ",tabEpaiss);
|
|
// lecture eventuelle des largeurs
|
|
lecBlocScal_ou_fctnD.Lecture(entreePrinc,lesRef,"largeurs",
|
|
" lecture des largeurs ",tabLargeurs);
|
|
// lecture eventuelle des sections
|
|
lecBlocScal_ou_fctnD.Lecture(entreePrinc,lesRef,"sections",
|
|
" lecture des sections ",tabSection);
|
|
// lecture eventuelle des variations de section
|
|
lecScal.Lecture(entreePrinc,lesRef,"variation_section",
|
|
" lecture des sections ",tabVarSection);
|
|
// lecture eventuelle des masse_volumiques
|
|
lecBlocScal_ou_fctnD.Lecture(entreePrinc,lesRef,"masse_volumique",
|
|
" lecture des masse_volumique ",tabMasseVolu);
|
|
// lecture eventuelle des coefficients de dilatation thermique
|
|
lecBlocScal_ou_fctnD.Lecture(entreePrinc,lesRef,"dilatation_thermique",
|
|
" lecture des coefficients de dilatation thermique ",tabCoefDila);
|
|
// lecture eventuelle de la gestion des modes d'hourglass
|
|
lecGen.Lecture(entreePrinc,lesRef,"hourglass_gestion_",
|
|
" lecture de la gestion des modes d'hourglass ",tabGesHourglass);
|
|
// lecture eventuelle des intégrales sur le volume
|
|
lecGen3_0.Lecture(entreePrinc,lesRef,"integrale_sur_volume_",
|
|
" lecture des integrales sur le volume ",tabIntegVol);
|
|
// lecture eventuelle des intégrales sur le volume et sur le temps
|
|
lecGen3_0.Lecture(entreePrinc,lesRef,"integrale_sur_vol_et_temps_",
|
|
" lecture des integrales sur le volume et le temps ",tabIntegVol_et_temps);
|
|
|
|
// lecture eventuelle d'une stabilisation transversale de membrane ou biel
|
|
lecGen4_0.Lecture(entreePrinc,lesRef,"stabilisation_transvers_membrane_biel_",
|
|
" lecture des stabilisations transversales ",tabStabMembraneBiel);
|
|
|
|
// lecture eventuelle de repère d'anisotropie à des éléments
|
|
lecGen6_0.Lecture(entreePrinc,lesRef,"repere_anisotropie_",
|
|
" lecture d'un repere d'anisotropie ",tabRepAnisotrope);
|
|
// lecture eventuelle des statistiques de ref de noeuds pour une grandeur quelconque
|
|
lecGen3_0.Lecture(entreePrinc,lesRef,"statistique_sur_RefNoeuds_",
|
|
" lecture des statistique_sur_RefNoeuds_ ",tabStatistique);
|
|
// lecture eventuelle des statistiques de ref de noeuds pour une grandeur
|
|
// quelconque avec cumul sur le temps
|
|
lecGen3_0.Lecture(entreePrinc,lesRef,"statistique_sur_RefNoeuds_et_temps_",
|
|
" lecture des statistique_sur_RefNoeuds_et_temps_",tabStatistique_et_temps);
|
|
|
|
|
|
};
|
|
|
|
////----- debug ---
|
|
//cout << "\n debug DiversStockage::Lecture1( "
|
|
// << "\n tabRepAnisotrope= "<< tabRepAnisotrope << endl;
|
|
////---- fin debug ---
|
|
|
|
// on vérifie qu'il n'y a pas 2 fois exactements les mêmes intégrales a effectuer, si oui on couine
|
|
// car cela va poser des pb
|
|
{int taille = tabIntegVol.Taille();
|
|
for (int i=1;i<= taille-1;i++)
|
|
for (int j=i+1;j<= taille;j++)
|
|
if (tabIntegVol(i) == tabIntegVol(j))
|
|
{cout << "\n erreur*** il y a deux integrales de volume qui sont strictement identiques "
|
|
<< " cela va poser des problemes de referencement a l'execution, il faut en supprimer une !! "
|
|
<< "\n integrale: "<< tabIntegVol(i)
|
|
<< endl;
|
|
Sortie(1);
|
|
};
|
|
};
|
|
{int taille = tabIntegVol_et_temps.Taille();
|
|
for (int i=1;i<= taille-1;i++)
|
|
for (int j=i+1;j<= taille;j++)
|
|
if (tabIntegVol_et_temps(i) == tabIntegVol_et_temps(j))
|
|
{cout << "\n erreur*** il y a deux integrales de volume et en temps qui sont strictement identiques "
|
|
<< " cela va poser des problemes de referencement a l'execution, il faut en supprimer une !! "
|
|
<< "\n integrale: "<< tabIntegVol_et_temps(i)
|
|
<< endl;
|
|
Sortie(1);
|
|
};
|
|
};
|
|
|
|
// on vérifie qu'il n'y a pas 2 fois exactements les mêmes statistique a effectuer, si oui on couine
|
|
// car cela va poser des pb
|
|
{int taille = tabStatistique.Taille();
|
|
for (int i=1;i<= taille-1;i++)
|
|
for (int j=i+1;j<= taille;j++)
|
|
if (tabStatistique(i) == tabStatistique(j))
|
|
{cout << "\n erreur*** il y a deux statistiques qui sont strictement identiques "
|
|
<< " cela va poser des problemes de referencement a l'execution, il faut en supprimer une !! "
|
|
<< "\n statistique: "<< tabStatistique(i)
|
|
<< endl;
|
|
Sortie(1);
|
|
};
|
|
};
|
|
{int taille = tabStatistique_et_temps.Taille();
|
|
for (int i=1;i<= taille-1;i++)
|
|
for (int j=i+1;j<= taille;j++)
|
|
if (tabStatistique_et_temps(i) == tabStatistique_et_temps(j))
|
|
{cout << "\n erreur*** il y a deux statistiques avec cumul en temps qui sont strictement identiques "
|
|
<< " cela va poser des problemes de referencement a l'execution, il faut en supprimer une !! "
|
|
<< "\n statistiques: "<< tabStatistique_et_temps(i)
|
|
<< endl;
|
|
Sortie(1);
|
|
};
|
|
};
|
|
|
|
|
|
if ((ParaGlob::NiveauImpression() >= 4) && sortie_info)
|
|
cout << " fin de la lecture des divers stockages 1 " << endl;
|
|
};
|
|
|
|
// dans la seconde lecture il s'agit des masses additionnelles
|
|
void DiversStockage::Lecture2(UtilLecture & entreePrinc,LesReferences& lesRef)
|
|
{ MotCle motCle; // ref aux mots cle
|
|
// on se positionne sur un mot cle
|
|
while ( !motCle.SimotCle(entreePrinc.tablcar))
|
|
entreePrinc.NouvelleDonnee();
|
|
bool sortie_info = false;
|
|
if ( (strstr(entreePrinc.tablcar,"masse_addi")!=NULL) )
|
|
{if (ParaGlob::NiveauImpression() >= 4)
|
|
cout << " debut de la lecture des divers stockages 2 " << endl;
|
|
sortie_info = true;
|
|
}
|
|
// def d'une classe de lecture de bloc scalaire
|
|
LectBloc < BlocDdlLim<BlocScal_ou_fctnD> > lecScal;
|
|
|
|
// lecture eventuelle des masses
|
|
lecScal.Lecture(entreePrinc,lesRef,"masse_addi",
|
|
" lecture des masses additionnelles ",tabMasseAddi);
|
|
if ((ParaGlob::NiveauImpression() >= 4) && sortie_info)
|
|
cout << " fin de la lecture des divers stockages 2 " << endl;
|
|
};
|
|
|
|
// affichage et definition interactive des commandes
|
|
void DiversStockage::Info_commande_DiversStockage1(UtilLecture & entreePrinc)
|
|
{ ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
|
|
//On va proposer un menu
|
|
string rep=" ";
|
|
bool plusieurs_maillages = false;
|
|
sort << "\n# --- divers stockages (1) ------- ";
|
|
cout << "\n cas d'un seul maillage (par defaut) : rep o "
|
|
<< "\n cas de plusieurs maillages : rep n ";
|
|
// procédure de lecture avec prise en charge d'un retour chariot
|
|
rep = lect_return_defaut(true,"o");
|
|
if (rep == "n")
|
|
{ plusieurs_maillages = true;};
|
|
rep="_"; // init
|
|
while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
|
|
{
|
|
try
|
|
{
|
|
cout << "\n -- definition de : --- "
|
|
<< "\n (0 ou f) (fin) "
|
|
<< "\n (1) epaisseurs "
|
|
<< "\n (2) largeurs "
|
|
<< "\n (3) sections "
|
|
<< "\n (4) variation de section "
|
|
<< "\n (5) masse volumique (obligatoire)"
|
|
<< "\n (6) dilatation_thermique "
|
|
<< "\n (7) gestion hourglass "
|
|
<< "\n (8) integrale sur volume "
|
|
<< "\n (9) integrale sur volume et temps "
|
|
<< "\n (10) stabilisation transversale "
|
|
<< "\n (11) repere d'anisotropie "
|
|
<< "\n (12) statistique sur ref de noeuds "
|
|
<< "\n (13) statistique sur ref de noeuds et temps "
|
|
<< "\n (14 ou ? ) informations "
|
|
<< "\n ";
|
|
rep = lect_return_defaut(false,"f");
|
|
if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie directe
|
|
break;
|
|
int num = ChangeEntier(rep);
|
|
if (Minuscules(rep) == "?")
|
|
num = 14;
|
|
bool choix_valide=false;
|
|
if ((num >= 0)&&(num< 15))
|
|
{ choix_valide=true; }
|
|
else { cout << "\n Erreur on attendait un entier entre 0 et 14 !!, "
|
|
<< "\n redonnez une bonne valeur"
|
|
<< "\n ou taper f ou 0 pour arreter le programme";
|
|
choix_valide=false;
|
|
}
|
|
string grandeur=" "; // init
|
|
// cas d'une grandeur simple
|
|
switch (num)
|
|
{ case 1: grandeur = "epaisseurs";break;
|
|
case 2: grandeur = "largeurs";break;
|
|
case 3: grandeur = "sections";break;
|
|
case 4: grandeur = "variation_section";break;
|
|
case 5: grandeur = "masse_volumique";break;
|
|
case 6: grandeur = "dilatation_thermique";break;
|
|
case 7: grandeur = "hourglass_gestion_";break;
|
|
case 8: grandeur = "integrale_sur_volume_";break;
|
|
case 9: grandeur = "integrale_sur_vol_et_temps_";break;
|
|
case 10: grandeur = "stabilisation_transvers_membrane_biel_";break;
|
|
case 11: grandeur = "repere_anisotropie_";break;
|
|
case 12: grandeur = "statistique_sur_RefNoeuds_";break;
|
|
case 13: grandeur = "statistique_sur_RefNoeuds_et_temps_";break;
|
|
};
|
|
|
|
switch (num)
|
|
{ case 0: // sortie
|
|
{ break;} // normalement cela a déjà été filtré avant
|
|
case 1: case 2: case 3: case 5: case 6:
|
|
{ cout << "\n def de la ref associee : ";
|
|
bool lecture_ok=true; // init a priori
|
|
string sortie = "\n " + grandeur + " #--------# \n";;
|
|
//sort << "\n "<< grandeur<<" #--------# \n";
|
|
if (plusieurs_maillages)
|
|
{ string nom_mail=" ";
|
|
cout << "\n nom du maillage ? ";
|
|
nom_mail= lect_chaine(); cout << " nom lu = "<< nom_mail;
|
|
sortie += " nom_mail= " + nom_mail + " ";
|
|
// sort << " nom_mail= "<< nom_mail<< " ";
|
|
};
|
|
cout << "\n nom de la reference ? ";
|
|
string nom_ref=" ";
|
|
nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
|
|
if (nom_ref.at(0) != 'E')
|
|
{cout << "\n *** erreur, la premiere lettre de la ref d'element "
|
|
<< " doit etre E et non "<< nom_ref.at(0)<< " !!";
|
|
lecture_ok = false;
|
|
break;
|
|
}
|
|
else {sortie += " " + nom_ref+" ";} ;
|
|
|
|
int int_choix_loc=0;string rep_loc("");
|
|
while ((int_choix_loc > 3) || (int_choix_loc < 1))
|
|
{cout << "\n --- definition de la valeur --- "
|
|
<< "\n (1) valeur fixe -> un reel "
|
|
<< "\n (2) valeur via une fonction nD "
|
|
<< "\n (3 ou f ) arret "
|
|
<< "\n ";
|
|
rep_loc = lect_return_defaut(false,"f"); Minuscules(rep_loc);
|
|
int_choix_loc = ChangeEntier(rep_loc);
|
|
if ((rep_loc == "f")||(int_choix_loc == 3))
|
|
{lecture_ok = false; break;
|
|
};
|
|
switch (int_choix_loc)
|
|
{case 1:
|
|
{double d=0.;// init
|
|
cout << "\n un reel ? ";
|
|
d=lect_double();cout << " valeur lue = "<< d;
|
|
sortie += ChangeReelSTring(d)+" ";
|
|
}
|
|
break;
|
|
case 2:
|
|
{ cout << "\n nom de la fonction nD ? ";
|
|
string nom_fnD("");
|
|
nom_fnD= lect_chaine();cout << " nom lu = "<< nom_fnD;
|
|
sortie += " une_fonction_nD_ " + nom_fnD;
|
|
};
|
|
break;
|
|
default:
|
|
{cout << "\n *** mauvais choix, vous devez donner une valeur entre 1 et 3 !"
|
|
<< "\n recommencer ";
|
|
};
|
|
};
|
|
};
|
|
if(lecture_ok)
|
|
sort << sortie;
|
|
break;
|
|
}
|
|
case 4:
|
|
{ cout << "\n def de la ref associee : ";
|
|
string sortie = "\n " + grandeur + " #--------# \n";;
|
|
//sort << "\n "<< grandeur<<" #--------# \n";
|
|
if (plusieurs_maillages)
|
|
{ string nom_mail=" ";
|
|
cout << "\n nom du maillage ? ";
|
|
nom_mail= lect_chaine(); cout << " nom lu = "<< nom_mail;
|
|
sortie += " nom_mail= " + nom_mail + " ";
|
|
// sort << " nom_mail= "<< nom_mail<< " ";
|
|
};
|
|
cout << "\n nom de la reference ? ";
|
|
string nom_ref=" ";
|
|
nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
|
|
if (nom_ref.at(0) != 'E')
|
|
{cout << "\n *** erreur, la premiere lettre de la ref d'element "
|
|
<< " doit etre E et non "<< nom_ref.at(0)<< " !!";
|
|
break;
|
|
};
|
|
cout << "\n valeur de: " << grandeur<<" (un entier) ? ";
|
|
int a = 0.;
|
|
a=(int) lect_double();cout << " valeur lue ="<< a;
|
|
sort << sortie;
|
|
sort << nom_ref << " " << a << " ";
|
|
break;
|
|
}
|
|
case 7:
|
|
{ cout << "\n def de la ref associee : ";
|
|
string sortie = "\n\n " + grandeur + " #--------# ";
|
|
//sort << "\n\n "<< grandeur<<" #--------# ";
|
|
//sort << "\n#----------------------------------------------------\n";
|
|
sortie += "\n#----------------------------------------------------\n";
|
|
if (plusieurs_maillages)
|
|
{ string nom_mail=" ";
|
|
cout << "\n nom du maillage ? ";
|
|
nom_mail= lect_chaine(); cout << " nom lu = "<< nom_mail;
|
|
//sort << " nom_mail= "<< nom_mail<< " ";
|
|
sortie += " nom_mail= " + nom_mail + " ";
|
|
};
|
|
cout << "\n nom de la reference d'element ? ";
|
|
string nom_ref=" ";
|
|
nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
|
|
// choix du type de stabilisation
|
|
int choix_type_stabilistion = 0;
|
|
string type_stabilistion_lu="";
|
|
while (choix_type_stabilistion == 0)
|
|
{ cout << "\n -- choix du type de stabilisation --- "
|
|
<< "\n (1) STABHOURGLASS_PAR_COMPORTEMENT "
|
|
<< "\n (2) STABHOURGLASS_PAR_COMPORTEMENT_REDUIT (par defaut)"
|
|
<< "\n ";
|
|
type_stabilistion_lu= lect_chaine(); cout << " valeur lue ="<< type_stabilistion_lu;
|
|
if (type_stabilistion_lu == "1" )
|
|
{type_stabilistion_lu = " STABHOURGLASS_PAR_COMPORTEMENT ";choix_type_stabilistion=1;}
|
|
else if (type_stabilistion_lu == "2" )
|
|
{type_stabilistion_lu = " STABHOURGLASS_PAR_COMPORTEMENT_REDUIT ";choix_type_stabilistion=2;};
|
|
};
|
|
cout << "\n stabilisation par comportement: "
|
|
<< " nom associe a la loi ? ";
|
|
string nom_loi="_";
|
|
nom_loi= lect_chaine();cout << " nom lu = "<< nom_loi;
|
|
cout << "\n valeur de alpha (un reel) ? ";
|
|
double alpha= 0.;
|
|
alpha=lect_double();cout << " valeur lu = "<< alpha;
|
|
sort << sortie;
|
|
sort << nom_ref << type_stabilistion_lu
|
|
<< nom_loi << " " << alpha << " ";
|
|
break;
|
|
}
|
|
case 8: case 9:
|
|
{ string type_integrale;
|
|
if (num == 8) type_integrale="integrale_sur_volume_";
|
|
else type_integrale="integrale_sur_vol_et_temps_";
|
|
|
|
cout << "\n def de la ref associee : ";
|
|
string sortie = "\n\n " + grandeur + " #--------# ";
|
|
//sort << "\n\n "<< grandeur<<" #--------# ";
|
|
//sort << "\n#----------------------------------------------------\n";
|
|
sortie += "\n#----------------------------------------------------\n";
|
|
if (plusieurs_maillages)
|
|
{ string nom_mail=" ";
|
|
cout << "\n nom du maillage ? ";
|
|
nom_mail= lect_chaine(); cout << " nom lu = "<< nom_mail;
|
|
//sort << " nom_mail= "<< nom_mail<< " ";
|
|
sortie += " nom_mail= " + nom_mail + " ";
|
|
};
|
|
cout << "\n nom de la reference d'element ? ";
|
|
string nom_ref=" ";
|
|
nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
|
|
// maintenant choix de la grandeur à intégrer
|
|
int choix_type_grandeur = 0;
|
|
string type_grandeur_lu="";
|
|
while (choix_type_grandeur == 0)
|
|
{ cout << "\n -- choix du type de grandeur a integrer sur le volume --- "
|
|
<< "\n (1) un ddl etendu "
|
|
<< "\n (2) une fonction nD "
|
|
<< "\n (f) fin sans sauvegarde (defaut) ";
|
|
type_grandeur_lu=lect_return_defaut(false,"f");
|
|
cout << " valeur lue ="<< type_grandeur_lu;
|
|
if (type_grandeur_lu == "1" )
|
|
{ string nom_ddl("");
|
|
Ddl_enum_etendu ddl;
|
|
cout << "\n nom du ddl "; nom_ddl= lect_chaine();
|
|
cout << " valeur lue = "<< nom_ddl;
|
|
if (!(ddl.VerifExistence(nom_ddl)))
|
|
{ cout << "\n *** "<<nom_ddl<< " n'est pas un nom de ddl, recommencer ou f pour fin ";
|
|
}
|
|
else
|
|
{ // sortie de la ligne
|
|
Ddl_enum_etendu ddl_sor(nom_ddl); // on crée le ddl de sortie
|
|
sort << sortie << nom_ref << " un_ddl_etendu_ " << ddl_sor.Nom_plein() << " ";
|
|
choix_type_grandeur = 1;
|
|
break;
|
|
};
|
|
}
|
|
else if (type_grandeur_lu == "2" )
|
|
{ string nom_fct_nD("");
|
|
cout << "\n nom de la fonction nD "; nom_fct_nD= lect_chaine();
|
|
cout << " valeur lue ="<< nom_fct_nD;
|
|
// sortie de la ligne
|
|
sort << sortie << type_integrale << " une_fonction_nD_ " << nom_fct_nD << " ";
|
|
choix_type_grandeur = 1;
|
|
break;
|
|
}
|
|
else if (Minuscules(type_grandeur_lu) == "f" ) {choix_type_grandeur = 1;break;}
|
|
else
|
|
{ cout << "\n aucun choix retenue recommencer ";
|
|
choix_type_grandeur=0;
|
|
};
|
|
};
|
|
break;
|
|
}
|
|
case 10:
|
|
{ cout << "\n def de la ref associee : ";
|
|
string sortie = "\n\n " + grandeur + " #--------# ";
|
|
sortie += "\n#----------------------------------------------------\n";
|
|
if (plusieurs_maillages)
|
|
{ string nom_mail=" ";
|
|
cout << "\n nom du maillage ? ";
|
|
nom_mail= lect_chaine(); cout << " nom lu = "<< nom_mail;
|
|
sortie += " nom_mail= " + nom_mail + " ";
|
|
};
|
|
cout << "\n nom de la reference d'element ? ";
|
|
string nom_ref=" ";
|
|
nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
|
|
// on définit le type de stabilisation
|
|
string type_stabilisation="STABMEMBRANE_BIEL_NON_DEFINIE"; // init
|
|
int choix_type_stabilisation = 0;
|
|
{string type_stabilisation_lu="";
|
|
while (choix_type_stabilisation == 0)
|
|
{ cout << "\n -- choix du type de stabilisation --- "
|
|
<< "\n (1) STABMEMBRANE_BIEL_PREMIER_ITER "
|
|
<< "\n (2) STABMEMBRANE_BIEL_PREMIER_ITER_INCR "
|
|
<< "\n (3) STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER "
|
|
<< "\n (4) STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR "
|
|
<< "\n (f) fin sans sauvegarde (defaut)";
|
|
type_stabilisation_lu= lect_return_defaut(false,"f");
|
|
cout << " valeur lue ="<< type_stabilisation_lu;
|
|
if (type_stabilisation_lu == "1" )
|
|
{ type_stabilisation = " STABMEMBRANE_BIEL_PREMIER_ITER ";
|
|
choix_type_stabilisation = 1;
|
|
break;
|
|
}
|
|
else if (type_stabilisation_lu == "2" )
|
|
{ type_stabilisation = " STABMEMBRANE_BIEL_PREMIER_ITER_INCR ";
|
|
choix_type_stabilisation = 1;
|
|
break;
|
|
}
|
|
else if (type_stabilisation_lu == "3" )
|
|
{ type_stabilisation = " STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER ";
|
|
choix_type_stabilisation = 1;
|
|
break;
|
|
}
|
|
else if (type_stabilisation_lu == "4" )
|
|
{ type_stabilisation = " STABMEMBRANE_BIEL_Gerschgorin_PREMIER_ITER_INCR ";
|
|
choix_type_stabilisation = 1;
|
|
break;
|
|
}
|
|
else if (Minuscules(type_stabilisation_lu) == "f" ) {choix_type_stabilisation = -1;break;}
|
|
else
|
|
{ cout << "\n aucun choix retenue recommencer ";
|
|
choix_type_stabilisation=0;
|
|
};
|
|
};
|
|
}
|
|
// maintenant choix de la grandeur utilisée pour la stabilisation
|
|
int choix_type_grandeur = 0;
|
|
string type_grandeur_lu="";
|
|
string type_grandeur=" "; // init
|
|
while (choix_type_grandeur == 0)
|
|
{ cout << "\n -- choix du type de stabilisation --- "
|
|
<< "\n (1) une valeur numerique "
|
|
<< "\n (2) une fonction nD "
|
|
<< "\n (f) fin sans sauvegarde ";
|
|
type_grandeur_lu= lect_return_defaut(false,"f");
|
|
cout << " valeur lue ="<< type_grandeur_lu;
|
|
if (type_grandeur_lu == "1" )
|
|
{ double valeur;
|
|
cout << "\n valeur de la stabilisation "; valeur=lect_double();
|
|
cout << " valeur lue = "<< valeur;
|
|
// stockage pour la sortie de la ligne
|
|
type_grandeur = " une_valeur_numerique_ " + ChangeReelSTring(valeur);
|
|
choix_type_grandeur = 1;
|
|
break;
|
|
}
|
|
else if (type_grandeur_lu == "2" )
|
|
{ string nom_fct_nD("");
|
|
cout << "\n nom de la fonction nD "; nom_fct_nD= lect_chaine();
|
|
cout << " valeur lue ="<< nom_fct_nD;
|
|
// stockage pour la sortie de la ligne
|
|
type_grandeur = " une_fonction_nD_ " + nom_fct_nD;
|
|
choix_type_grandeur = 1;
|
|
break;
|
|
}
|
|
else if (Minuscules(type_grandeur_lu) == "f" ) {choix_type_grandeur = -1;break;}
|
|
else
|
|
{ cout << "\n aucun choix retenue recommencer ";
|
|
choix_type_grandeur=0;
|
|
};
|
|
};
|
|
// sortie de la ligne
|
|
if ((choix_type_stabilisation==1)&&(choix_type_grandeur==1))
|
|
// sortie de la ligne
|
|
sort << sortie << nom_ref << " " << type_stabilisation
|
|
<< type_grandeur ;
|
|
|
|
break;
|
|
}
|
|
case 11:
|
|
{ string type_repere = " orthonorme_ ";
|
|
cout << "\n def de la ref associee : ";
|
|
string sortie = "\n\n " + grandeur + " #--------# ";
|
|
//sort << "\n\n "<< grandeur<<" #--------# ";
|
|
//sort << "\n#----------------------------------------------------\n";
|
|
sortie += "\n#----------------------------------------------------\n";
|
|
if (plusieurs_maillages)
|
|
{ string nom_mail=" ";
|
|
cout << "\n nom du maillage ? ";
|
|
nom_mail= lect_chaine(); cout << " nom lu = "<< nom_mail;
|
|
//sort << " nom_mail= "<< nom_mail<< " ";
|
|
sortie += " nom_mail= " + nom_mail + " ";
|
|
};
|
|
cout << "\n nom de la reference d'element ? ";
|
|
string nom_ref=" ";
|
|
nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
|
|
sortie += " " + nom_ref + " "+type_repere;
|
|
// maintenant choix de la méthode de def du repère
|
|
int choix_def_repere = 0;
|
|
string type_def_repere="";
|
|
while (choix_def_repere == 0)
|
|
{ cout << "\n -- choix de la methode de def du repere --- "
|
|
<< "\n (1) Par_projection_et_normale_au_plan_ "
|
|
<< "\n (2) par_fonction_nD_ "
|
|
<< "\n (f) fin sans sauvegarde (defaut)";
|
|
type_def_repere= lect_return_defaut(false,"f");
|
|
cout << " valeur lue ="<< type_def_repere;
|
|
if (type_def_repere == "1" )
|
|
{ sortie += " Par_projection_et_normale_au_plan_ ";
|
|
choix_def_repere=1;
|
|
}
|
|
else if (type_def_repere == "2" )
|
|
{sortie += " par_fonction_nD_ ";
|
|
choix_def_repere=1;
|
|
}
|
|
else if (Minuscules(type_def_repere) == "f" )
|
|
{choix_def_repere = -1;}
|
|
else
|
|
{ cout << "\n aucun choix retenue recommencer ";
|
|
choix_def_repere=0;
|
|
};
|
|
};
|
|
// maintenant choix de la fonction nD
|
|
if (choix_def_repere != -1)
|
|
{string nom_fct_nD("");
|
|
cout << "\n nom de la fonction nD "; nom_fct_nD= lect_chaine();
|
|
cout << " valeur lue ="<< nom_fct_nD;
|
|
sortie += " une_fonction_nD_ "+nom_fct_nD+" ";
|
|
// sortie de la ligne
|
|
sort << sortie;
|
|
};
|
|
break;
|
|
}
|
|
case 12: case 13: // cas des statistiques
|
|
{
|
|
cout << "\n def de la ref associee : ";
|
|
string sortie = "\n\n " + grandeur + " #--------# ";
|
|
sortie += "\n#----------------------------------------------------\n";
|
|
if (plusieurs_maillages)
|
|
{ string nom_mail=" ";
|
|
cout << "\n nom du maillage ? ";
|
|
nom_mail= lect_chaine(); cout << " nom lu = "<< nom_mail;
|
|
sortie += " nom_mail= " + nom_mail + " ";
|
|
};
|
|
cout << "\n nom de la reference de noeuds ? ";
|
|
string nom_ref=" ";
|
|
nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
|
|
// maintenant choix de la grandeur
|
|
int choix_type_grandeur = 0;
|
|
string type_grandeur_lu="";
|
|
while (choix_type_grandeur == 0)
|
|
{ cout << "\n -- choix du type de grandeur pour statistique --- "
|
|
<< "\n (1) un ddl etendu "
|
|
<< "\n (2) une fonction nD "
|
|
<< "\n (f) fin sans sauvegarde (defaut)";
|
|
type_grandeur_lu=lect_return_defaut(false,"f");
|
|
cout << " valeur lue ="<< type_grandeur_lu;
|
|
if (type_grandeur_lu == "1" )
|
|
{ string nom_ddl("");
|
|
Ddl_enum_etendu ddl;
|
|
cout << "\n nom du ddl "; nom_ddl= lect_chaine();
|
|
cout << " valeur lue = "<< nom_ddl;
|
|
if (!(ddl.VerifExistence(nom_ddl)))
|
|
{ cout << "\n *** "<<nom_ddl<< " n'est pas un nom de ddl, recommencer ou f pour fin ";
|
|
}
|
|
else
|
|
{ // sortie de la ligne
|
|
Ddl_enum_etendu ddl_sor(nom_ddl); // on crée le ddl de sortie
|
|
sort << sortie << nom_ref << " un_ddl_etendu_ " << ddl_sor.Nom_plein() << " ";
|
|
choix_type_grandeur = 1;
|
|
break;
|
|
};
|
|
}
|
|
else if (type_grandeur_lu == "2" )
|
|
{ string nom_fct_nD("");
|
|
cout << "\n nom de la fonction nD "; nom_fct_nD= lect_chaine();
|
|
cout << " valeur lue ="<< nom_fct_nD;
|
|
// sortie de la ligne
|
|
sort << sortie << grandeur << " une_fonction_nD_ " << nom_fct_nD << " ";
|
|
choix_type_grandeur = 1;
|
|
break;
|
|
}
|
|
else if (Minuscules(type_grandeur_lu) == "f" ) {choix_type_grandeur = 1;break;}
|
|
else
|
|
{ cout << "\n aucun choix retenue recommencer ";
|
|
choix_type_grandeur=0;
|
|
};
|
|
};
|
|
break;
|
|
}
|
|
case 14: // information
|
|
{ cout << "\n pour les elements geometriques, la masse volumique et la dilatation thermique,"
|
|
<< "\n il s'agit de completer si necessaire (donc en fonction du type d'elements)"
|
|
<< "\n les donnees lues concernant les elements "
|
|
<< "\n pour cela on indique une reference puis une valeur"
|
|
<< "\n concernant la gestion des modes d'hourglass (optionnelle) "
|
|
<< "\n on se reportera a la documentation pour plus d'info"
|
|
<< "\n sinon il suffit de repondre aux questions"
|
|
<< "\n pour les integrales : il s'agit de definir une grandeur a integrer sur les elements"
|
|
<< "\n de la ref -> un resultat pour chaque element et un resultat global "
|
|
<< "\n pour les statistiques: il s'agit de definir une grandeur dont on va calculer "
|
|
<< "\n sur les noeuds d'une ref: la somme, le mini, le maxi etc. "
|
|
<< "\n ";
|
|
}
|
|
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
|
|
sort << flush;
|
|
|
|
};
|
|
// affichage et definition interactive des commandes
|
|
// cas du deuxième passage
|
|
void DiversStockage::Info_commande_DiversStockage2(UtilLecture & entreePrinc)
|
|
{ ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
|
|
//On va proposer un menu
|
|
string rep=" ";
|
|
bool plusieurs_maillages = false;
|
|
sort << "\n# --- divers stockages (2) ------- ";
|
|
cout << "\n cas d'un seul maillage (par defaut) : rep o "
|
|
<< "\n cas de plusieurs maillages : rep n ";
|
|
rep = lect_return_defaut(true,"o");
|
|
if (rep == "n")
|
|
{ plusieurs_maillages = true;};
|
|
rep="_"; // init
|
|
while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
|
|
{
|
|
try
|
|
{
|
|
cout << "\n -- definition de : --- "
|
|
<< "\n (0 ou f) (fin) "
|
|
<< "\n (1) masse additionnelles "
|
|
<< "\n (2 ou ? ) informations "
|
|
<< "\n ";
|
|
rep = lect_return_defaut(false,"f");
|
|
if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie directe
|
|
break;
|
|
int num = ChangeEntier(rep);
|
|
if (Minuscules(rep) == "?")
|
|
num = 7;
|
|
bool choix_valide=false;
|
|
if ((num >= 0)&&(num<=7))
|
|
{ choix_valide=true; }
|
|
else { cout << "\n Erreur on attendait un entier entre 0 et 2 !!, "
|
|
<< "\n redonnez une bonne valeur"
|
|
<< "\n ou taper f ou 0 pour arreter le programme";
|
|
choix_valide=false;
|
|
}
|
|
string grandeur=" "; // init
|
|
// cas d'une grandeur simple
|
|
switch (num)
|
|
{ case 1: grandeur = "masse_addi";break;
|
|
};
|
|
|
|
switch (num)
|
|
{ case 0: // sortie
|
|
{ break;} // normalement cela a déjà été filtré avant
|
|
case 1:
|
|
{ string sortie = "\n def de la ref associee : ";
|
|
bool lecture_ok=true; // init a priori
|
|
//cout << "\n def de la ref associee : ";
|
|
sortie += "\n "+ grandeur +" #--------# \n";
|
|
//sort << "\n "<< grandeur <<" #--------# \n";
|
|
if (plusieurs_maillages)
|
|
{ string nom_mail=" ";
|
|
cout << "\n nom du maillage ? ";
|
|
nom_mail= lect_chaine(); cout << " nom lu = "<< nom_mail;
|
|
sortie += " nom_mail= "+ nom_mail+ " ";
|
|
//sort << " nom_mail= "<< nom_mail<< " ";
|
|
};
|
|
cout << "\n nom de la reference ? ";
|
|
string nom_ref=" ";
|
|
nom_ref= lect_chaine();cout << " nom lu = "<< nom_ref;
|
|
if (nom_ref.at(0) != 'N')
|
|
{cout << "\n *** erreur, la premiere lettre de la ref de noeud "
|
|
<< " doit etre N et non "<< nom_ref.at(0)<< " !!";
|
|
lecture_ok = false;
|
|
break;
|
|
}
|
|
else {sortie += " " + nom_ref+" ";} ;
|
|
|
|
int int_choix_loc=0;string rep_loc("");
|
|
while ((int_choix_loc > 3) || (int_choix_loc < 1))
|
|
{cout << "\n --- definition de la valeur --- "
|
|
<< "\n (1) valeur fixe -> un reel "
|
|
<< "\n (2) valeur via une fonction nD "
|
|
<< "\n (3 ou f ) arret "
|
|
<< "\n ";
|
|
rep_loc = lect_return_defaut(false,"f"); Minuscules(rep_loc);
|
|
int_choix_loc = ChangeEntier(rep_loc);
|
|
if ((rep_loc == "f")||(int_choix_loc == 3))
|
|
{lecture_ok = false; break;
|
|
};
|
|
switch (int_choix_loc)
|
|
{case 1:
|
|
{double d=0.;// init
|
|
d=lect_double();cout << " valeur lue = "<< d;
|
|
sortie += ChangeReelSTring(d)+" ";
|
|
}
|
|
break;
|
|
case 2:
|
|
{ cout << "\n nom de la fonction nD ? ";
|
|
string nom_fnD("");
|
|
nom_fnD= lect_chaine();cout << " nom lu = "<< nom_fnD;
|
|
sortie += " Fonction_nD_: " + nom_fnD;
|
|
};
|
|
break;
|
|
default:
|
|
{cout << "\n *** mauvais choix, vous devez donner une valeur entre 1 et 3 !"
|
|
<< "\n recommencer ";
|
|
};
|
|
};
|
|
};
|
|
if(lecture_ok)
|
|
sort << sortie << flush;
|
|
break;
|
|
}
|
|
case 2: // information
|
|
{ cout << "\n Au niveau des noeuds il est possible d'imposer une masse supplementaire ponctuelle "
|
|
<< "\n pour cela on indique une reference de noeud puis une valeur correspondant a la masse ponctuelle "
|
|
<< "\n on se reportera a la documentation pour plus d'info"
|
|
<< "\n sinon il suffit de repondre aux questions"
|
|
<< "\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
|
|
sort << flush;
|
|
|
|
};
|
|
|
|
|
|
//----- lecture écriture de base info -----
|
|
// lecture base info
|
|
// = 1 : on récupère tout
|
|
// = 2 : on récupère uniquement les données variables (supposées comme telles)
|
|
void DiversStockage::Lecture_base_info(ifstream& entr,const int cas)
|
|
{ // a priori les données stockées ne sont pas variables d'où seule le cas = 1
|
|
// est utilisé
|
|
if (cas == 1 )
|
|
{ cout << "== lecture de divers stockages \n";
|
|
string toto;
|
|
entr >> toto ;
|
|
|
|
// cas du tableau des épaisseurs
|
|
int tabEpaissTaille ;
|
|
entr >> toto >> tabEpaissTaille ;
|
|
tabEpaiss.Change_taille(tabEpaissTaille);
|
|
for (int i=1; i<= tabEpaissTaille; i++)
|
|
entr >> tabEpaiss(i) ;
|
|
|
|
// cas du tableau des largeurs
|
|
int tabLargeursTaille = tabLargeurs.Taille();
|
|
entr >> toto >> tabLargeursTaille ;
|
|
tabLargeurs.Change_taille(tabLargeursTaille);
|
|
for (int i=1; i<= tabLargeursTaille; i++)
|
|
entr >> tabLargeurs(i) ;
|
|
|
|
// cas du tableau des sections
|
|
int tabSectionTaille = tabSection.Taille();
|
|
entr >> toto >> tabSectionTaille ;
|
|
tabSection.Change_taille(tabSectionTaille);
|
|
for (int i=1; i<= tabSectionTaille; i++)
|
|
entr >> tabSection(i) ;
|
|
|
|
// cas du tableau des variation de section
|
|
int tabVarSectionTaille = tabVarSection.Taille();
|
|
entr >> toto >> tabVarSectionTaille ;
|
|
tabVarSection.Change_taille(tabVarSectionTaille);
|
|
for (int i=1; i<= tabVarSectionTaille; i++)
|
|
entr >> tabVarSection(i) ;
|
|
|
|
// cas du tableau des masses volumique
|
|
int tabMasseVoluTaille = tabMasseVolu.Taille();
|
|
entr >> toto >> tabMasseVoluTaille ;
|
|
tabMasseVolu.Change_taille(tabMasseVoluTaille);
|
|
for (int i=1; i<= tabMasseVoluTaille; i++)
|
|
entr >> tabMasseVolu(i) ;
|
|
|
|
// cas du tableau des coefficients de dilatation thermique
|
|
int tabCoefDilaTaille = tabCoefDila.Taille();
|
|
entr >> toto >> tabCoefDilaTaille ;
|
|
tabCoefDila.Change_taille(tabCoefDilaTaille);
|
|
for (int i=1; i<= tabCoefDilaTaille; i++)
|
|
entr >> tabCoefDila(i) ;
|
|
|
|
// cas du tableau des gestions d'hourglass
|
|
int tabGesHourglassTaille = tabGesHourglass.Taille();
|
|
entr >> toto >> tabGesHourglassTaille ;
|
|
tabGesHourglass.Change_taille(tabGesHourglassTaille);
|
|
for (int i=1; i<= tabGesHourglassTaille; i++)
|
|
entr >> tabGesHourglass(i) ;
|
|
|
|
// cas du tableau des intégrales sur volume
|
|
int tabIntegVolTaille = tabIntegVol.Taille();
|
|
entr >> toto >> tabIntegVolTaille ;
|
|
tabIntegVol.Change_taille(tabIntegVolTaille);
|
|
for (int i=1; i<= tabIntegVolTaille; i++)
|
|
entr >> tabIntegVol(i) ;
|
|
|
|
// cas du tableau des intégrales sur volume et temps
|
|
int tabIntegVol_et_tempsTaille = tabIntegVol_et_temps.Taille();
|
|
entr >> toto >> tabIntegVol_et_tempsTaille ;
|
|
tabIntegVol_et_temps.Change_taille(tabIntegVol_et_tempsTaille);
|
|
for (int i=1; i<= tabIntegVol_et_tempsTaille; i++)
|
|
entr >> tabIntegVol_et_temps(i) ;
|
|
|
|
// cas du tableau des stabilisations transversales de membrane ou biel
|
|
int tabStabMembraneBielTaille = tabStabMembraneBiel.Taille();
|
|
entr >> toto >> tabStabMembraneBielTaille ;
|
|
tabStabMembraneBiel.Change_taille(tabStabMembraneBielTaille);
|
|
for (int i=1; i<= tabStabMembraneBielTaille; i++)
|
|
entr >> tabStabMembraneBiel(i) ;
|
|
|
|
// cas du tableau des masses additionnelles
|
|
int tabMasseAddiTaille = tabMasseAddi.Taille();
|
|
entr >> toto >> tabMasseAddiTaille ;
|
|
tabMasseAddi.Change_taille(tabMasseAddiTaille);
|
|
for (int i=1; i<= tabMasseAddiTaille; i++)
|
|
entr >> tabMasseAddi(i) ;
|
|
|
|
// cas du tableau des repères d'anisotropie
|
|
int tabRepAnisotropeTaille = tabRepAnisotrope.Taille();
|
|
entr >> toto >> tabRepAnisotropeTaille ;
|
|
tabRepAnisotrope.Change_taille(tabRepAnisotropeTaille);
|
|
for (int i=1; i<= tabRepAnisotropeTaille; i++)
|
|
entr >> tabRepAnisotrope(i) ;
|
|
|
|
|
|
// cas du tableau des statistiques
|
|
int tabStatistiqueTaille = tabStatistique.Taille();
|
|
entr >> toto >> tabStatistiqueTaille ;
|
|
tabStatistique.Change_taille(tabStatistiqueTaille);
|
|
for (int i=1; i<= tabStatistiqueTaille; i++)
|
|
entr >> tabStatistique(i) ;
|
|
|
|
// cas du tableau des statistiques avec cumul en temps
|
|
int tabStatistique_et_tempsTaille = tabStatistique_et_temps.Taille();
|
|
entr >> toto >> tabStatistique_et_tempsTaille ;
|
|
tabStatistique_et_temps.Change_taille(tabStatistique_et_tempsTaille);
|
|
for (int i=1; i<= tabStatistique_et_tempsTaille; i++)
|
|
entr >> tabStatistique_et_temps(i) ;
|
|
|
|
}
|
|
};
|
|
|
|
|
|
// écriture base info
|
|
// = 1 : on sauvegarde tout
|
|
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
|
|
void DiversStockage::Ecriture_base_info(ofstream& sort,const int cas)
|
|
{ // a priori les données stockées ne sont pas variables d'où seule le cas = 1
|
|
// est utilisé
|
|
if (cas == 1 )
|
|
{ sort << "\n ****divers_stockages \n" ;
|
|
|
|
// cas du tableau des épaisseurs
|
|
int tabEpaissTaille = tabEpaiss.Taille();
|
|
sort << "epaisseurs " << tabEpaissTaille << " " ;
|
|
for (int i=1; i<= tabEpaissTaille; i++)
|
|
sort << tabEpaiss(i) << " ";
|
|
|
|
// cas du tableau des largeurs
|
|
int tabLargeursTaille = tabLargeurs.Taille();
|
|
sort << "\n largeurs " << tabLargeursTaille << " " ;
|
|
for (int i=1; i<= tabLargeursTaille; i++)
|
|
sort << tabLargeurs(i) << " ";
|
|
|
|
// cas du tableau des sections
|
|
int tabSectionTaille = tabSection.Taille();
|
|
sort << "\n sections " << tabSectionTaille << " " ;
|
|
for (int i=1; i<= tabSectionTaille; i++)
|
|
sort << tabSection(i) << " ";
|
|
|
|
// cas du tableau des variations d sections
|
|
int tabVarSectionTaille = tabVarSection.Taille();
|
|
sort << "\n variation de section " << tabVarSectionTaille << " " ;
|
|
for (int i=1; i<= tabVarSectionTaille; i++)
|
|
sort << tabVarSection(i) << " ";
|
|
|
|
// cas du tableau des masses volumiques
|
|
int tabMasseVoluTaille = tabMasseVolu.Taille();
|
|
sort << "\n masse_volumique " << tabMasseVoluTaille << " " ;
|
|
for (int i=1; i<= tabMasseVoluTaille; i++)
|
|
sort << tabMasseVolu(i) << " ";
|
|
|
|
// cas du tableau des coefficients de dilatation thermique
|
|
int tabCoefDilaTaille = tabCoefDila.Taille();
|
|
sort << "\n dilatation_thermique " << tabCoefDilaTaille << " " ;
|
|
for (int i=1; i<= tabCoefDilaTaille; i++)
|
|
sort << tabCoefDila(i) << " ";
|
|
|
|
// cas du tableau des gestions d'hourglass
|
|
int tabGesHourglassTaille = tabGesHourglass.Taille();
|
|
sort << "\n hourglass_gestion_ " << tabGesHourglassTaille << " " ;
|
|
for (int i=1; i<= tabGesHourglassTaille; i++)
|
|
sort << tabGesHourglass(i) << " ";
|
|
|
|
// cas du tableau des intégrales de volume
|
|
int tabIntegVolTaille = tabIntegVol.Taille();
|
|
sort << "\n integrale_sur_volume_ " << tabIntegVolTaille << " " ;
|
|
for (int i=1; i<= tabIntegVolTaille; i++)
|
|
sort << tabIntegVol(i) << " ";
|
|
|
|
// cas du tableau des intégrales de volume et sur le temps
|
|
int tabIntegVol_et_tempsTaille = tabIntegVol_et_temps.Taille();
|
|
sort << "\n integrale_sur_vol_et_temps_ " << tabIntegVol_et_tempsTaille << " " ;
|
|
for (int i=1; i<= tabIntegVol_et_tempsTaille; i++)
|
|
sort << tabIntegVol_et_temps(i) << " ";
|
|
|
|
// cas du tableau des stabilisations transversales de membrane ou biel
|
|
int tabStabMembraneBielTaille = tabStabMembraneBiel.Taille();
|
|
sort << "\n stabilisation_transvers_membrane_biel_ " << tabStabMembraneBielTaille << " " ;
|
|
for (int i=1; i<= tabStabMembraneBielTaille; i++)
|
|
sort << tabStabMembraneBiel(i) << " ";
|
|
|
|
// cas du tableau des masses additionnelles
|
|
int tabMasseAddiTaille = tabMasseAddi.Taille();
|
|
sort << "\n masses_additionnelles " << tabMasseAddiTaille << " " ;
|
|
for (int i=1; i<= tabMasseAddiTaille; i++)
|
|
sort << tabMasseAddi(i) << " ";
|
|
|
|
// cas du tableau des repères d'anisotropie
|
|
int tabRepAnisotropeTaille = tabRepAnisotrope.Taille();
|
|
sort << "\n repere_anisotropie_ " << tabRepAnisotropeTaille << " " ;
|
|
for (int i=1; i<= tabRepAnisotropeTaille; i++)
|
|
sort << tabRepAnisotrope(i) << " ";
|
|
|
|
// cas du tableau des statistiques
|
|
int tabStatistiqueTaille = tabStatistique.Taille();
|
|
sort << "\n statistique_sur_RefNoeuds_ " << tabStatistiqueTaille << " " ;
|
|
for (int i=1; i<= tabStatistiqueTaille; i++)
|
|
sort << tabStatistique(i) << " ";
|
|
|
|
// cas du tableau des statistiques avec cumul en temps
|
|
int tabStatistique_et_tempsTaille = tabStatistique_et_temps.Taille();
|
|
sort << "\n statistique_sur_RefNoeuds_et_temps_ " << tabStatistique_et_tempsTaille << " " ;
|
|
for (int i=1; i<= tabStatistique_et_tempsTaille; i++)
|
|
sort << tabStatistique_et_temps(i) << " ";
|
|
|
|
|
|
|
|
}
|
|
};
|
|
|