rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Parametres/ParaAlgoControle.cc

3110 lines
188 KiB
C++
Raw Normal View History

introduction des répertoires flambages, Lecture et Parametres
2021-09-28 11:58:49 +02:00
// 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/>.
// implantation de la classe ParaAlgoControle
#include <stdlib.h>
using namespace std; //introduces namespace std
#include <math.h>
#include "ParaAlgoControle.h"
#include "MotCle.h"
#include "ParaGlob.h"
#include "ConstMath.h"
#include "MathUtil.h"
#include "CharUtil.h"
// ================ paramètres static ======================
// valeur par défaut de coef_pas_critique_deltat, compliqué pour qu'il n'y est pas de doute d'égalité
double ParaAlgoControle::coef_defaut_pa_critique = 0.853247689523;
// pour le temps
VariablesTemps ParaAlgoControle::tempo; // init aux valeurs par défaut
//================= fin paramètres static ====================
// CONSTRUCTEUR
// par défaut
ParaAlgoControle::ParaAlgoControle() :
tempo_specifique_algo(),
// on initialise les listes par défaut
type_matrice_secondaire(),type_resolution_secondaire(),type_preconditionnement_secondaire()
,nb_iter_nondirecte_secondaire(),tolerance_secondaire(),nb_vect_restart_secondaire()
,opti_pointeur_assemblage(0)
{// on met les parametres a leurs valeurs par defaut
// 1) parametres de controle généraux pour la résolution de l'équilibre
// générale
sauvegarde = 1; // frequence de sauvegarde
cas_de_sauvegarde = 1; // cas de gestion de la fréquence de sauvegarde, par défaut sauvegarde
// indique le nombre d'incréments entre deux sauvegardes
tempo_specifique_algo.deltatmaxi = tempo.deltatmaxi = 1.; // increment de temps maxi
tempo_specifique_algo.deltatmini = tempo.deltatmini = 0.; // increment de temps mini
coef_pas_critique_deltatmaxi = 0.; // // coeff du pas critique pour deltatmaxi s'il existe
coef_pas_critique_deltatmini = -3333256794.; // // coeff du pas critique pour deltatmini s'il existe
typeDFC_pas_critique_deltatmaxi = true; // par défaut pas critique DFC
typeDFC_pas_critique_deltatmini = true; // par défaut pas critique DFC
iterations = 100; // maxi d'iteration pour converger
precision = 1.e-3; // precision de la convergence
tempo_specifique_algo.prectemps = tempo.prectemps = 1.E-12; // precision sur le temps final
norme.nom1 = "Residu/Reaction"; // type de norme de convergence
norme.nom2 = " "; // ne sert que si norme.nom1 = fonction_nD:
cinematique = false; // cinematique sur l'increment ?
conv_forcee = false; // convergence forcee ?
multiplicateur = 1.; // multiplicateur de la charge
tempo_specifique_algo.deltat = tempo.deltat = 1.; // increment de temps
force_deltat = false; // a priori on reprend le deltat sauvegardé au pas précédent
coef_pas_critique_deltat=coef_defaut_pa_critique; // coeff du pas critique pour deltat s'il existe
typeDFC_pas_critique_deltat = true; // par défaut pas critique DFC
tempo_specifique_algo.tempsfin = tempo.tempsfin = 1.; // temps de fin de calcul
maxincre = 400 ; // maximum d'increment de temps
max_essai_incre = maxincre; // maximum de tentative d'increment de temps permis
restart = 0; // increment de redemarage de calcul
max_puissance = 1.e10; // maximum de la puissance tolérée dans le calcul
line_search = false; // line_seach désactivée par défaut
var_charge_externe = true; // charge externe participe à la raideur
var_jacobien = false; // variation du jacobien dans le calcul de la raideur
var_D = false; // variation de la vitesse de déformation dans le calcul de la raideur
// on renseigne la class ParaGlob sur les variables temps
ParaGlob::Init_temps(tempo);
// 2) paramètres liés au systèmes d'équations linéaire
type_matrice = BANDE_SYMETRIQUE; // type de stockage matriciel
symetrie_matrice = true; // assemblage symétrique par défaut
type_resolution = CHOLESKY; // type de résolution
type_preconditionnement = DIAGONAL; // type de préconditionnement
nb_iter_nondirecte = 30; // nombre d'itération dans le cas d'une méthode itérative
tolerance = 1.e-7; // tolerance de convergence dans le cas d'une méthode itérative
nb_vect_restart = 32; // nombre de vecteur sauvegardé dans le cas d'une méthode
// itérative avec redépart
// pour les matrices secondaires éventuelles, aucune déclaration, car
// par défaut il n'y en a pas
// 3) paramètres liés au pilotage de l'équilibre global
type_de_pilotage = PILOTAGE_BASIQUE; // type de pilotage basique par défaut
facteur_diminution = sqrt(3.); // facteurs d'augmentation, ou de diminution
facteur_augmentation = sqrt(2.); // du paramètre de chargement
fact_dim_en_mauvaiseConv = 1.23; // facteurs de diminution après une mauvaise convergence
nb_bonne_convergence = 3; // nb de bonne convergence -> augmentation du deltatt
nb_iter_pour_bonne_convergence = 0.25 * iterations; // nb d'iter pour statuer sur la bonne convergence
nb_iter_pour_mauvaise_convergence = 0.5 * iterations; // nb d'iter pour statuer sur la bonne convergence
init_comp_tangent_simple = -1; // nb d'itération avec un comportement tangent simple
sur_sous_relaxation = 1.; // facteur de sur ou sous relaxation
norme_incre_max = ConstMath::tresgrand; // limitation de l'incrément maxi des ddl
// pour les deux lignes qui suivent, ne pas bouger le maxi (==ConstMath::tresgrand) car
// il sert à savoir si les limitations sont actives c-a-d modifié par l'utilisateur
norme_incre_X_max = ConstMath::tresgrand; // limitation de l'incrément maxi des ddl de déplacement
norme_incre_V_max = ConstMath::tresgrand; // limitation de l'incrément maxi des ddl de vitesse
//
varMiniDdl = 0.; // limite mini en dessous de laquelle on considère qu'il n'y a pas convergence
varMaxiDdl = ConstMath::tresgrand; // idem en maxi
nbCycleControleResidu = 3; // entre combien d'iter on compare le max résidu
plageControleResidu = 3; // combien de fois il faut que le test soit négatif pour la non convergence
initIncreAvecDeltaDdlPrec = 1.; // initialisation de l'incrément avec l'incrément du pas précédent
jabobien_negatif = 1; // traitement du cas des jacobiens négatifs
var_maxi_jacobien = 0; // variation maxi autorisée du jacobien, si <= 1 pas pris en compte
cas_fctnD_charge = 0; // traitement d'un retour de fct nD problématique: dans le chargement
// 4) paramètres liès à la dynamique
type_calcul_masse = MASSE_DIAG_COEF_EGAUX; // type de calcul de la masse
// le type de stockage de la masse utilisée est celui de type_matrice
// qui est utilisé uniquement lorque la matrice masse n'est pas diagonale`
limitation_temps_maxi_stable = true; // booléen qui indique si la limitation supérieur
// du temps pour satisfaire la stabilité, est active ou pas
amort_visco_arti = 0; // indique si l'on inclut automatiquement un amortissement visqueux artificiel
visco_arti = 0.01; // valeur de la viscosité dynamique
maxi_C_en_fonction_M = 10000; // coef tel que: maxi C = maxi_C_en_fonction_M * M (cas de C critique)
coef_rayleigh_masse = 1.; // coeffs de rayleigh sur la masse pour la construction de [C]
coef_rayleigh_raideur = 0.; // coeffs de rayleigh sur la raideur pour la construction de [C]
// cas du bulk viscosity
bulk_viscosity = 0; // indique si oui ou non on utilise le bulk viscosity
c_Tracebulk = 1.5; // coefficient de la trace de D
c_Trace2bulk = 0.06; // coefficient du carré de la trace de D
// 5) paramètres liès à l'affichage des résultats
frequence_affichage_increment = 1; // fréquence sur les increments de l'affichage des résultats
frequence_affichage_iteration = 1; // fréquence sur les itération de l'affichage des résultats
sortie_fil_calcul = -1000000; // fréquence sur les incréments, pour la sortie au fil du calcul
cas_de_sortie_fil_calcul = 1; // par défaut le paramètre sortie_fil_calcul = un delta incrément
// nombre de chiffre significatifs utilisé pour l'affichage des double précision: le premier pour
// l'archivage du calcul le secon pour la visualisation graphique
nb_diggit_double_calcul = 17;
nb_diggit_double_graphique = 12;
nb_diggit_double_ecran= 8;
// 6) paramètres liès au contact
prec_pt_int_deb = 1.e-6; // précision du test: point intérieur ?, avant le début des calculs
factPourRayonAccostage = 1.; // facteur multiplicatif du déplacement maxi entre t et tdt, donnant
// distance maxi admissible entre le point et le point projeté
distanceMaxiAuPtProjete = ConstMath::grand; // a priori grand, est ensuite éventuellement géré par l'entrée des données
extra_boite_prelocalisation = 1.05; // donne la proportion de plus que l'on prend pour les boites
mini_extra_boite_prelocalisation = 0.001; // permet le calcul de la bande mini autour de la boite
ajout_extra_boite_prelocalisation = 0.; // ajout dans toutes les directions à la boite
contact_type = 0; // a priori il n'y a pas de contact de prélocalisation d'élément
fct_nD_bascul_contact_type_4="_"; // a priori pas de fonction nD
penalisationPenetration = 0.1; // facteur pour le calcul du facteur de pénalisation pour la pénétration
fct_nD_penalisationPenetration="_"; // pas de fonction par défaut
typePenalisationPenetration = 2; // par défaut le calcul est celui de ls-dyna avec la compressibilité du maître
penetration_contact_maxi = 0.1; // par défaut on met 1/10 de penetration,
fct_nD_penetration_contact_maxi="_"; // pas de fonction par défaut
penetration_borne_regularisation = ConstMath::tresgrand; // par défaut n'intervient pas
fct_nD_penetration_borne_regularisation="_"; // pas de fonction par défaut
force_contact_noeud_maxi = ConstMath::tresgrand; // borne maxi pour la force de réaction du noeud ,
fct_nD_force_contact_noeud_maxi="_"; // pas de fonction par défaut
penalisationTangentielle = 1.e6; // facteur de pénalisation pour le déplacement tangentiel
fct_nD_penalisationTangentielle="_"; // pas de fonction par défaut
typePenalisationTangentielle = 2; // indique le type de calcul pour la pénalisation pour le dep tangentiel
tangentielle_contact_maxi = 0.1; // indique une borne maxi de dep tangentiel (dont l'utilisation dépend de l'algo)
fct_nD_tangentielle_contact_maxi="_"; // pas de fonction par défaut
tangentielle_borne_regularisation = ConstMath::tresgrand;// par défaut n'intervient pas
fct_nD_tangentielle_borne_regularisation="_"; // pas de fonction par défaut
force_tangentielle_noeud_maxi = ConstMath::tresgrand;; // indique une borne maxi pour la force tangentielle
fct_nD_force_tangentielle_noeud_maxi="_"; // pas de fonction par défaut
prec_pt_sur_frontiere = 1.e-4; // précision de positionnement sur les X^ar d'un pt en contact sur une frontière
nb_boucle_newton_position_frontiere = 10; // nb de boucle maxi pour la recherche du positionnement du pt en contact
nbDecolAutorise = 1; // nb de fois un noeud décolle pour n'être plus considéré en contact
typeDeDecolement = 0; // type par défaut sur la réaction
nb_glissant = 1; // par défaut il n'y a pas de moyenne glissante
niveau_commentaire_contact = 0; // par défaut c'est le général qui commande
optimisation_numerotation = 0; // par défaut pas d'optimisation
// 7) paramètres liés aux calculs des énergies
nb_incr_cal_ener=1; // donne l'incrément mini, à partir duquel on calcul les énergie cumulée
affiche_incr_energie=false; // affichage oui ou non de l'énergie et du bilan sur l'incrément
// 8) paramètres liés aux calculs géométriques sur les éléments
point_interne_delta_thetai_maxi = 1.e-4; // coordonnée thetai ok si delta thetai < à la prec
point_interne_prec_thetai_interne = 1.e-6; // precision sur thetai sur le test du point interne
point_interne_nb_boucle_sur_delta_thetai = 10; // maxi boucle de Newton sur la recherche des thetai
point_interne_nb_externe = 3; //nb max de test positif "externe" pour statuer un point externe
cal_vol_total_entre_surface_et_plans_ref = false; // par défaut il n'y a pas de calcul de ces volumes
ratio_maxi_jacoMembrane_jacoPti = 200.; //rapport maxi autorisé entre le jacobien de la facette centrale
// et le jacobien au pti pour les éléments coques
type_calnum_inversion_metrique = CRAMER; // méthode historique
//------------ gestion de certaines interruptions systèmes ---------
// ces variables ne sont pas sauvegardées, elles sont accessibles de partout pour un projet donné
// on se sert de ParaAlgoControle pour le stockage, l'accès et la modification
sortieEquilibreGlobal=false; // par défaut
sortieEtatActuelDansBI=false; // par défaut
sortieEtatActuelDansCVisu = false; // par défaut
};
// de copie
ParaAlgoControle::ParaAlgoControle(const ParaAlgoControle& p) :
sauvegarde(p.sauvegarde),cas_de_sauvegarde(p.cas_de_sauvegarde),
tempo_specifique_algo(p.tempo_specifique_algo),
force_deltat(p.force_deltat),
coef_pas_critique_deltatmaxi(p.coef_pas_critique_deltatmaxi),
coef_pas_critique_deltatmini(p.coef_pas_critique_deltatmini),
typeDFC_pas_critique_deltatmaxi(p.typeDFC_pas_critique_deltatmaxi),
typeDFC_pas_critique_deltatmini(p.typeDFC_pas_critique_deltatmini),
iterations(p.iterations), precision(p.precision),
norme(p.norme),//prectemps(p.prectemps),
cinematique(p.cinematique),conv_forcee(p.conv_forcee),
multiplicateur(p.multiplicateur),//deltat(p.deltat),
coef_pas_critique_deltat(p.coef_pas_critique_deltat),
typeDFC_pas_critique_deltat(p.typeDFC_pas_critique_deltat),
maxincre(p.maxincre),//tempsfin(p.tempsfin),
max_essai_incre(p.max_essai_incre),
restart(p.restart),max_puissance(p.max_puissance),
line_search(p.line_search),var_charge_externe(p.var_charge_externe),
var_jacobien(p.var_jacobien),var_D(p.var_D),
type_matrice(p.type_matrice),symetrie_matrice(p.symetrie_matrice),
type_resolution(p.type_resolution),
type_preconditionnement(p.type_preconditionnement),
nb_iter_nondirecte(p.nb_iter_nondirecte),
tolerance(p.tolerance),nb_vect_restart(p.nb_vect_restart),
type_matrice_secondaire(p.type_matrice_secondaire),
type_resolution_secondaire(p.type_resolution_secondaire),
type_preconditionnement_secondaire(p.type_preconditionnement_secondaire),
nb_iter_nondirecte_secondaire(p.nb_iter_nondirecte_secondaire),
tolerance_secondaire(p.tolerance_secondaire),nb_vect_restart_secondaire(p.nb_vect_restart_secondaire),
opti_pointeur_assemblage(p.opti_pointeur_assemblage),
type_de_pilotage(p.type_de_pilotage),facteur_diminution(p.facteur_diminution),
facteur_augmentation(p.facteur_augmentation),fact_dim_en_mauvaiseConv(p.fact_dim_en_mauvaiseConv),
nb_bonne_convergence(p.nb_bonne_convergence),
nb_iter_pour_bonne_convergence(p.nb_iter_pour_bonne_convergence),
nb_iter_pour_mauvaise_convergence(p.nb_iter_pour_mauvaise_convergence),
init_comp_tangent_simple(p.init_comp_tangent_simple),
norme_incre_max(p.norme_incre_max),norme_incre_X_max(p.norme_incre_X_max),
norme_incre_V_max(p.norme_incre_V_max),
varMiniDdl(p.varMiniDdl),varMaxiDdl(p.varMaxiDdl),
nbCycleControleResidu(p.nbCycleControleResidu),plageControleResidu(p.plageControleResidu),
sur_sous_relaxation(p.sur_sous_relaxation),initIncreAvecDeltaDdlPrec(p.initIncreAvecDeltaDdlPrec),
jabobien_negatif(p.jabobien_negatif),var_maxi_jacobien(p.var_maxi_jacobien),
cas_fctnD_charge(p.cas_fctnD_charge),
type_calcul_masse(p.type_calcul_masse),
limitation_temps_maxi_stable(p.limitation_temps_maxi_stable),
amort_visco_arti(p.amort_visco_arti),visco_arti(p.visco_arti),
maxi_C_en_fonction_M(p.maxi_C_en_fonction_M),
coef_rayleigh_masse(p.coef_rayleigh_masse),coef_rayleigh_raideur(p.coef_rayleigh_raideur),
bulk_viscosity(p.bulk_viscosity),c_Tracebulk(p.c_Tracebulk),c_Trace2bulk(p.c_Trace2bulk),
frequence_affichage_increment(p.frequence_affichage_increment),
frequence_affichage_iteration(p.frequence_affichage_iteration),
sortie_fil_calcul(p.sortie_fil_calcul),
cas_de_sortie_fil_calcul(p.cas_de_sortie_fil_calcul),
nb_diggit_double_calcul(p.nb_diggit_double_calcul),
nb_diggit_double_graphique(p.nb_diggit_double_graphique),
nb_diggit_double_ecran(p.nb_diggit_double_ecran),
nb_incr_cal_ener(p.nb_incr_cal_ener),
affiche_incr_energie(p.affiche_incr_energie),
prec_pt_int_deb(p.prec_pt_int_deb),factPourRayonAccostage(p.factPourRayonAccostage),
distanceMaxiAuPtProjete(p.distanceMaxiAuPtProjete),
extra_boite_prelocalisation(p.extra_boite_prelocalisation),
mini_extra_boite_prelocalisation(p.mini_extra_boite_prelocalisation),
ajout_extra_boite_prelocalisation(p.ajout_extra_boite_prelocalisation),
contact_type(p.contact_type),prec_pt_sur_frontiere(p.prec_pt_sur_frontiere),
fct_nD_bascul_contact_type_4(p.fct_nD_bascul_contact_type_4),
penalisationPenetration(p.penalisationPenetration),
fct_nD_penalisationPenetration(p.fct_nD_penalisationPenetration),
penalisationTangentielle(p.penalisationTangentielle),
fct_nD_penalisationTangentielle(p.fct_nD_penalisationTangentielle),
typePenalisationPenetration(p.typePenalisationPenetration),
penetration_contact_maxi(p.penetration_contact_maxi),
fct_nD_penetration_contact_maxi(p.fct_nD_penetration_contact_maxi),
penetration_borne_regularisation(p.penetration_borne_regularisation),
fct_nD_penetration_borne_regularisation(p.fct_nD_penetration_borne_regularisation),
force_contact_noeud_maxi(p.force_contact_noeud_maxi),
fct_nD_force_contact_noeud_maxi(p.fct_nD_force_contact_noeud_maxi),
typePenalisationTangentielle(p.typePenalisationTangentielle),
tangentielle_contact_maxi(p.tangentielle_contact_maxi),
fct_nD_tangentielle_contact_maxi(p.fct_nD_tangentielle_contact_maxi),
tangentielle_borne_regularisation(p.tangentielle_borne_regularisation),
fct_nD_tangentielle_borne_regularisation(p.fct_nD_tangentielle_borne_regularisation),
force_tangentielle_noeud_maxi(p.force_tangentielle_noeud_maxi),
fct_nD_force_tangentielle_noeud_maxi(p.fct_nD_force_tangentielle_noeud_maxi),
nb_boucle_newton_position_frontiere(p.nb_boucle_newton_position_frontiere),
nbDecolAutorise(p.nbDecolAutorise),typeDeDecolement(p.typeDeDecolement),nb_glissant(p.nb_glissant),
niveau_commentaire_contact(p.niveau_commentaire_contact),
optimisation_numerotation(p.optimisation_numerotation),
point_interne_delta_thetai_maxi(p.point_interne_delta_thetai_maxi),
point_interne_prec_thetai_interne(p.point_interne_prec_thetai_interne),
point_interne_nb_boucle_sur_delta_thetai(p.point_interne_nb_boucle_sur_delta_thetai),
point_interne_nb_externe(p.point_interne_nb_externe),
cal_vol_total_entre_surface_et_plans_ref(p.cal_vol_total_entre_surface_et_plans_ref),
ratio_maxi_jacoMembrane_jacoPti(p.ratio_maxi_jacoMembrane_jacoPti),
type_calnum_inversion_metrique(p.type_calnum_inversion_metrique),
sortieEquilibreGlobal(p.sortieEquilibreGlobal),
sortieEtatActuelDansBI(p.sortieEtatActuelDansBI),
sortieEtatActuelDansCVisu(p.sortieEtatActuelDansCVisu)
{// pas de recopie des paramètre prec_pt_int_deb,extra_boite_prelocalisation car ils sont statics
// ParaGlob::Init_temps(tempo); // pas la peine car c'est une variable statique
};
// Surcharge de l'affectation
ParaAlgoControle& ParaAlgoControle::operator= (const ParaAlgoControle& p)
{ sauvegarde = p.sauvegarde; cas_de_sauvegarde = p.cas_de_sauvegarde;
tempo_specifique_algo = p.tempo_specifique_algo;
force_deltat = p.force_deltat;
coef_pas_critique_deltatmaxi = p.coef_pas_critique_deltatmaxi;
coef_pas_critique_deltatmini = p.coef_pas_critique_deltatmini;
typeDFC_pas_critique_deltatmaxi = p.typeDFC_pas_critique_deltatmaxi;
typeDFC_pas_critique_deltatmini = p.typeDFC_pas_critique_deltatmini;
iterations = p.iterations; precision = p.precision;
norme = p.norme; //prectemps = p.prectemps;
cinematique = p.cinematique; conv_forcee = p.conv_forcee;
multiplicateur = p.multiplicateur; //deltat = p.deltat;
coef_pas_critique_deltat = p.coef_pas_critique_deltat;
typeDFC_pas_critique_deltat = p.typeDFC_pas_critique_deltat;
maxincre = p.maxincre; //tempsfin = p.tempsfin;
max_essai_incre = p.max_essai_incre;
restart = p.restart; max_puissance = p.max_puissance;
line_search = p.line_search; var_charge_externe = p.var_charge_externe;
var_jacobien = p.var_jacobien; var_D = p.var_D;
type_matrice = p.type_matrice; symetrie_matrice = p.symetrie_matrice;
type_resolution = p.type_resolution;
type_preconditionnement = p.type_preconditionnement;
nb_iter_nondirecte = p.nb_iter_nondirecte;
tolerance = p.tolerance; nb_vect_restart = p.nb_vect_restart;
type_matrice_secondaire = p.type_matrice_secondaire;
type_resolution_secondaire = p.type_resolution_secondaire;
type_preconditionnement_secondaire = p.type_preconditionnement_secondaire;
nb_iter_nondirecte_secondaire = p.nb_iter_nondirecte_secondaire;
tolerance_secondaire = p.tolerance_secondaire; nb_vect_restart_secondaire = p.nb_vect_restart_secondaire;
opti_pointeur_assemblage = p.opti_pointeur_assemblage;
type_de_pilotage = p.type_de_pilotage; facteur_diminution = p.facteur_diminution;
facteur_augmentation = p.facteur_augmentation; fact_dim_en_mauvaiseConv = p.fact_dim_en_mauvaiseConv;
nb_bonne_convergence = p.nb_bonne_convergence;
nb_iter_pour_bonne_convergence = p.nb_iter_pour_bonne_convergence;
nb_iter_pour_mauvaise_convergence = p.nb_iter_pour_mauvaise_convergence;
init_comp_tangent_simple = p.init_comp_tangent_simple;
norme_incre_max = p.norme_incre_max; norme_incre_X_max = p.norme_incre_X_max;
norme_incre_V_max = p.norme_incre_V_max;
varMiniDdl = p.varMiniDdl; varMaxiDdl = p.varMaxiDdl;
nbCycleControleResidu = p.nbCycleControleResidu; plageControleResidu = p.plageControleResidu;
sur_sous_relaxation = p.sur_sous_relaxation; initIncreAvecDeltaDdlPrec = p.initIncreAvecDeltaDdlPrec;
jabobien_negatif = p.jabobien_negatif; var_maxi_jacobien = p.var_maxi_jacobien;
cas_fctnD_charge = p.cas_fctnD_charge;
type_calcul_masse = p.type_calcul_masse;
limitation_temps_maxi_stable = p.limitation_temps_maxi_stable;
amort_visco_arti = p.amort_visco_arti; visco_arti = p.visco_arti;
maxi_C_en_fonction_M = p.maxi_C_en_fonction_M;
coef_rayleigh_masse = p.coef_rayleigh_masse; coef_rayleigh_raideur = p.coef_rayleigh_raideur;
bulk_viscosity = p.bulk_viscosity; c_Tracebulk = p.c_Tracebulk; c_Trace2bulk = p.c_Trace2bulk;
frequence_affichage_increment = p.frequence_affichage_increment;
frequence_affichage_iteration = p.frequence_affichage_iteration;
sortie_fil_calcul = p.sortie_fil_calcul;
cas_de_sortie_fil_calcul = p.cas_de_sortie_fil_calcul;
nb_diggit_double_calcul = p.nb_diggit_double_calcul;
nb_diggit_double_graphique = p.nb_diggit_double_graphique;
nb_diggit_double_ecran = p.nb_diggit_double_ecran;
nb_incr_cal_ener = p.nb_incr_cal_ener;
affiche_incr_energie = p.affiche_incr_energie;
prec_pt_int_deb = p.prec_pt_int_deb; factPourRayonAccostage = p.factPourRayonAccostage;
distanceMaxiAuPtProjete = p.distanceMaxiAuPtProjete;
extra_boite_prelocalisation = p.extra_boite_prelocalisation;
mini_extra_boite_prelocalisation = p.mini_extra_boite_prelocalisation;
ajout_extra_boite_prelocalisation = p.ajout_extra_boite_prelocalisation;
contact_type = p.contact_type; prec_pt_sur_frontiere = p.prec_pt_sur_frontiere;
fct_nD_bascul_contact_type_4 = p.fct_nD_bascul_contact_type_4;
penalisationPenetration = p.penalisationPenetration;
fct_nD_penalisationPenetration = p.fct_nD_penalisationPenetration;
penalisationTangentielle = p.penalisationTangentielle;
fct_nD_penalisationPenetration = p.fct_nD_penalisationPenetration;
typePenalisationPenetration = p.typePenalisationPenetration;
penetration_contact_maxi = p.penetration_contact_maxi;
fct_nD_penetration_contact_maxi = p.fct_nD_penetration_contact_maxi;
penetration_borne_regularisation = p.penetration_borne_regularisation;
fct_nD_penetration_borne_regularisation = p.fct_nD_penetration_borne_regularisation;
force_contact_noeud_maxi = p.force_contact_noeud_maxi;
fct_nD_force_contact_noeud_maxi = p.fct_nD_force_contact_noeud_maxi;
typePenalisationTangentielle = p.typePenalisationTangentielle;
tangentielle_contact_maxi = p.tangentielle_contact_maxi;
fct_nD_tangentielle_contact_maxi = p.fct_nD_tangentielle_contact_maxi;
tangentielle_borne_regularisation = p.tangentielle_borne_regularisation;
fct_nD_tangentielle_borne_regularisation = p.fct_nD_tangentielle_borne_regularisation;
force_tangentielle_noeud_maxi = p.force_tangentielle_noeud_maxi;
fct_nD_force_tangentielle_noeud_maxi = p.fct_nD_force_tangentielle_noeud_maxi;
nb_boucle_newton_position_frontiere = p.nb_boucle_newton_position_frontiere;
nbDecolAutorise = p.nbDecolAutorise; typeDeDecolement = p.typeDeDecolement; nb_glissant = p.nb_glissant;
niveau_commentaire_contact = p.niveau_commentaire_contact;
optimisation_numerotation = p.optimisation_numerotation;
point_interne_delta_thetai_maxi = p.point_interne_delta_thetai_maxi;
point_interne_prec_thetai_interne = p.point_interne_prec_thetai_interne;
point_interne_nb_boucle_sur_delta_thetai = p.point_interne_nb_boucle_sur_delta_thetai;
point_interne_nb_externe = p.point_interne_nb_externe;
cal_vol_total_entre_surface_et_plans_ref = p.cal_vol_total_entre_surface_et_plans_ref;
ratio_maxi_jacoMembrane_jacoPti = p.ratio_maxi_jacoMembrane_jacoPti;
type_calnum_inversion_metrique = p.type_calnum_inversion_metrique;
sortieEquilibreGlobal = p.sortieEquilibreGlobal;
sortieEtatActuelDansBI = p.sortieEtatActuelDansBI;
sortieEtatActuelDansCVisu = p.sortieEtatActuelDansCVisu;
return *this;
};
// Méthodes publiques
void ParaAlgoControle::Lecture_paraAlgoControle(UtilLecture & entreePrinc)
{ if (ParaGlob::NiveauImpression() > 5)
cout << " debut de la lecture des parametres " << endl;
MotCle motCle; // ref aux mots cle
// on se positionne sur un mot cle
while ( !motCle.SimotCle(entreePrinc.tablcar))
entreePrinc.NouvelleDonnee();
// def de variable logique disant si oui ou non il y a eu lecture d'un type de paramètre
bool controle_lec=false; bool para_systeme_lineaire_lec = false;
bool para_pilotage_equi_global_lec = false; bool para_dedies_dynamique_lec = false;
bool para_affichage_lec = false;bool para_contact_lec = false; bool para_energie_lec = false;
bool para_calculs_geometriques_lec = false; bool lecture_max_essai_incre = false;
// on lit tant qu'il s'agit d'un mot clé concernant les paramètres de contrôle
while ((strstr(entreePrinc.tablcar,"controle")!=NULL) ||
(strstr(entreePrinc.tablcar,"para_syteme_lineaire")!=NULL) ||
(strstr(entreePrinc.tablcar,"para_pilotage_equi_global")!=NULL) ||
(strstr(entreePrinc.tablcar,"para_dedies_dynamique")!=NULL) ||
(strstr(entreePrinc.tablcar,"para_affichage")!=NULL)||
(strstr(entreePrinc.tablcar,"para_contact")!=NULL)||
(strstr(entreePrinc.tablcar,"para_energie")!=NULL)||
(strstr(entreePrinc.tablcar,"para_calculs_geometriques")!=NULL)
)
{ if (strstr(entreePrinc.tablcar,"controle")!=NULL)
{controle_lec=true;
// on lit jusqu'au prochain mot cle
string nom;
entreePrinc.NouvelleDonnee();
while ( !motCle.SimotCle(entreePrinc.tablcar))
{ *(entreePrinc.entree) >> nom;
if (nom == "SAUVEGARDE")
{ // on regarde s'il y a une référence à un intervalle
if((strstr(entreePrinc.tablcar,"INTER_TEMPS")!=NULL)
&& (strstr(entreePrinc.tablcar,"DERNIER_CALCUL")!=NULL))
{// cas où la sauvegarde est gérer en fonction d'un intervalle
cas_de_sauvegarde = 5; // enreg du type de gestion de sauvegarde
string nom1;
*(entreePrinc.entree) >> nom >> sauvegarde >> nom1;
if ((nom1 != "DERNIER_CALCUL") || (nom != "INTER_TEMPS"))
{ cout << "\n *** erreur on a lu : "<< nom << ", au lieu de DERNIER_CALCUL "
<< " ou alors on a lu : " << nom1 << ", au lieu de INTER_TEMPS !! ";
Sortie(1);
};
}
else if((strstr(entreePrinc.tablcar,"INTER_INCREMENT")!=NULL)
&& (strstr(entreePrinc.tablcar,"DERNIER_CALCUL")!=NULL))
{// cas où la sauvegarde est gérer en fonction d'un intervalle
cas_de_sauvegarde = 4; // enreg du type de gestion de sauvegarde
string nom1;
*(entreePrinc.entree) >> nom >> sauvegarde >> nom1;
if ((nom1 != "DERNIER_CALCUL") || (nom != "INTER_INCREMENT"))
{ cout << "\n *** erreur on a lu : "<< nom << ", au lieu de DERNIER_CALCUL "
<< " ou alors on a lu : " << nom1 << ", au lieu de INTER_INCREMENT !! ";
Sortie(1);
};
}
else if(strstr(entreePrinc.tablcar,"DERNIER_CALCUL")!=NULL)
{// cas où la sauvegarde est gérer en fonction du dernier calcul
cas_de_sauvegarde = 3; // enreg du type de gestion de sauvegarde
*(entreePrinc.entree) >> nom ; //>> sauvegarde;
}
else if(strstr(entreePrinc.tablcar,"INTER_TEMPS")!=NULL)
{// cas où la sauvegarde est gérer en fonction d'un intervale
cas_de_sauvegarde = 2; // enreg du type de gestion de sauvegarde
*(entreePrinc.entree) >> nom ;
sauvegarde = entreePrinc.lect_avec_const_double_utilisateur("SAUVEGARDE ");
}
else if(strstr(entreePrinc.tablcar,"INTER_INCREMENT")!=NULL)
{// cas où la sauvegarde est gérée par le nombre d'incréments
cas_de_sauvegarde = 1; // enreg du type de gestion de sauvegarde
*(entreePrinc.entree) >> nom ;
sauvegarde = entreePrinc.lect_avec_const_double_utilisateur("SAUVEGARDE ");
}
else
{// cas où la sauvegarde est gérée par le nombre d'incréments
cas_de_sauvegarde = 1; // enreg du type de gestion de sauvegarde
sauvegarde = entreePrinc.lect_avec_const_double_utilisateur("SAUVEGARDE ");
};
}
else if (nom == "DELTAtMAXI")
{ // on regarde s'il y a une référence au pas critique
if(strstr(entreePrinc.tablcar,"COEF_PASCRITIQUE_DFC")!=NULL)
// cas où c'est un coef du pas critique DFC
{ //on passe la chaine de caractère et on lit le coeff
string toto;
typeDFC_pas_critique_deltatmaxi=true; // pas critique DFC
*(entreePrinc.entree) >> toto ;
coef_pas_critique_deltatmaxi = entreePrinc.lect_avec_const_double_utilisateur
("DELTAtMAXI COEF_PASCRITIQUE_DFC ");
}
else if(strstr(entreePrinc.tablcar,"COEF_PASCRITIQUE")!=NULL)
// cas où c'est un coef du pas critique de la méthode
{ //on passe la chaine de caractère et on lit le coeff
string toto;
typeDFC_pas_critique_deltatmaxi=false; // pas critique spécifique
*(entreePrinc.entree) >> toto ;
coef_pas_critique_deltatmaxi = entreePrinc.lect_avec_const_double_utilisateur
("DELTAtMAXI COEF_PASCRITIQUE ");
}
else
// sinon on lit directement le deltatmaxi
{ tempo_specifique_algo.deltatmaxi = tempo.deltatmaxi
= entreePrinc.lect_avec_const_double_utilisateur("DELTAtMAXI ");
};
}
else if (nom == "DELTAtMINI")
{ // on regarde s'il y a une référence au pas critique
if(strstr(entreePrinc.tablcar,"COEF_PASCRITIQUE_DFC")!=NULL)
// cas où c'est un coef du pas critique DFC
{ //on passe la chaine de caractère et on lit le coeff
string toto;
typeDFC_pas_critique_deltatmini=true; // pas critique DFC
*(entreePrinc.entree) >> toto ;
coef_pas_critique_deltatmini = entreePrinc.lect_avec_const_double_utilisateur
("DELTAtMINI COEF_PASCRITIQUE_DFC ");
}
else if(strstr(entreePrinc.tablcar,"COEF_PASCRITIQUE")!=NULL)
// cas où c'est un coef du pas critique
{ //on passe la chaine de caractère et on lit le coeff
string toto;
typeDFC_pas_critique_deltatmini=false; // pas critique DFC
*(entreePrinc.entree) >> toto ;
coef_pas_critique_deltatmini = entreePrinc.lect_avec_const_double_utilisateur
("DELTAtMINI COEF_PASCRITIQUE ");
}
else
// sinon on lit directement le deltatmaxi
{ tempo_specifique_algo.deltatmini = tempo.deltatmini
= entreePrinc.lect_avec_const_double_utilisateur("DELTAtMINI ");};
}
else if (nom == "ITERATIONS")
{ // on regarde les termes par défaut qui sont dépendants de cette valeur
bool changer1 = (nb_iter_pour_bonne_convergence == 0.25 * iterations);
bool changer2 = (nb_iter_pour_mauvaise_convergence == 0.5 * iterations);
// lecture de la nouvelle valeur
iterations = (int) entreePrinc.lect_avec_const_double_utilisateur("ITERATIONS ");
if (changer1) nb_iter_pour_bonne_convergence = 0.25 * iterations;
if (changer2) nb_iter_pour_mauvaise_convergence = 0.5 * iterations;
}
else if (nom == "PRECISION")
{precision = entreePrinc.lect_avec_const_double_utilisateur("PRECISION ");}
else if (nom == "PRECTEMPS")
{tempo_specifique_algo.prectemps = tempo.prectemps
= entreePrinc.lect_avec_const_double_utilisateur("PRECTEMPS ");}
else if (nom == "MAX_PUISSANCE")
{max_puissance= entreePrinc.lect_avec_const_double_utilisateur("MAX_PUISSANCE ");}
else if (nom == "NORME")
{*(entreePrinc.entree) >> norme.nom1;
if ( !(strstr(norme.nom1.c_str(),"Residu") || strstr(norme.nom1.c_str(),"Residu/Reaction")
|| strstr(norme.nom1.c_str(),"Residu/PVExterne") || strstr(norme.nom1.c_str(),"Residu/PVInterne")
|| strstr(norme.nom1.c_str(),"Residu/maxPVI")|| strstr(norme.nom1.c_str(),"min(Res,Res/Reaction)")
|| strstr(norme.nom1.c_str(),"min(Res,Res/MaX(Reaction_et_PVExterne))")
|| strstr(norme.nom1.c_str(),"E_cinetique/E_statique_ET_ResSurReact")
|| strstr(norme.nom1.c_str(),"E_cinetique/E_statique_ET_Res/Reac_et_Fext")
|| strstr(norme.nom1.c_str(),"E_cin/E_stat_ET_min(Res,Res/Reac_et_Fext)")
|| strstr(norme.nom1.c_str(),"E_cinetique")
|| strstr(norme.nom1.c_str(),"Bilan_puissance/Max(puiss)")
|| strstr(norme.nom1.c_str(),"Residu/Reaction_et_Residu")
|| strstr(norme.nom1.c_str(),"fonction_nD:")
))
{ cout << "\n ** erreur en lecture du type de norme pour le controle"
<< " d\'algorithme, nom lu : "<< norme;
entreePrinc.MessageBuffer
("** lecture des parametres de controle **");
Affiche();
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie (1);
};
// s'il s'agit du nom d'une fonction nD on la récupère
if (norme.nom1 == "fonction_nD:")
*(entreePrinc.entree) >> norme.nom2;
}
else if (nom == "CINEMATIQUE")
{cinematique = (bool) entreePrinc.lect_avec_const_double_utilisateur("CINEMATIQUE ");
}
else if (nom == "CONV_FORCEE")
{conv_forcee = (bool) entreePrinc.lect_avec_const_double_utilisateur("CONV_FORCEE ");
}
else if (nom == "MULTIPLICATEUR")
{multiplicateur = entreePrinc.lect_avec_const_double_utilisateur("MULTIPLICATEUR ");
}
else if (nom == "DELTAt")
{ // on regarde s'il y a une référence au pas critique
if(strstr(entreePrinc.tablcar,"COEF_PASCRITIQUE_DFC")!=NULL)
// cas où c'est un coef du pas critique DFC
{ //on passe la chaine de caractère et on lit le coeff
string toto;
typeDFC_pas_critique_deltat=true; // pas critique DFC
*(entreePrinc.entree) >> toto ;
coef_pas_critique_deltat = entreePrinc.lect_avec_const_double_utilisateur
("DELTAt COEF_PASCRITIQUE_DFC ");
}
else if(strstr(entreePrinc.tablcar,"COEF_PASCRITIQUE")!=NULL)
// cas où c'est un coef du pas critique
{ //on passe la chaine de caractère et on lit le coeff
string toto;
typeDFC_pas_critique_deltat=false; // pas critique DFC
*(entreePrinc.entree) >> toto ;
coef_pas_critique_deltat = entreePrinc.lect_avec_const_double_utilisateur
("DELTAt COEF_PASCRITIQUE ");
}
else
// sinon on lit directement le deltat
{tempo_specifique_algo.deltat = tempo.deltat
= entreePrinc.lect_avec_const_double_utilisateur("DELTAt ");
};
// on regarde si l'on veut forcer la reprise du pas de temps donné dans le .info
// par rapport à celle du fichier de restart si il existe
if(strstr(entreePrinc.tablcar,"FORCE_DELTAT_DU_.INFO")!=NULL)
force_deltat=true; else force_deltat=false;
}
else if (nom == "TEMPSFIN")
{tempo_specifique_algo.tempsfin = tempo.tempsfin
= entreePrinc.lect_avec_const_double_utilisateur("TEMPSFIN ");
}
else if (nom == "MAXINCRE")
{maxincre = (int) entreePrinc.lect_avec_const_double_utilisateur("MAXINCRE ");
}
else if (nom == "MAX_ESSAI_INCRE")
{max_essai_incre= (int) entreePrinc.lect_avec_const_double_utilisateur("MAX_ESSAI_INCRE ");
lecture_max_essai_incre = true; // du coup le max_essai_incre ne prendra
} // pas la valeur par défaut qui est celle de maxincre
else if (nom == "RESTART")
{restart= (int) entreePrinc.lect_avec_const_double_utilisateur("RESTART ");
}
else if (nom == "LINE_SEARCH")
{line_search = true;}
else if (nom == "VARIATION_CHARGE_EXTERNE_SUR_RAIDEUR")
{var_charge_externe = (bool) entreePrinc.lect_avec_const_double_utilisateur
("VARIATION_CHARGE_EXTERNE_SUR_RAIDEUR ");
}
else if (nom == "VARIATION_JACOBIEN_SUR_RAIDEUR")
{var_jacobien = (bool) entreePrinc.lect_avec_const_double_utilisateur
("VARIATION_JACOBIEN_SUR_RAIDEUR ");
}
else if (nom == "VARIATION_VITESSE_DEFORMATION_SUR_RAIDEUR")
{var_D = (bool) entreePrinc.lect_avec_const_double_utilisateur
("VARIATION_VITESSE_DEFORMATION_SUR_RAIDEUR ");
}
else
{ cout << "\n ** erreur en lecture de parametre de controle"
<< " d\'algorithme, nom lu : "<< nom;
entreePrinc.MessageBuffer
("** lecture des parametres de controle **");
Affiche();
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie (1);
};
entreePrinc.NouvelleDonnee();
};
};
// ensuite on s'occupe du sytème lineaire général
if (strstr(entreePrinc.tablcar,"para_syteme_lineaire")!=NULL)
{ para_systeme_lineaire_lec = true; // on signal qu'il y a lecture
// on lit jusqu'au prochain mot cle
string nom;
entreePrinc.NouvelleDonnee();
while ( !motCle.SimotCle(entreePrinc.tablcar))
{ *(entreePrinc.entree) >> nom;
if (nom == "TYPE_MATRICE")
{*(entreePrinc.entree) >> type_matrice ;}
else if (nom == "SYMETRIE_MATRICE")
{symetrie_matrice= (bool) entreePrinc.lect_avec_const_double_utilisateur("SYMETRIE_MATRICE ");
}
else if (nom == "TYPE_RESOLUTION")
{*(entreePrinc.entree) >> type_resolution;}
else if (nom == "TYPE_PRECONDITIONNEMENT")
{*(entreePrinc.entree) >> type_preconditionnement;}
else if (nom == "NB_ITER_NONDIRECTE")
{nb_iter_nondirecte = (int) entreePrinc.lect_avec_const_double_utilisateur("NB_ITER_NONDIRECTE ");
}
else if (nom == "TOLERANCE")
{tolerance = entreePrinc.lect_avec_const_double_utilisateur("TOLERANCE ");
}
else if (nom == "NB_VECT_RESTART")
{nb_vect_restart = (int) entreePrinc.lect_avec_const_double_utilisateur("NB_VECT_RESTART ");}
else if (nom == "MATRICE_S_SECONDAIRE_S_")
{// dans le cas de matrices secondaires on lit tout d'abort les types de matrices
type_matrice_secondaire.clear(); // on vide d'abord la liste déjà existante
while (nom != "FIN_TYPE_MAT_SECONDAIRES_")
{ *(entreePrinc.entree) >> nom;
if (nom != "FIN_TYPE_MAT_SECONDAIRES_")
type_matrice_secondaire.push_back(Id_nom_matrice(nom));
};
}
else if (nom == "TYPE_RESOLUTION_S_SECONDAIRE_S_")
{// dans le cas de matrices secondaires lecture du type de résolution
type_resolution_secondaire.clear(); // on vide d'abord la liste déjà existante
while (nom != "FIN_TYPE_RESOLUTION_SECONDAIRES_")
{ *(entreePrinc.entree) >> nom;
if (nom != "FIN_TYPE_RESOLUTION_SECONDAIRES_")
type_resolution_secondaire.push_back(Id_nom_resolution(nom));
};
}
else if (nom == "TYPE_PRECONDITIONNEMENT_S_SECONDAIRE_S_")
{// dans le cas de matrices secondaires lecture du type de préconditionnement
type_preconditionnement_secondaire.clear(); // on vide d'abord la liste déjà existante
while (nom != "FIN_TYPE_PRECONDITIONNEMENT_SECONDAIRES_")
{ *(entreePrinc.entree) >> nom;
if (nom != "FIN_TYPE_PRECONDITIONNEMENT_SECONDAIRES_")
type_preconditionnement_secondaire.push_back(Id_nom_preconditionnement(nom));
};
}
else if (nom == "NB_ITER_NONDIRECTE_S_SECONDAIRE_S_")
{// dans le cas de matrices secondaires lecture du nombre d'itération
nb_iter_nondirecte_secondaire.clear(); // on vide d'abord la liste déjà existante
while (nom != "FIN_NB_ITER_NONDIRECTE_SECONDAIRES_")
{ *(entreePrinc.entree) >> nom;
if (nom != "FIN_NB_ITER_NONDIRECTE_SECONDAIRES_")
nb_iter_nondirecte_secondaire.push_back(ChangeEntier(nom));
};
}
else if (nom == "TOLERANCE_S_SECONDAIRE_S_")
{// dans le cas de matrices secondaires lecture du type de préconditionnement
tolerance_secondaire.clear(); // on vide d'abord la liste déjà existante
while (nom != "FIN_TOLERANCE_SECONDAIRES_")
{ *(entreePrinc.entree) >> nom;
if (nom != "FIN_TOLERANCE_SECONDAIRES_")
tolerance_secondaire.push_back(ChangeReel(nom));
};
}
else if (nom == "NB_VECT_RESTART_S_SECONDAIRE_S_")
{// dans le cas de matrices secondaires lecture du type de préconditionnement
nb_vect_restart_secondaire.clear(); // on vide d'abord la liste déjà existante
while (nom != "FIN_NB_VECT_RESTART_SECONDAIRES_")
{ *(entreePrinc.entree) >> nom;
if (nom != "FIN_NB_VECT_RESTART_SECONDAIRES_")
nb_vect_restart_secondaire.push_back(ChangeEntier(nom));
};
}
else if (nom == "OPTIMISATION_POINTEURS_ASSEMBLAGE")
{opti_pointeur_assemblage= (int) entreePrinc.lect_avec_const_double_utilisateur("OPTIMISATION_POINTEURS_ASSEMBLAGE ");}
else
{ cout << "\n ** erreur en lecture de parametres"
<< " pour le système linéaire, nom lu : "<< nom;
entreePrinc.MessageBuffer
("** lecture des parametres du systeme lineaire **");
Affiche();
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie (1);
};
entreePrinc.NouvelleDonnee();
}
};
// 3) ensuite on s'occupe des paramètres de pilotage de l'équilibre global
if (strstr(entreePrinc.tablcar,"para_pilotage_equi_global")!=NULL)
{ para_pilotage_equi_global_lec = true; // on signal qu'il y a lecture
// on lit jusqu'au prochain mot cle
string nom;
entreePrinc.NouvelleDonnee();
while ( !motCle.SimotCle(entreePrinc.tablcar))
{ *(entreePrinc.entree) >> nom;
if (nom == "FACTEUR_DIMINUTION")
facteur_diminution= entreePrinc.lect_avec_const_double_utilisateur("FACTEUR_DIMINUTION ");
else if (nom == "FACTEUR_AUGMENTATION")
facteur_augmentation= entreePrinc.lect_avec_const_double_utilisateur("FACTEUR_AUGMENTATION ");
else if (nom == "NB_BONNE_CONVERGENCE")
nb_bonne_convergence= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_BONNE_CONVERGENCE ");
else if (nom == "FACT_DIM_EN_MAUVAISE_CONVERGENCE")
fact_dim_en_mauvaiseConv= entreePrinc.lect_avec_const_double_utilisateur("FACT_DIM_EN_MAUVAISE_CONVERGENCE ");
else if (nom == "NB_ITER_POUR_BONNE_CONVERGENCE")
nb_iter_pour_bonne_convergence= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_ITER_POUR_BONNE_CONVERGENCE ");
else if (nom == "NB_ITER_POUR_MAUVAISE_CONVERGENCE")
nb_iter_pour_mauvaise_convergence= (int)entreePrinc.lect_avec_const_double_utilisateur("NB_ITER_POUR_MAUVAISE_CONVERGENCE ");
else if (nom == "INIT_COMP_TANGENT_SIMPLE")
init_comp_tangent_simple= entreePrinc.lect_avec_const_double_utilisateur("INIT_COMP_TANGENT_SIMPLE ");
else if (nom == "SUR_SOUS_RELAXATION")
sur_sous_relaxation= entreePrinc.lect_avec_const_double_utilisateur("SUR_SOUS_RELAXATION ");
else if (nom == "NORME_MAXI_INCREMENT")
norme_incre_max= entreePrinc.lect_avec_const_double_utilisateur("NORME_MAXI_INCREMENT ");
else if (nom == "NORME_MAXI_X_INCREMENT")
norme_incre_X_max= entreePrinc.lect_avec_const_double_utilisateur("NORME_MAXI_X_INCREMENT ");
else if (nom == "NORME_MAXI_V_INCREMENT")
norme_incre_V_max= entreePrinc.lect_avec_const_double_utilisateur("NORME_MAXI_V_INCREMENT ");
else if (nom == "MAXI_VARIATION_DDL_POUR_CONVERGENCE")
varMaxiDdl= entreePrinc.lect_avec_const_double_utilisateur("MAXI_VARIATION_DDL_POUR_CONVERGENCE ");
else if (nom == "MINI_VARIATION_DDL_POUR_CONVERGENCE")
varMiniDdl= entreePrinc.lect_avec_const_double_utilisateur("MINI_VARIATION_DDL_POUR_CONVERGENCE ");
else if (nom == "NB_CYCLE_CONTROLE_RESIDU")
nbCycleControleResidu= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_CYCLE_CONTROLE_RESIDU ");
else if (nom == "PLAGE_CONTROLE_RESIDU")
plageControleResidu= (int) entreePrinc.lect_avec_const_double_utilisateur("PLAGE_CONTROLE_RESIDU ");
else if (nom == "INIT_INCRE_AVEC_PAS_PREC")
initIncreAvecDeltaDdlPrec= entreePrinc.lect_avec_const_double_utilisateur("INIT_INCRE_AVEC_PAS_PREC ");
else if (nom == "CAS_JACOBIEN_NEGATIF")
jabobien_negatif= (int) entreePrinc.lect_avec_const_double_utilisateur("CAS_JACOBIEN_NEGATIF ");
else if (nom == "VAR_MAXI_JACOBIEN")
var_maxi_jacobien= entreePrinc.lect_avec_const_double_utilisateur("VAR_MAXI_JACOBIEN ");
else if (nom == "CAS_PB_FCTND_CHARGE")
cas_fctnD_charge= entreePrinc.lect_avec_const_double_utilisateur("CAS_PB_FCTND_CHARGE ");
else if (nom == "TYPE_DE_PILOTAGE")
*(entreePrinc.entree) >> type_de_pilotage;
else
{ cout << "\n ** erreur en lecture de parametres"
<< " pour le pilotage de l'equilibre global, nom lu : "<< nom;
entreePrinc.MessageBuffer
("** lecture des parametres du pilotage de l'equilibre global **");
Affiche();
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie (1);
}
entreePrinc.NouvelleDonnee();
}
}
// 4) ensuite on s'occupe des paramètres liés à la dynamique
if (strstr(entreePrinc.tablcar,"para_dedies_dynamique")!=NULL)
{ para_dedies_dynamique_lec = true; // on signal qu'il y a lecture
// on lit jusqu'au prochain mot cle
string nom;
entreePrinc.NouvelleDonnee();
while ( !motCle.SimotCle(entreePrinc.tablcar))
{ *(entreePrinc.entree) >> nom;
if (nom == "TYPE_CALCUL_MATRICE_MASSE")
{// lecture du type
*(entreePrinc.entree) >> nom;
if (nom == "MASSE_DIAG_COEF_EGAUX")
type_calcul_masse = MASSE_DIAG_COEF_EGAUX;
else if (nom == "MASSE_DIAG_COEF_VAR")
type_calcul_masse = MASSE_DIAG_COEF_VAR;
else if (nom == "MASSE_CONSISTANTE")
type_calcul_masse = MASSE_CONSISTANTE;
else
{ cout << "\n ** erreur en lecture de parametres"
<< " pour le type de matrice de masse, type lu : "<< nom;
entreePrinc.MessageBuffer
("** lecture des donnees lie à la dynamique **");
Affiche();
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie (1);
}
}
else if (nom == "LIMITATION_TEMPS_MAXI_STABLE")
{// lecture du booléen
limitation_temps_maxi_stable= (bool) entreePrinc.lect_avec_const_double_utilisateur("LIMITATION_TEMPS_MAXI_STABLE ");
}
else if (nom == "AMORTISSEMENT_VISCOSITE_ARTIFICIELLE")
{// lecture du cas d'amortissement
amort_visco_arti= (int) entreePrinc.lect_avec_const_double_utilisateur("AMORTISSEMENT_VISCOSITE_ARTIFICIELLE ");
}
else if (nom == "VISCOSITE_ARTIFICIELLE")
{// lecture de la viscosité ou de la proportion de viscosité critique
visco_arti= entreePrinc.lect_avec_const_double_utilisateur("VISCOSITE_ARTIFICIELLE ");
}
else if (nom == "MAXI_C_EN_FONCTION_M")
{// bornage de C critique
maxi_C_en_fonction_M= entreePrinc.lect_avec_const_double_utilisateur("MAXI_C_EN_FONCTION_M ");
}
else if (nom == "COEFFICIENT_DE_RAYLEIGH_POUR_LA_MASSE")
{// lecture du coefficient
coef_rayleigh_masse= entreePrinc.lect_avec_const_double_utilisateur("COEFFICIENT_DE_RAYLEIGH_POUR_LA_MASSE ");
}
else if (nom == "COEFFICIENT_DE_RAYLEIGH_POUR_LA_RAIDEUR")
{// lecture du coefficient
coef_rayleigh_raideur= entreePrinc.lect_avec_const_double_utilisateur("COEFFICIENT_DE_RAYLEIGH_POUR_LA_RAIDEUR ");
}
else if (nom == "BULK_VISCOSITY")
{// lecture du choix
bulk_viscosity= (int) entreePrinc.lect_avec_const_double_utilisateur("BULK_VISCOSITY ");
}
else if (nom == "COEFF_TRACE")
{// lecture du coefficient
c_Tracebulk= entreePrinc.lect_avec_const_double_utilisateur("COEFF_TRACE ");
}
else if (nom == "COEFF_CARRE_TRACE")
{// lecture du coefficient
c_Trace2bulk= entreePrinc.lect_avec_const_double_utilisateur("COEFF_CARRE_TRACE ");
}
else
{ cout << "\n ** erreur en lecture de parametres"
<< " pour les donnees lie à la dynamique, nom lu : "<< nom;
entreePrinc.MessageBuffer
("** lecture des donnees lie à la dynamique **");
Affiche();
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie (1);
}
entreePrinc.NouvelleDonnee();
}
}
// 5) paramètres liès à l'affichage des résultats
if (strstr(entreePrinc.tablcar,"para_affichage")!=NULL)
{ para_affichage_lec = true; // on signal qu'il y a lecture
// on lit jusqu'au prochain mot cle
string nom;
entreePrinc.NouvelleDonnee();
while ( !motCle.SimotCle(entreePrinc.tablcar))
{ *(entreePrinc.entree) >> nom;
if (nom == "FREQUENCE_AFFICHAGE_INCREMENT")
frequence_affichage_increment= (int) entreePrinc.lect_avec_const_double_utilisateur("FREQUENCE_AFFICHAGE_INCREMENT ");
else if (nom == "FREQUENCE_AFFICHAGE_ITERATION")
frequence_affichage_iteration= (int) entreePrinc.lect_avec_const_double_utilisateur("FREQUENCE_AFFICHAGE_ITERATION ");
else if (nom == "FREQUENCE_SORTIE_FIL_DU_CALCUL")
{ // on regarde s'il y a une référence au pas critique
if(strstr(entreePrinc.tablcar,"INTER_TEMPS")!=NULL)
{// cas où la sauvegarde est gérer en fonction d'un pas de temps
cas_de_sortie_fil_calcul = 2; // enreg du type de gestion de sauvegarde
*(entreePrinc.entree) >> nom ;
sortie_fil_calcul= entreePrinc.lect_avec_const_double_utilisateur("FREQUENCE_SORTIE_FIL_DU_CALCUL ");
}
else if(strstr(entreePrinc.tablcar,"DERNIER_CALCUL")!=NULL)
{// cas où la sauvegarde est gérer en fonction du dernier calcul
cas_de_sortie_fil_calcul = 3; // enreg du type de gestion de sauvegarde
*(entreePrinc.entree) >> nom ; // passage du nom
sortie_fil_calcul =1000000; // grand
}
else
{// cas où la sauvegarde est gérée par le nombre d'incréments
cas_de_sortie_fil_calcul = 1; // enreg du type de gestion de sauvegarde
sortie_fil_calcul= entreePrinc.lect_avec_const_double_utilisateur("FREQUENCE_SORTIE_FIL_DU_CALCUL ");
// si la fréquence est nulle ou négative
if (sortie_fil_calcul <= 0)sortie_fil_calcul =-1000000;
};
}
else if (nom == "NB_CHIFFRE_POUR_DOUBLE_CALCUL")
nb_diggit_double_calcul= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_CHIFFRE_POUR_DOUBLE_CALCUL ");
else if (nom == "NB_CHIFFRE_POUR_DOUBLE_GRAPHIQUE")
nb_diggit_double_graphique= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_CHIFFRE_POUR_DOUBLE_GRAPHIQUE ");
else if (nom == "NB_CHIFFRE_POUR_DOUBLE_ECRAN")
nb_diggit_double_ecran= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_CHIFFRE_POUR_DOUBLE_ECRAN ");
else
{ cout << "\n ** erreur en lecture des parametres d'affichage" << nom;
entreePrinc.MessageBuffer
("** lecture des parametres des parametres d'affichage **");
Affiche();
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie (1);
}
entreePrinc.NouvelleDonnee();
}
}
// 6) paramètres liès au contact
if (strstr(entreePrinc.tablcar,"para_contact")!=NULL)
{ para_contact_lec = true; // on signal qu'il y a lecture
// on lit jusqu'au prochain mot cle
string nom; string nom_inter;
entreePrinc.NouvelleDonnee();
while ( !motCle.SimotCle(entreePrinc.tablcar))
{ *(entreePrinc.entree) >> nom;
if (nom == "PRECISION_POINT_INTERNE_DEBUT")
{prec_pt_int_deb= entreePrinc.lect_avec_const_double_utilisateur("PRECISION_POINT_INTERNE_DEBUT ");}
else if (nom == "FACT_POUR_RAYON_ACCOSTAGE")
{factPourRayonAccostage= entreePrinc.lect_avec_const_double_utilisateur("FACT_POUR_RAYON_ACCOSTAGE ");}
else if (nom == "DISTANCE_MAXI_AU_PT_PROJETE")
{distanceMaxiAuPtProjete= entreePrinc.lect_avec_const_double_utilisateur("DISTANCE_MAXI_AU_PT_PROJETE ");}
else if (nom == "PRECISION_BOITE_PRELOCALISATION")
{extra_boite_prelocalisation= entreePrinc.lect_avec_const_double_utilisateur("PRECISION_BOITE_PRELOCALISATION ");}
else if (nom == "MINI_EXTRA_BOITE_PRELOCALISATION")
{mini_extra_boite_prelocalisation= entreePrinc.lect_avec_const_double_utilisateur("MINI_EXTRA_BOITE_PRELOCALISATION ");}
else if (nom == "AJOUT_EXTRA_BOITE_PRELOCALISATION")
{ajout_extra_boite_prelocalisation= entreePrinc.lect_avec_const_double_utilisateur("AJOUT_EXTRA_BOITE_PRELOCALISATION ");}
else if (nom == "CONTACT_TYPE")
{contact_type= (int) entreePrinc.lect_avec_const_double_utilisateur("CONTACT_TYPE ");}
else if (nom == "FCT_ND_BASCUL_CONTACT_TYPE_4")
{*(entreePrinc.entree) >> fct_nD_bascul_contact_type_4;}
else if (nom == "PENALISATION_PENETRATION")
{if (strstr(entreePrinc.tablcar,"FCT_ND_PENALISATION_PENETRATION")!=NULL)
{*(entreePrinc.entree) >> nom_inter >> fct_nD_penalisationPenetration;
penalisationPenetration = -ConstMath::tresgrand; // valeur négative arbitraire
}
else
{penalisationPenetration= entreePrinc.lect_avec_const_double_utilisateur("PENALISATION_PENETRATION ");
fct_nD_penalisationPenetration = "_";
}
}
else if (nom == "TYPE_PENALISATION_PENETRATION")
{typePenalisationPenetration= (int) entreePrinc.lect_avec_const_double_utilisateur("TYPE_PENALISATION_PENETRATION ");}
else if (nom == "PENETRATION_CONTACT_MAXI")
{if (strstr(entreePrinc.tablcar,"FCT_ND_PENETRATION_CONTACT_MAXI")!=NULL)
{*(entreePrinc.entree) >> nom_inter >> fct_nD_penetration_contact_maxi;
penetration_contact_maxi = -ConstMath::tresgrand; // valeur négative arbitraire
}
else
{penetration_contact_maxi= entreePrinc.lect_avec_const_double_utilisateur("PENETRATION_CONTACT_MAXI ");
penetration_contact_maxi=Dabs(penetration_contact_maxi);
fct_nD_penetration_contact_maxi = "_";
}
}
else if (nom == "PENETRATION_BORNE_REGULARISATION")
{if (strstr(entreePrinc.tablcar,"FCT_ND_PENETRATION_BORNE_REGULARISATION")!=NULL)
{*(entreePrinc.entree) >> nom_inter >> fct_nD_penetration_borne_regularisation;
penetration_borne_regularisation = -ConstMath::tresgrand; // valeur négative arbitraire
}
else
{penetration_borne_regularisation= entreePrinc.lect_avec_const_double_utilisateur("PENETRATION_BORNE_REGULARISATION ");
penetration_borne_regularisation=Dabs(penetration_borne_regularisation);
fct_nD_penetration_borne_regularisation = "_";
}
}
else if (nom == "FORCE_CONTACT_NOEUD_MAXI")
{if (strstr(entreePrinc.tablcar,"FCT_ND_FORCE_CONTACT_NOEUD_MAXI")!=NULL)
{*(entreePrinc.entree) >> nom_inter >> fct_nD_force_contact_noeud_maxi;
force_contact_noeud_maxi = -ConstMath::tresgrand; // valeur négative arbitraire
}
else
{force_contact_noeud_maxi= entreePrinc.lect_avec_const_double_utilisateur("FORCE_CONTACT_NOEUD_MAXI ");
force_contact_noeud_maxi=Dabs(force_contact_noeud_maxi);
fct_nD_force_contact_noeud_maxi = "_";
}
}
else if (nom == "PENALISATION_TANGENTIELLE")
{if (strstr(entreePrinc.tablcar,"FCT_ND_PENALISATION_TANGENTIELLE")!=NULL)
{*(entreePrinc.entree) >> nom_inter >> fct_nD_penalisationTangentielle;
penalisationTangentielle = -ConstMath::tresgrand; // valeur négative arbitraire
}
else
{penalisationTangentielle= entreePrinc.lect_avec_const_double_utilisateur("PENALISATION_TANGENTIELLE ");
fct_nD_penalisationTangentielle = "_";
}
}
else if (nom == "TYPE_PENALISATION_TANGENTIELLE")
{typePenalisationTangentielle= (int) entreePrinc.lect_avec_const_double_utilisateur("TYPE_PENALISATION_TANGENTIELLE ");}
else if (nom == "TANGENTIELLE_CONTACT_MAXI")
{if (strstr(entreePrinc.tablcar,"FCT_ND_TANGENTIELLE_CONTACT_MAXI")!=NULL)
{*(entreePrinc.entree) >> nom_inter >> fct_nD_tangentielle_contact_maxi;
tangentielle_contact_maxi = -ConstMath::tresgrand; // valeur négative arbitraire
}
else
{tangentielle_contact_maxi= entreePrinc.lect_avec_const_double_utilisateur("TANGENTIELLE_CONTACT_MAXI ");
tangentielle_contact_maxi=Dabs(tangentielle_contact_maxi);
fct_nD_tangentielle_contact_maxi = "_";
}
}
else if (nom == "TANGENTIELLE_BORNE_REGULARISATION")
{if (strstr(entreePrinc.tablcar,"FCT_ND_TANGENTIELLE_BORNE_REGULARISATION")!=NULL)
{*(entreePrinc.entree) >> nom_inter >> fct_nD_tangentielle_borne_regularisation;
tangentielle_borne_regularisation = -ConstMath::tresgrand; // valeur négative arbitraire
}
else
{tangentielle_borne_regularisation= entreePrinc.lect_avec_const_double_utilisateur("TANGENTIELLE_BORNE_REGULARISATION ");
tangentielle_borne_regularisation=Dabs(tangentielle_borne_regularisation);
fct_nD_tangentielle_borne_regularisation = "_";
}
}
else if (nom == "FORCE_TANGENTIELLE_NOEUD_MAXI")
{if (strstr(entreePrinc.tablcar,"FCT_ND_FORCE_TANGENTIELLE_NOEUD_MAXI")!=NULL)
{*(entreePrinc.entree) >> nom_inter >> fct_nD_force_tangentielle_noeud_maxi;
force_tangentielle_noeud_maxi = -ConstMath::tresgrand; // valeur négative arbitraire
}
else
{force_tangentielle_noeud_maxi= entreePrinc.lect_avec_const_double_utilisateur("FORCE_TANGENTIELLE_NOEUD_MAXI ");
force_tangentielle_noeud_maxi=Dabs(force_tangentielle_noeud_maxi);
fct_nD_force_tangentielle_noeud_maxi = "_";
}
}
else if (nom == "PRECISION_PT_SUR_FRONTIERE")
{prec_pt_sur_frontiere= entreePrinc.lect_avec_const_double_utilisateur("PRECISION_PT_SUR_FRONTIERE ");}
else if (nom == "NB_BOUCLE_NEWTON_SUR_POSITION_FRONTIERE")
{nb_boucle_newton_position_frontiere= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_BOUCLE_NEWTON_SUR_POSITION_FRONTIERE ");}
else if (nom == "NB_DECOLLEMENT_MAXI")
{nbDecolAutorise= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_DECOLLEMENT_MAXI ");}
else if (nom == "TYPE_DE_DECOLLEMENT")
{typeDeDecolement= (int) entreePrinc.lect_avec_const_double_utilisateur("TYPE_DE_DECOLLEMENT ");}
else if (nom == "NB_MOY_GLISSANT")
{nb_glissant= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_MOY_GLISSANT ");}
else if (nom == "NIVEAU_COMMENTAIRE_CONTACT")
{niveau_commentaire_contact= (int) entreePrinc.lect_avec_const_double_utilisateur("NIVEAU_COMMENTAIRE_CONTACT ");}
else if (nom == "OPTIMISATION_NUMEROTATION")
{optimisation_numerotation= (int) entreePrinc.lect_avec_const_double_utilisateur("OPTIMISATION_NUMEROTATION ");}
else
{ cout << "\n ** erreur en lecture des parametres de contact" << nom;
entreePrinc.MessageBuffer
("** lecture des parametres des parametres de contact **");
Affiche();
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie (1);
}
entreePrinc.NouvelleDonnee();
};
}
// 7) paramètres liés aux calculs des énergies
if (strstr(entreePrinc.tablcar,"para_energie")!=NULL)
{ para_energie_lec = true; // on signal qu'il y a lecture
// on lit jusqu'au prochain mot cle
string nom;
entreePrinc.NouvelleDonnee();
while ( !motCle.SimotCle(entreePrinc.tablcar))
{ *(entreePrinc.entree) >> nom;
if (nom == "CALCUL_ENERGIE")
{double calcul_energie;
*(entreePrinc.entree) >> calcul_energie;
cout << "\n warning CALCUL_ENERGIE est un parametre obsolete, le calcul est maintenant systematique "
<< endl;
}
else if (nom == "NB_INCR_CAL_ENERG")
nb_incr_cal_ener= (int) entreePrinc.lect_avec_const_double_utilisateur("NB_INCR_CAL_ENERG ");
else if (nom == "AFFICHE_INCR_ENERGIE")
affiche_incr_energie= (bool) entreePrinc.lect_avec_const_double_utilisateur("AFFICHE_INCR_ENERGIE ");
else
{ cout << "\n ** erreur en lecture des parametres sur l'energie" << nom;
entreePrinc.MessageBuffer
("** lecture des parametres des parametres sur l'energie **");
Affiche();
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie (1);
}
entreePrinc.NouvelleDonnee();
}
};
// 8) paramètres liés aux calculs géométriques sur les éléments
if (strstr(entreePrinc.tablcar,"para_calculs_geometriques")!=NULL)
{ para_calculs_geometriques_lec = true; // on signal qu'il y a lecture
// on lit jusqu'au prochain mot cle
string nom;
entreePrinc.NouvelleDonnee();
while ( !motCle.SimotCle(entreePrinc.tablcar))
{ *(entreePrinc.entree) >> nom;
if (nom == "POINT_INTERNE_DELTA_THETAI_MAXI")
{point_interne_delta_thetai_maxi= entreePrinc.lect_avec_const_double_utilisateur("POINT_INTERNE_DELTA_THETAI_MAXI ");}
else if (nom == "POINT_INTERNE_PREC_THETAI_INTERNE")
{point_interne_prec_thetai_interne= entreePrinc.lect_avec_const_double_utilisateur("POINT_INTERNE_PREC_THETAI_INTERNE ");}
else if (nom == "POINT_INTERNE_NB_BOUCLE_SUR_DELTA_THETAI")
{point_interne_nb_boucle_sur_delta_thetai= (int) entreePrinc.lect_avec_const_double_utilisateur("POINT_INTERNE_NB_BOUCLE_SUR_DELTA_THETAI ");}
else if (nom == "POINT_INTERNE_NB_EXTERNE")
{point_interne_nb_externe= (int) entreePrinc.lect_avec_const_double_utilisateur("POINT_INTERNE_NB_EXTERNE ");}
else if (nom == "CAL_VOL_TOTAL_ENTRE_SURFACE_ET_PLANS_REF")
{cal_vol_total_entre_surface_et_plans_ref= (bool) entreePrinc.lect_avec_const_double_utilisateur("CAL_VOL_TOTAL_ENTRE_SURFACE_ET_PLANS_REF ");}
else if (nom == "RATIO_MAXI_JACOMEMBRANE_JACOPTI" )
{ratio_maxi_jacoMembrane_jacoPti= entreePrinc.lect_avec_const_double_utilisateur("RATIO_MAXI_JACOMEMBRANE_JACOPTI ");}
else if (nom == "TYPE_CALNUM_INVERSION_METRIQUE")
{ *(entreePrinc.entree) >> type_calnum_inversion_metrique;}
else
{ cout << "\n ** erreur en lecture des parametres de calculs geometrique: mot cle inconnu : " << nom;
entreePrinc.MessageBuffer
("** lecture des parametres des parametres sur l'energie **");
Affiche();
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie (1);
}
entreePrinc.NouvelleDonnee();
}
}
}; // fin de la lecture tant qu'il y a un mot clé relatif à la lecture de paramètres
// affichage d'information concernant les paramètres
if ((ParaGlob::NiveauImpression() >= 4 ) && (ParaGlob::param->EtatDeLaLecturePointInfo()==0))
{ if (!controle_lec)
{ cout << "\n lecture des parametres de controle ";
cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
};
if (!para_systeme_lineaire_lec)
{ cout << "\n lecture des parametres pour le syteme lineaire ";
cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
};
if (!para_pilotage_equi_global_lec)
{ cout << "\n ** lecture des parametres du pilotage de l'equilibre global **";
cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
};
if (!para_dedies_dynamique_lec)
{ cout << "\n ** lecture des parametres parametres lies a la dynamique **";
cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
};
if (!para_affichage_lec)
{ cout << "\n ** lecture des parametres parametres lies a l'affichage **";
cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
};
if (!para_contact_lec)
{ cout << "\n ** lecture des parametres parametres lies au contact **";
cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
}
if (!para_energie_lec)
{ cout << "\n ** lecture des parametres parametres lies aux energies **";
cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
}
if (!para_calculs_geometriques_lec)
{ cout << "\n ** lecture des parametres parametres lies aux calculs geometriques **";
cout << "\n **** ATTENTION utilisation de TOUS les parametres par defaut !! " << flush;
};
};
if ((ParaGlob::NiveauImpression() > 0 ) && (ParaGlob::param->EtatDeLaLecturePointInfo()> 0))
{ if (controle_lec)
cout << "\n relecture de certains(s) parametre(s) de controle " << flush;
if (para_systeme_lineaire_lec)
cout << "\n relecture de certains(s) parametre(s) pour le syteme lineaire " << flush;
if (para_pilotage_equi_global_lec)
cout << "\n ** relecture de certains(s) parametre(s) du pilotage de l'equilibre global **" << flush;
if (para_dedies_dynamique_lec)
cout << "\n ** relecture de certains(s) parametre(s) lies a la dynamique **" << flush;
if (para_affichage_lec)
cout << "\n ** relecture de certains(s) parametre(s) lies a l'affichage **" << flush;
if (para_contact_lec)
cout << "\n ** relecture de certains(s) parametre(s) lies au contact **" << flush;
if (para_energie_lec)
cout << "\n ** relecture de certains(s) parametre(s) lies aux energies **" << flush;
if (para_calculs_geometriques_lec)
cout << "\n ** relecture de certains(s) parametre(s) lies aux calculs geometriques **" << flush;
};
if (ParaGlob::NiveauImpression() >= 4 )
{ // vérification sur les paramètres temps
if (tempo.deltatmaxi < tempo.deltatmini)
{ cout << "\n ***erreur en lecture des parametres de controle du temps: deltat maxi "
<< tempo.deltatmaxi << " est inferieur eu deltat mini " << tempo.deltatmini;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie (1);
};
if (tempo.deltatmini < 0.)
{ cout << "\n ***erreur en lecture des parametres de controle du temps: deltat mini est negatif: "
<< tempo.deltatmini;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie (1);
};
};
// particularité liée au paramètre max_essai_incre
if (!lecture_max_essai_incre) // s'il n'y a pas eu de lecture du paramètre max_essai_incre
max_essai_incre = maxincre; // on le met à la valeur par défaut = maxincre
if (ParaGlob::NiveauImpression() >= 4)
cout << " \n fin de la lecture des parametres " << endl;
};
// sauvegarde propre de l'élément sur base info
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
// incre : numero d'incrément auquel on sauvegarde
// éventuellement est définit de manière spécifique pour chaque algorithme
// dans les classes filles
void ParaAlgoControle::Ecriture_base_info_Para
(ofstream& sort,const int cas) const
{// dans le cas particulier de cette classe il n'y a que les paramètres
// du calcul qu'il faut sauvegarder
sort << "\n";
switch (cas)
{ case 1 : // ------- on sauvegarde tout -------------------------
{// 1) parametres de controle généraux pour la résolution de l'équilibre
// générale
sort << "PARAMETRES_DU_CALCUL_:\n";
sort << "frequence_de_sauvegarde " << sauvegarde << "\n";
sort << "casDeGestion_de_sauvegarde " << cas_de_sauvegarde << "\n";
sort << "force_deltat_du_point_info " << force_deltat << "\n";
sort << "coef_pas_critique_deltatmaxi " << coef_pas_critique_deltatmaxi << "\n";
sort << "coef_pas_critique_deltatmini " << coef_pas_critique_deltatmini << "\n";
sort << "typeDFC_pas_critique_deltatmaxi " << typeDFC_pas_critique_deltatmaxi << "\n";
sort << "typeDFC_pas_critique_deltatmini " << typeDFC_pas_critique_deltatmini << "\n";
sort << "maxi_d'iteration_pour_converger " << iterations << "\n";
sort << "precision_de_la_convergence " << precision << "\n";
// sort << "precision_sur_le_temps_final " << tempo.prectemps << "\n";
sort << "type_de_norme_de_convergence " << norme << "\n";
sort << "cinematique_sur_l'increment " << cinematique << "\n";
sort << "convergence_forcee " << conv_forcee << "\n";
sort << "multiplicateur_de_la_charge " << multiplicateur << "\n";
// sort << "increment_de_temps " << tempo.deltat << "\n";
sort << "coef_pas_critique_deltat " << coef_pas_critique_deltat << "\n";
sort << "typeDFC_pas_critique_deltat " << typeDFC_pas_critique_deltat << "\n";
// sort << "temps_de_fin_de_calcul " << tempo.tempsfin << "\n";
sort << "maximum_d'increment_de_temps " << maxincre << "\n";
sort << "maximum_d'essai_d'increment_de_temps " << max_essai_incre << "\n";
sort << "increment_de_redemarage_de_calcul " << restart << "\n";
sort << "maximum_de_puissance " << max_puissance << "\n";
sort << "utilisation_du_line_search " << line_search << '\n';
sort << "var_charge_externe " << var_charge_externe << '\n';
sort << "var_jacobien " << var_jacobien << '\n';
sort << "var_D " << var_D << '\n';
// sauvegarde du temps
tempo_specifique_algo.Ecriture_base_info_temps(sort,cas);
// 2) paramètres liés au systèmes d'équation linéairelinéaire
sort << "PARAMETRES_SYSTEM_LINEAIRE_:\n";
sort << "type_de_matrice " << type_matrice << "\n";
sort << "symetrie_matrice " << symetrie_matrice << "\n";
sort << "type_de_resolution " << type_resolution << "\n";
sort << "type_de_preconditionnement " << type_preconditionnement << "\n";
sort << "nombre_iteration_non_directe " << nb_iter_nondirecte << "\n";
sort << "tolerance_resol_non_directe " << tolerance << "\n";
sort << "nb_vecteur_restart " << nb_vect_restart << "\n";
// maintenant les listes pour les matrices secondaires si nécessaire
sort << " liste_pour_matrice_secondaire_ \n ";
if (!type_matrice_secondaire.empty())
{ sort << "type_matrice_secondaire(s)_taille: " << type_matrice_secondaire.size() << " \n";
list < Enum_matrice >::const_iterator ili,ili_end=type_matrice_secondaire.end();
for (ili = type_matrice_secondaire.begin();ili != ili_end;ili++)
sort << " " << (*ili) ;
sort << "\n";
};
if (!type_resolution_secondaire.empty())
{ sort << "type_resolution_secondaire(s)_taille: " << type_resolution_secondaire.size() << " \n";
list < Enum_type_resolution_matri >::const_iterator ili,ili_end=type_resolution_secondaire.end();
for (ili = type_resolution_secondaire.begin();ili != ili_end;ili++)
sort << " " << (*ili) ;
sort << "\n";
};
if (!type_preconditionnement_secondaire.empty())
{ sort << "type_preconditionnement_secondaire(s)_taille: " << type_preconditionnement_secondaire.size() << " \n";
list < Enum_preconditionnement >::const_iterator ili,ili_end=type_preconditionnement_secondaire.end();
for (ili = type_preconditionnement_secondaire.begin();ili != ili_end;ili++)
sort << " " << (*ili) ;
sort << "\n";
};
if (!nb_iter_nondirecte_secondaire.empty())
{ sort << "nb_iter_nondirecte_secondaire(s)_taille: " << nb_iter_nondirecte_secondaire.size() << " \n";
list < int >::const_iterator ili,ili_end=nb_iter_nondirecte_secondaire.end();
for (ili = nb_iter_nondirecte_secondaire.begin();ili != ili_end;ili++)
sort << " " << (*ili) ;
sort << "\n";
};
if (!tolerance_secondaire.empty())
{ sort << "tolerance_secondaire(s)_taille: " << tolerance_secondaire.size() << " \n";
list < double >::const_iterator ili,ili_end=tolerance_secondaire.end();
for (ili = tolerance_secondaire.begin();ili != ili_end;ili++)
sort << " " << (*ili) ;
sort << "\n";
};
if (!nb_vect_restart_secondaire.empty())
{ sort << "nb_vect_restart_secondaire(s)_taille: " << nb_vect_restart_secondaire.size() << " \n";
list < int >::const_iterator ili,ili_end=nb_vect_restart_secondaire.end();
for (ili = nb_vect_restart_secondaire.begin();ili != ili_end;ili++)
sort << " " << (*ili) ;
sort << "\n";
};
sort << " fin_liste_pour_matrice_secondaire_ \n ";
sort << "OPTIMISATION_POINTEURS_ASSEMBLAGE " << opti_pointeur_assemblage << "\n";
// 3) paramètres liés au pilotage de l'équilibre global
sort << "PARAMETRES_PILOTAGE_EQUILIBRE_GLOBAL:\n";
sort << "typ_de_pilotage " << Nom_TypePilotage(type_de_pilotage) << "\n";
sort << "facteur_diminution " << facteur_diminution << "\n";
sort << "facteur_augmentation " << facteur_augmentation << "\n";
sort << "nb_bonne_convergence " << nb_bonne_convergence << "\n";
sort << "fact_dim_en_mauvaiseConv " << fact_dim_en_mauvaiseConv << "\n";
sort << "nb_iter_pour_bonne_convergence " << nb_iter_pour_bonne_convergence << "\n";
sort << "nb_iter_pour_mauvaise_convergence " << nb_iter_pour_mauvaise_convergence << "\n";
sort << "init_comp_tangent_simple " << init_comp_tangent_simple << "\n";
sort << "sur_sous_relaxation " << sur_sous_relaxation << "\n";
sort << "norme_maxi_increment " << norme_incre_max << "\n";
sort << "norme_maxi_X_increment " << norme_incre_X_max << "\n";
sort << "norme_maxi_V_increment " << norme_incre_V_max << "\n";
sort << "maxi_variation_ddl_pour_convergence " << varMaxiDdl << "\n";
sort << "mini_variation_ddl_pour_convergence " << varMiniDdl << "\n";
sort << "nb_cycle_controle_residu " << nbCycleControleResidu << "\n";
sort << "plage_controle_residu " << plageControleResidu << "\n";
sort << "init_incre_avec_pas_prec " << initIncreAvecDeltaDdlPrec << "\n";
sort << "jabobien_negatif " << jabobien_negatif << "\n";
sort << "var_maxi_jacobien " << var_maxi_jacobien << "\n";
sort << "cas_fctnD_charge " << cas_fctnD_charge << "\n";
// 4) paramètres liès à la dynamique
sort << "PARAMETRES_DEDIES_DYNAMIQUE:\n";
sort << "type_calcul_masse " << type_calcul_masse << "\n";
sort << "limitation_temps_maxi_stable " << limitation_temps_maxi_stable << "\n";
sort << "amorti_visco_artificielle " << amort_visco_arti << "\n";
sort << "coeff_visco_artificielle " << visco_arti << "\n";
sort << "maxi_C_en_fonction_M " << maxi_C_en_fonction_M << "\n";
sort << "coeff_rayleigh_masse " << coef_rayleigh_masse << "\n";
sort << "coeff_rayleigh_raideur " << coef_rayleigh_raideur << "\n";
sort << "bulk_viscosity " << bulk_viscosity << "\n";
sort << "c_Tracebulk " << c_Tracebulk << "\n";
sort << "c_Trace2bulk " << c_Trace2bulk << "\n";
// 5) paramètres liès à l'affichage des résultats
sort << "PARAMETRES_AFFICHAGE:\n";
sort << "FREQUENCE_AFFICHAGE_INCREMENT " << frequence_affichage_increment << "\n";
sort << "FREQUENCE_AFFICHAGE_ITERATION " << frequence_affichage_iteration << "\n";
sort << "FREQUENCE_SORTIE_FIL_DU_CALCUL " << sortie_fil_calcul << "\n";
sort << "CAS_DE_FREQUENCE_SORTIE_FIL_CALCUL " << cas_de_sortie_fil_calcul << "\n";
sort << "NB_CHIFFRE_POUR_DOUBLE_CALCUL " << nb_diggit_double_calcul << "\n";
sort << "NB_CHIFFRE_POUR_DOUBLE_GRAPHIQUE " << nb_diggit_double_graphique << "\n";
sort << "NB_CHIFFRE_POUR_DOUBLE_ECRAN " << nb_diggit_double_ecran << "\n";
// 6) paramètres liès au contact
sort << "PARAMETRES_CONTACT:\n";
sort << "PRECISION_POINT_INTERNE_DEBUT " << prec_pt_int_deb << "\n";
sort << "FACT_POUR_RAYON_ACCOSTAGE " << factPourRayonAccostage << "\n";
sort << "DISTANCE_MAXI_AU_PT_PROJETE " << distanceMaxiAuPtProjete << "\n";
sort << "PRECISION_BOITE_PRELOCALISATION " << extra_boite_prelocalisation << "\n";
sort << "MINI_EXTRA_BOITE_PRELOCALISATION " << mini_extra_boite_prelocalisation << "\n";
sort << "AJOUT_EXTRA_BOITE_PRELOCALISATION " << ajout_extra_boite_prelocalisation << "\n";
sort << "CONTACT_TYPE " << contact_type << "\n";
sort << "FCT_ND_BASCUL_CONTACT_TYPE_4 " << fct_nD_bascul_contact_type_4 << "\n";
sort << "PENALISATION_PENETRATION " << penalisationPenetration
<< "FCT_ND_PENALISATION_PENETRATION"<< fct_nD_penalisationPenetration <<"\n";
sort << "TYPE_PENALISATION_PENETRATION " << typePenalisationPenetration << "\n";
sort << "PENETRATION_CONTACT_MAXI " << penetration_contact_maxi
<< "FCT_ND_PENETRATION_CONTACT_MAXI"<< fct_nD_penetration_contact_maxi <<"\n";
sort << "PENETRATION_BORNE_REGULARISATION " << penetration_borne_regularisation
<< "FCT_ND_PENETRATION_BORNE_REGULARISATION"<< fct_nD_penetration_borne_regularisation <<"\n";
sort << "FORCE_CONTACT_NOEUD_MAXI " << force_contact_noeud_maxi
<< "FCT_ND_FORCE_CONTACT_NOEUD_MAXI"<< fct_nD_force_contact_noeud_maxi <<"\n";
sort << "PENALISATION_TANGENTIELLE " << penalisationTangentielle
<< "FCT_ND_PENALISATION_TANGENTIELLE"<< fct_nD_penalisationTangentielle <<"\n";
sort << "TYPE_PENALISATION_TANGENTIELLE " << typePenalisationTangentielle << "\n";
sort << "TANGENTIELLE_CONTACT_MAXI " << tangentielle_contact_maxi
<< "FCT_ND_TANGENTIELLE_CONTACT_MAXI"<< fct_nD_tangentielle_contact_maxi <<"\n";
sort << "TANGENTIELLE_BORNE_REGULARISATION " << tangentielle_borne_regularisation
<< "FCT_ND_TANGENTIELLE_BORNE_REGULARISATION"<< fct_nD_tangentielle_borne_regularisation <<"\n";
sort << "FORCE_TANGENTIELLE_NOEUD_MAXI " << force_tangentielle_noeud_maxi
<< "FCT_ND_FORCE_TANGENTIELLE_NOEUD_MAXI"<< fct_nD_force_tangentielle_noeud_maxi <<"\n";
sort << "PRECISION_PT_SUR_FRONTIERE " << prec_pt_sur_frontiere << "\n";
sort << "NB_BOUCLE_NEWTON_SUR_POSITION_FRONTIERE " << nb_boucle_newton_position_frontiere << "\n";
sort << "NB_DECOLLEMENT_MAXI " << nbDecolAutorise << "\n";
sort << "TYPE_DE_DECOLLEMENT " << typeDeDecolement << "\n";
sort << "NB_MOY_GLISSANT " << nb_glissant << "\n";
sort << "NIVEAU_COMMENTAIRE_CONTACT "<< niveau_commentaire_contact << "\n";
sort << "OPTIMISATION_NUMEROTATION "<< optimisation_numerotation << "\n";
// 7) paramètres liès aux énergies
sort << "PARAMETRES_ENERGIES:\n";
sort << "NB_INCR_CAL_ENERG " << nb_incr_cal_ener << "\n";
sort << "AFFICHE_INCR_ENERGIE " << affiche_incr_energie << "\n";
// 8) paramètres liés aux calculs géométriques sur les éléments
sort << "PARAMETRES_CALCULS_GEOMETRIQUES:\n";
sort << "POINT_INTERNE_DELTA_THETAI_MAXI " << point_interne_delta_thetai_maxi << "\n";
sort << "POINT_INTERNE_PREC_THETAI_INTERNE " << point_interne_prec_thetai_interne << "\n";
sort << "POINT_INTERNE_NB_BOUCLE_SUR_DELTA_THETAI " << point_interne_nb_boucle_sur_delta_thetai << "\n";
sort << "POINT_INTERNE_NB_EXTERNE " << point_interne_nb_externe << "\n";
sort << "CAL_VOL_TOTAL_ENTRE_SURFACE_ET_PLANS_REF " << cal_vol_total_entre_surface_et_plans_ref << "\n";
sort << "RATIO_MAXI_JACOMEMBRANE_JACOPTI " << ratio_maxi_jacoMembrane_jacoPti << "\n";
sort << "TYPE_CALNUM_INVERSION_METRIQUE " << type_calnum_inversion_metrique << "\n";
sort << flush;
break;
}
case 2 : // ----------- sauvegarde uniquement de se qui varie --------------------
{// paramètres relatifs au temps
tempo_specifique_algo.Ecriture_base_info_temps(sort,cas);
break;
}
}
};
// cas de la lecture spécifique à l'algorithme dans base_info
void ParaAlgoControle::Lecture_base_info_Para(ifstream& ent,const int cas)
{ // dans le cas particulier de cette classe il n'y a que les paramètres
// du calcul qu'il faut lire
switch (cas)
{ case 1 : // lecture complète
{string toto;
ent >> toto;
ent >> toto >> sauvegarde ;
ent >> toto >> cas_de_sauvegarde ;
ent >> toto >> force_deltat ;
ent >> toto >> coef_pas_critique_deltatmaxi ;
ent >> toto >> coef_pas_critique_deltatmini ;
ent >> toto >> typeDFC_pas_critique_deltatmaxi ;
ent >> toto >> typeDFC_pas_critique_deltatmini ;
ent >> toto >> iterations ;
ent >> toto >> precision ;
ent >> toto >> norme ;
ent >> toto >> cinematique ;
ent >> toto >> conv_forcee ;
ent >> toto >> multiplicateur ;
ent >> toto >> coef_pas_critique_deltat ;
ent >> toto >> typeDFC_pas_critique_deltat ;
ent >> toto >> maxincre ;
ent >> toto >> max_essai_incre ;
ent >> toto >> restart ;
ent >> toto >> max_puissance ;
ent >> toto >> line_search ;
ent >> toto >> var_charge_externe ;
ent >> toto >> var_jacobien ;
ent >> toto >> var_D ;
// lecture du temps
tempo_specifique_algo.Lecture_base_info_temps(ent,cas);
// 2) paramètres liés au systèmes d'équation linéairelinéaire
ent >> toto ;
ent >> toto >> type_matrice ;
ent >> toto >> symetrie_matrice ;
ent >> toto >> type_resolution ;
ent >> toto >> type_preconditionnement ;
ent >> toto >> nb_iter_nondirecte ;
ent >> toto >> tolerance ;
ent >> toto >> nb_vect_restart ;
// maintenant les listes pour les matrices secondaires si nécessaire
ent >> toto ; // passage du mot clé
while (toto != "fin_liste_pour_matrice_secondaire_")
{ ent >> toto ; // on lit le mot clé
if (toto == "type_matrice_secondaire(s)_taille:")
{ type_matrice_secondaire.clear(); // on vide la liste
int taille = 0;
ent >> taille;
for (int i=1;i<=taille;i++)
{ ent >> toto;
type_matrice_secondaire.push_back(Id_nom_matrice(toto));
};
}
else if (toto == "type_resolution_secondaire(s)_taille:")
{ type_resolution_secondaire.clear(); // on vide la liste
int taille = 0;
ent >> taille;
for (int i=1;i<=taille;i++)
{ ent >> toto;
type_resolution_secondaire.push_back(Id_nom_resolution(toto));
};
}
else if (toto == "type_preconditionnement_secondaire(s)_taille:")
{ type_preconditionnement_secondaire.clear(); // on vide la liste
int taille = 0;
ent >> taille;
for (int i=1;i<=taille;i++)
{ ent >> toto;
type_preconditionnement_secondaire.push_back(Id_nom_preconditionnement(toto));
};
}
else if (toto == "nb_iter_nondirecte_secondaire(s)_taille:")
{ nb_iter_nondirecte_secondaire.clear(); // on vide la liste
int taille = 0;
ent >> taille;
for (int i=1;i<=taille;i++)
{ ent >> toto;
nb_iter_nondirecte_secondaire.push_back(ChangeEntier(toto));
};
}
else if (toto == "tolerance_secondaire(s)_taille:")
{ tolerance_secondaire.clear(); // on vide la liste
int taille = 0;
ent >> taille;
for (int i=1;i<=taille;i++)
{ ent >> toto;
tolerance_secondaire.push_back(ChangeReel(toto));
};
}
else if (toto == "nb_vect_restart_secondaire(s)_taille:")
{ nb_vect_restart_secondaire.clear(); // on vide la liste
int taille = 0;
ent >> taille;
for (int i=1;i<=taille;i++)
{ ent >> toto;
nb_vect_restart_secondaire.push_back(ChangeEntier(toto));
};
}
else if (toto == "fin_liste_pour_matrice_secondaire_")
{ } // on ne fait rien c'est ok
else
{cout << "\n erreur en lecture des listes pour matrices secondaires: "
<< " on a lu: "<< toto << " et on ne sait pas quoi en faire !! "
<< "\n ParaAlgoControle::Lecture_base_info_Para(.. "
<< endl;
Sortie(1);
};
};
ent >> toto >> opti_pointeur_assemblage;
// 3) paramètres liés au pilotage de l'équilibre global
ent >> toto ;
ent >> toto >> facteur_diminution;
ent >> toto >> type_de_pilotage;
ent >> toto >> facteur_augmentation;
ent >> toto >> nb_bonne_convergence;
ent >> toto >> fact_dim_en_mauvaiseConv;
ent >> toto >> nb_iter_pour_bonne_convergence;
ent >> toto >> nb_iter_pour_mauvaise_convergence;
ent >> toto >> init_comp_tangent_simple;
ent >> toto >> sur_sous_relaxation;
ent >> toto >> norme_incre_max;
ent >> toto >> norme_incre_X_max;
ent >> toto >> norme_incre_V_max;
ent >> toto >> varMaxiDdl;
ent >> toto >> varMiniDdl;
ent >> toto >> nbCycleControleResidu ;
ent >> toto >> plageControleResidu ;
ent >> toto >> initIncreAvecDeltaDdlPrec ;
ent >> toto >> jabobien_negatif ;
ent >> toto >> var_maxi_jacobien ;
ent >> toto >> cas_fctnD_charge ;
// 4) paramètres liès à la dynamique
ent >> toto ;
ent >> toto >> type_calcul_masse ;
ent >> toto >> limitation_temps_maxi_stable ;
ent >> toto >> amort_visco_arti ;
ent >> toto >> visco_arti ;
ent >> toto >> maxi_C_en_fonction_M ;
ent >> toto >> coef_rayleigh_masse ;
ent >> toto >> coef_rayleigh_raideur ;
ent >> toto >> bulk_viscosity ;
ent >> toto >> c_Tracebulk ;
ent >> toto >> c_Trace2bulk ;
// 5) paramètres liès à l'affichage des résultats
ent >> toto ;
ent >> toto >> frequence_affichage_increment ;
ent >> toto >> frequence_affichage_iteration ;
ent >> toto >> sortie_fil_calcul ;
ent >> toto >> cas_de_sortie_fil_calcul ;
ent >> toto >> nb_diggit_double_calcul ;
ent >> toto >> nb_diggit_double_graphique ;
ent >> toto >> nb_diggit_double_ecran ;
// 6) paramètres liès au contact
ent >> toto ;
ent >> toto >> prec_pt_int_deb ;
ent >> toto >> factPourRayonAccostage ;
ent >> toto >> distanceMaxiAuPtProjete;
ent >> toto >> extra_boite_prelocalisation ;
ent >> toto >> mini_extra_boite_prelocalisation ;
ent >> toto >> ajout_extra_boite_prelocalisation ;
ent >> toto >> contact_type ;
ent >> toto >> fct_nD_bascul_contact_type_4 ;
ent >> toto >> penalisationPenetration >> toto >> fct_nD_penalisationPenetration;
ent >> toto >> typePenalisationPenetration ;
ent >> toto >> penetration_contact_maxi >> toto >> fct_nD_penetration_contact_maxi ;
ent >> toto >> penetration_borne_regularisation >> toto >> fct_nD_penetration_borne_regularisation;
ent >> toto >> force_contact_noeud_maxi >> toto >> fct_nD_force_contact_noeud_maxi;
ent >> toto >> penalisationTangentielle >> toto >> fct_nD_penalisationTangentielle;
ent >> toto >> typePenalisationTangentielle ;
ent >> toto >> tangentielle_contact_maxi >> toto >> fct_nD_tangentielle_contact_maxi ;
ent >> toto >> tangentielle_borne_regularisation >> toto >> fct_nD_tangentielle_borne_regularisation;
ent >> toto >> force_tangentielle_noeud_maxi >> toto >> fct_nD_force_tangentielle_noeud_maxi ;
ent >> toto >> prec_pt_sur_frontiere ;
ent >> toto >> nb_boucle_newton_position_frontiere ;
ent >> toto >> nbDecolAutorise ;
ent >> toto >> typeDeDecolement ;
ent >> toto >> nb_glissant ;
// 7) paramètres liès aux énergies
ent >> toto ;
ent >> toto >> nb_incr_cal_ener ;
ent >> toto >> affiche_incr_energie ;
// 8) paramètres liés aux calculs géométriques sur les éléments
ent >> toto ;
ent >> toto >> point_interne_delta_thetai_maxi ;
ent >> toto >> point_interne_prec_thetai_interne ;
ent >> toto >> point_interne_nb_boucle_sur_delta_thetai ;
ent >> toto >> point_interne_nb_externe ;
ent >> toto >> cal_vol_total_entre_surface_et_plans_ref ;
ent >> toto >> ratio_maxi_jacoMembrane_jacoPti ;
ent >> toto >> type_calnum_inversion_metrique ;
break;
}
case 2 : // lecture uniquement de ce qui varie
{// lecture du temps
if (force_deltat && (restart!=0))
{ // cas du premier passage, et d'un restart
// cas ou on veut forcer l'état de deltat à la valeur du .info (ou autre valeur initiale)
double sauve_deltat = tempo_specifique_algo.deltat; // sauvegarde de la valeur initiale
tempo_specifique_algo.Lecture_base_info_temps(ent,cas);
tempo_specifique_algo.deltat = sauve_deltat; // récup de la valeur précédente
force_deltat = false;
tempo = tempo_specifique_algo;
}
else
{// cas courant
tempo_specifique_algo.Lecture_base_info_temps(ent,cas);
tempo = tempo_specifique_algo;
};
break;
};
} // -- fin du switch
};
// affichage des parametres de controle de l'algorithme
// et affichage des paramètres liés à la résolution du système linéaire
void ParaAlgoControle::Affiche() const
{
// 1) parametres de controle généraux pour la résolution de l'équilibre
// générale
cout << "\n parametres de controle de l'algorithmes \n";
cout << "frequence de sauvegarde = " << sauvegarde << '\n';
cout << "casDeGestion_de_sauvegarde = " << cas_de_sauvegarde << '\n';
cout << "force deltat du point info = " << force_deltat << '\n';
cout << "coef pas_critique pour deltatmaxi= " << coef_pas_critique_deltatmaxi << '\n';
cout << "coef pas_critique pour deltatmini= " << coef_pas_critique_deltatmini << '\n';
cout << "type pas_critique DFC pour deltatmaxi= " << typeDFC_pas_critique_deltatmaxi << '\n';
cout << "type pas_critique DFC pour deltatmini= " << typeDFC_pas_critique_deltatmini << '\n';
cout << "maxi d'iteration pour converger = " << iterations << '\n';
cout << "precision de la convergence = " << precision << '\n';
// cout << "precision sur le temps final = " << tempo.prectemps << '\n';
cout << "type de norme de convergence = " << norme << '\n';
cout << "cinematique sur l'increment = " << cinematique << '\n';
cout << "convergence forcee = " << conv_forcee << '\n';
cout << "multiplicateur de la charge = " << multiplicateur << '\n';
// cout << "increment de temps = " << tempo.deltat << '\n';
// cout << "temps de fin de calcul = " << tempo.tempsfin << '\n';
cout << "maximum d'increment de temps = " << maxincre << '\n';
cout << "maximum d'essai d'increment = " << max_essai_incre << '\n';
cout << "increment de redemarage de calcul = " << restart << '\n';
cout << "maximum de puissance = " << max_puissance << '\n';
cout << "utilisation du line_search = " << line_search << '\n';
cout << "var_charge_externe = " << var_charge_externe << '\n';
cout << "var_jacobien = " << var_jacobien << '\n';
cout << "var_D = " << var_D << '\n';
// affichage des paramètres liés au temps
tempo_specifique_algo.Affiche();
// 2) paramètres liés au systèmes d'équation linéaire
cout << "PARAMETRES_SYSTEM_LINEAIRE_:\n";
cout << "type de matrice " << type_matrice << "\n";
cout << "symetrie de l'assemblage " << symetrie_matrice << "\n";
cout << "type de resolution " << type_resolution << "\n";
cout << "type de preconditionnement " << type_preconditionnement << "\n";
cout << "nombre iteration non directe " << nb_iter_nondirecte << "\n";
cout << "tolerance resol non directe " << tolerance << "\n";
cout << "nb vecteur restart " << nb_vect_restart << "\n";
// maintenant les listes pour les matrices secondaires si nécessaire
if (!type_matrice_secondaire.empty())
{ cout << "type_matrice_secondaire(s)_taille: " << type_matrice_secondaire.size() << " \n";
list < Enum_matrice >::const_iterator ili,ili_end=type_matrice_secondaire.end();
for (ili = type_matrice_secondaire.begin();ili != ili_end;ili++)
cout << " " << (*ili) ;
cout << "\n";
};
if (!type_resolution_secondaire.empty())
{ cout << "type_resolution_secondaire(s)_taille: " << type_resolution_secondaire.size() << " \n";
list < Enum_type_resolution_matri >::const_iterator ili,ili_end=type_resolution_secondaire.end();
for (ili = type_resolution_secondaire.begin();ili != ili_end;ili++)
cout << " " << (*ili) ;
cout << "\n";
};
if (!type_preconditionnement_secondaire.empty())
{ cout << "type_preconditionnement_secondaire(s)_taille: " << type_preconditionnement_secondaire.size() << " \n";
list < Enum_preconditionnement >::const_iterator ili,ili_end=type_preconditionnement_secondaire.end();
for (ili = type_preconditionnement_secondaire.begin();ili != ili_end;ili++)
cout << " " << (*ili) ;
cout << "\n";
};
if (!nb_iter_nondirecte_secondaire.empty())
{ cout << "nb_iter_nondirecte_secondaire(s)_taille: " << nb_iter_nondirecte_secondaire.size() << " \n";
list < int >::const_iterator ili,ili_end=nb_iter_nondirecte_secondaire.end();
for (ili = nb_iter_nondirecte_secondaire.begin();ili != ili_end;ili++)
cout << " " << (*ili) ;
cout << "\n";
};
if (!tolerance_secondaire.empty())
{ cout << "tolerance_secondaire(s)_taille: " << tolerance_secondaire.size() << " \n";
list < double >::const_iterator ili,ili_end=tolerance_secondaire.end();
for (ili = tolerance_secondaire.begin();ili != ili_end;ili++)
cout << " " << (*ili) ;
cout << "\n";
};
if (!nb_vect_restart_secondaire.empty())
{ cout << "nb_vect_restart_secondaire(s)_taille: " << nb_vect_restart_secondaire.size() << " \n";
list < int >::const_iterator ili,ili_end=nb_vect_restart_secondaire.end();
for (ili = nb_vect_restart_secondaire.begin();ili != ili_end;ili++)
cout << " " << (*ili) ;
cout << "\n";
};
cout << "OPTIMISATION_POINTEURS_ASSEMBLAGE" << opti_pointeur_assemblage << "\n";
// 3) paramètres liés au pilotage de l'équilibre global
cout << "PARAMETRES_PILOTAGE_EQUILIBRE_GLOBAL:\n";
cout << "typ_de_pilotage " << Nom_TypePilotage(type_de_pilotage) << "\n";
cout << "facteur_diminution" << facteur_diminution << "\n";
cout << "facteur_augmentation" << facteur_augmentation << "\n";
cout << "nb_bonne_convergence" << nb_bonne_convergence << "\n";
cout << "fact_dim_en_mauvaiseConv" << fact_dim_en_mauvaiseConv << "\n";
cout << "nb_iter_pour_bonne_convergence" << nb_iter_pour_bonne_convergence << "\n";
cout << "nb_iter_pour_mauvaise_convergence " << nb_iter_pour_mauvaise_convergence << "\n";
cout << "init_comp_tangent_simple" << init_comp_tangent_simple << "\n";
cout << "sur_sous_relaxation" << sur_sous_relaxation << "\n";
cout << "norme_maxi_increment" << norme_incre_max << "\n";
cout << "norme_maxi_X_increment" << norme_incre_X_max << "\n";
cout << "norme_maxi_V_increment" << norme_incre_V_max << "\n";
cout << "maxi_variation_ddl_pour_convergence " << varMaxiDdl << "\n";
cout << "mini_variation_ddl_pour_convergence " << varMiniDdl << "\n";
cout << "nb_cycle_controle_residu " << nbCycleControleResidu << "\n";
cout << "plage_controle_residu " << plageControleResidu << "\n";
cout << "init_incre_avec_pas_prec " << initIncreAvecDeltaDdlPrec << "\n";
cout << "jabobien_negatif " << jabobien_negatif << "\n";
cout << "var_maxi_jacobien " << var_maxi_jacobien << "\n";
cout << "cas_fctnD_charge " << cas_fctnD_charge << "\n";
// 4) paramètres liès à la dynamique
cout << "PARAMETRES_DEDIES_DYNAMIQUE:\n";
cout << "type_calcul_masse" << type_calcul_masse << "\n";
cout << "limitation_temps_maxi_stable" << limitation_temps_maxi_stable << "\n";
cout << "amorti_visco_artificielle " << amort_visco_arti << "\n";
cout << "coeff_visco_artificielle " << visco_arti << "\n";
cout << "maxi_C_en_fonction_M " << maxi_C_en_fonction_M << "\n";
cout << "coeff_rayleigh_masse " << coef_rayleigh_masse << "\n";
cout << "coeff_rayleigh_raideur " << coef_rayleigh_raideur << "\n";
cout << "bulk_viscosity " << bulk_viscosity << "\n";
cout << "c_Tracebulk " << c_Tracebulk << "\n";
cout << "c_Trace2bulk " << c_Trace2bulk << "\n";
// 5) paramètres liès à l'affichage des résultats
cout << "PARAMETRES_AFFICHAGE:\n";
cout << "frequence_affichage_increment " << frequence_affichage_increment << "\n";
cout << "frequence_affichage_iteration " << frequence_affichage_iteration << "\n";
cout << "sortie_fil_calcul " << sortie_fil_calcul << "\n";
cout << "CAS_DE_SORTIE_FIL_CALCUL " << cas_de_sortie_fil_calcul << "\n";
cout << "nb_chiffre_pour_double_calcul " << nb_diggit_double_calcul << "\n";
cout << "nb_chiffre_pour_double_graphique " << nb_diggit_double_graphique << "\n";
cout << "nb_chiffre_pour_double_ecran " << nb_diggit_double_ecran << "\n";
// 6) paramètres liès au contact
cout << "PARAMETRES_CONTACT:\n";
cout << "PRECISION_POINT_INTERNE_DEBUT " << prec_pt_int_deb << "\n";
cout << "FACT_POUR_RAYON_ACCOSTAGE " << factPourRayonAccostage << "\n";
cout << "DISTANCE_MAXI_AU_PT_PROJETE" << distanceMaxiAuPtProjete << "\n";
cout << "PRECISION_BOITE_PRELOCALISATION " << extra_boite_prelocalisation << "\n";
cout << "MINI_EXTRA_BOITE_PRELOCALISATION " << mini_extra_boite_prelocalisation << "\n";
cout << "AJOUT_EXTRA_BOITE_PRELOCALISATION " << ajout_extra_boite_prelocalisation << "\n";
cout << "CONTACT_TYPE " << contact_type << "\n";
cout << "FCT_ND_BASCUL_CONTACT_TYPE_4 " << fct_nD_bascul_contact_type_4 << "\n";
cout << "PENALISATION_PENETRATION " << penalisationPenetration
<< "FCT_ND_PENALISATION_PENETRATION"<< fct_nD_penalisationPenetration <<"\n";
cout << "TYPE_PENALISATION_PENETRATION " << typePenalisationPenetration << "\n";
cout << "PENETRATION_CONTACT_MAXI " << penetration_contact_maxi
<< "FCT_ND_PENETRATION_CONTACT_MAXI"<< fct_nD_penetration_contact_maxi << "\n";
cout << "PENETRATION_BORNE_REGULARISATION " << penetration_borne_regularisation
<< "FCT_ND_PENETRATION_BORNE_REGULARISATION"<< fct_nD_penetration_borne_regularisation << "\n";
cout << "FORCE_CONTACT_NOEUD_MAXI " << force_contact_noeud_maxi
<< "FCT_ND_FORCE_CONTACT_NOEUD_MAXI"<< fct_nD_force_contact_noeud_maxi << "\n";
cout << "PENALISATION_TANGENTIELLE " << penalisationTangentielle
<< "FCT_ND_PENALISATION_TANGENTIELLE"<< fct_nD_penalisationTangentielle << "\n";
cout << "TYPE_PENALISATION_TANGENTIELLE " << typePenalisationTangentielle << "\n";
cout << "TANGENTIELLE_CONTACT_MAXI " << tangentielle_contact_maxi
<< "FCT_ND_TANGENTIELLE_CONTACT_MAXI"<< fct_nD_tangentielle_contact_maxi << "\n";
cout << "TANGENTIELLE_BORNE_REGULARISATION " << tangentielle_borne_regularisation
<< "FCT_ND_TANGENTIELLE_BORNE_REGULARISATION"<< fct_nD_tangentielle_borne_regularisation << "\n";
cout << "FORCE_TANGENTIELLE_NOEUD_MAXI " << force_tangentielle_noeud_maxi
<< "FCT_ND_FORCE_TANGENTIELLE_NOEUD_MAXI"<< fct_nD_force_tangentielle_noeud_maxi << "\n";
cout << "PRECISION_PT_SUR_FRONTIERE " << prec_pt_sur_frontiere << "\n";
cout << "NB_BOUCLE_NEWTON_SUR_POSITION_FRONTIERE " << nb_boucle_newton_position_frontiere << "\n";
cout << "NB_DECOLLEMENT_MAXI " << nbDecolAutorise << "\n";
cout << "TYPE_DE_DECOLLEMENT " << typeDeDecolement << "\n";
cout << "NB_MOY_GLISSANT " << nb_glissant << "\n";
cout << "NIVEAU_COMMENTAIRE_CONTACT " << niveau_commentaire_contact << "\n";
cout << "OPTIMISATION_NUMEROTATION " << optimisation_numerotation << "\n";
// 7) paramètres liès aux énergies
cout << "PARAMETRES_ENERGIES:\n";
cout << "NB_INCR_CAL_ENERG " << nb_incr_cal_ener << "\n";
cout << "AFFICHE_INCR_ENERGIE " << affiche_incr_energie << "\n";
// 8) paramètres liés aux calculs géométriques sur les éléments
cout << "PARAMETRES_CALCULS_GEOMETRIQUES:\n";
cout << "POINT_INTERNE_DELTA_THETAI_MAXI " << point_interne_delta_thetai_maxi << "\n";
cout << "POINT_INTERNE_PREC_THETAI_INTERNE " << point_interne_prec_thetai_interne << "\n";
cout << "POINT_INTERNE_NB_BOUCLE_SUR_DELTA_THETAI " << point_interne_nb_boucle_sur_delta_thetai << "\n";
cout << "POINT_INTERNE_NB_EXTERNE " << point_interne_nb_externe << "\n";
cout << "CAL_VOL_TOTAL_ENTRE_SURFACE_ET_PLANS_REF " << cal_vol_total_entre_surface_et_plans_ref << "\n";
cout << "RATIO_MAXI_JACOMEMBRANE_JACOPTI " << ratio_maxi_jacoMembrane_jacoPti << "\n";
cout << "TYPE_CALNUM_INVERSION_METRIQUE " << type_calnum_inversion_metrique << "\n";
};
// affichage et definition interactive des commandes
void ParaAlgoControle::Info_commande_ParaAlgoControle(UtilLecture& entreePrinc)
{
ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
//On va proposer un menu
string rep=" ";
cout << "\n --- definition des parametres de controle ------ ";
while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
{
try
{
cout << "\n choix du groupe de controle : "
<< "\n [c] -> para tres classique [-] para assez courants "
<< "\n (0 ou f) (fin) "
<< "\n (1) controles generaux pour la resolution de l'equilibre generale [c]"
<< "\n (2) parametres lies au systeme d'equation lineaire "
<< "\n (3) parametres lies à la dynamique "
<< "\n (4) parametres lies à l'affichage des resultats [c]"
<< "\n (5) parametres lies au contact "
<< "\n (6) parametres lies aux energies "
<< "\n (7) parametres lies aux calculs geometriques sur les elements "
<< "\n ";
rep = lect_return_defaut(false,"f");
if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie directe
break;
int num = ChangeEntier(rep);
if (!((num >= 0)&&(num<=7)))
{ cout << "\n Erreur on attendait un entier entre 0 et 7 !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour arreter le programme";
};
switch (num)
{ case 0: // sortie
{ break;} // normalement cela a déjà été filtré avant
case 1: // controles generaux pour la resolution de l'equilibre generale
{ sort << "\n\n controle #------------ "
<< "\n#--------------------------- "
<< "\n# PARAMETRE | VALEUR | "
<< "\n#--------------------------- ";
Tableau<bool> tab_modif(26,false); // indique qu'est-ce qui a été modifié
//On va proposer un menu
string repa=" ";
cout << "\n --- controle generaux ------ ";
while ((Minuscules(repa) != "f")&&(Minuscules(repa) != "0"))
{try
{ cout << "\n (0 ou f) (fin) "
<< "\n --- parametres de controle de l'algorithmes et para par defaut "
<< "\n [c] -> para tres classique [-] para assez courants "
<< "\n (1) frequence de sauvegarde = 1 [c] "
<< "\n (2) type de gestion de sauvegarde = 1 "
<< "\n (3) FORCE_DELTAT_DU_.INFO "
<< "\n (4) coef pas_critique pour deltatmaxi = 0."
<< "\n (5) coef pas_critique pour deltatmini = -3333256794."
<< "\n (6) type pas_critique DFC pour deltatmaxi = true "
<< "\n (7) type pas_critique DFC pour deltatmini = true "
<< "\n (8) maxi d'iteration pour converger = 100 [-] "
<< "\n (9) precision de la convergence = 1.e-3 [-] "
<< "\n (10) precision sur le temps final = 1.E-12"
<< "\n (11) type de norme de convergence = Residu/Reaction [-]"
<< "\n ou: fonction_nD: <le nom de la fonction nD> "
<< "\n (12) cinematique sur l'increment = false"
<< "\n (13) convergence forcee = false"
<< "\n (14) multiplicateur de la charge = 1."
<< "\n (15) increment de temps = 1. [c]"
<< "\n (16) temps de fin de calcul = 1. [c]"
<< "\n (17) maximum d'increment de temps = 400 [-]"
<< "\n (18) increment de redemarage de calcul = 0"
<< "\n (19) maximum de puissance = 1.e10"
<< "\n (20) utilisation du line_search = false"
<< "\n (21) var_charge_externe = true"
<< "\n (22) var_D= false"
<< "\n (23) ajout au choix sur la norme: "
<< "\n et_miniVarDdl et_VarRes et_maxiVarDdl"
<< "\n (24) delta t maxi 1. [c]"
<< "\n (25) delta t mini 0. [-]"
<< "\n (26) maximum d'essai d'increment de temps = maxincre [-]"
<< "\n ";
repa = lect_return_defaut(false,"f");;
if ((Minuscules(repa) == "f") || (Minuscules(repa) == "0"))// sortie directe
break;
int numa = ChangeEntier(repa);
if (!((numa >= 0)&&(numa<=26)))
{ cout << "\n Erreur on attendait un entier entre 0 et 26 !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour arreter le programme";
};
int val_int;
bool val_bool;
double val_double;
string val_string,string_inter;
bool bonne_lecture = false;
switch (numa)
{ case 0: // sortie
{ break;} // normalement cela a déjà été filtré avant
case 2:
{ cout << "\n (1) type par intervalle d'increment "
<< "\n (2) type par intervalle de temps "
<< "\n (3) uniquement l'increment 0 et le dernier increment "
<< "\n (4) type par intervalle d'increment + le dernier increment "
<< "\n (5) type par intervalle de temps + le dernier increment \n"
;
string type_de_cas_de_sauvegarde;
type_de_cas_de_sauvegarde= lect_chaine();
cout << " valeur lue :" << type_de_cas_de_sauvegarde;
if (type_de_cas_de_sauvegarde == "1") {cas_de_sauvegarde=1;tab_modif(numa)=true;bonne_lecture=true;break;}
else if (type_de_cas_de_sauvegarde == "2") {cas_de_sauvegarde=2;tab_modif(numa)=true;bonne_lecture=true;break;}
else if (type_de_cas_de_sauvegarde == "3") {cas_de_sauvegarde=3;tab_modif(numa)=true;bonne_lecture=true;break;}
else if (type_de_cas_de_sauvegarde == "4") {cas_de_sauvegarde=4;tab_modif(numa)=true;bonne_lecture=true;break;}
else if (type_de_cas_de_sauvegarde == "5") {cas_de_sauvegarde=5;tab_modif(numa)=true;bonne_lecture=true;break;}
else {cout << "\n valeur lue erronee, on concerve la valeur "<< cas_de_sauvegarde;};
}
case 1:
{ cout << "\n nouvelle valeur (un entier ou un reel selon de type d'intervalle) (defaut 1) ? ";
string_inter= lect_return_defaut(false,"1");
cout << " valeur lue ="<<string_inter;
// on test si c'est numérique
if (isNumeric( string_inter.c_str(), 10))
{ val_double = ChangeReel(string_inter);bonne_lecture=true;}
else
{ cout << " *** erreur: valeur non numerique !! ";};
break;
}
case 8: case 17: case 18: case 26:
{ cout << "\n nouvelle valeur (un entier) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est numérique
if (isNumeric( string_inter.c_str(), 10))
{ val_int = ChangeEntier(string_inter);bonne_lecture=true;}
else
{ cout << " *** erreur: valeur non numerique !! ";};
break;
}
case 4: case 5: case 9: case 10: case 14: case 15: case 16: case 19: case 24: case 25:
{ cout << "\n nouvelle valeur (un reel) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est numérique
if (isNumeric( string_inter.c_str(), 10))
{ val_double = ChangeReel(string_inter);bonne_lecture=true;}
else
{ cout << " *** erreur: valeur non numerique !! ";};
break;
}
case 3: case 6: case 7: case 12: case 13: case 20: case 21: case 22:
{ cout << "\n nouvelle valeur (un entier 1(=true) ou 0(=false) ) ? ";
val_bool= (bool) lect_double();cout << " valeur lue ="<< val_bool;
bonne_lecture=true;
break;
}
case 11:
{ cout << "\n nouvelle valeur (un nom) ? ";
int nb_string = 14;
Tableau <string > tab_norme(nb_string);
tab_norme(1) = "Residu/Reaction_et_Residu";
tab_norme(2) = "Residu/Reaction";
tab_norme(3) = "Residu/PVExterne";
tab_norme(4) = "Residu/PVInterne";
tab_norme(5) = "Residu/maxPVI";
tab_norme(6) = "Residu";
tab_norme(7) = "min(Res,Res/Reaction)";
tab_norme(8) = "min(Res,Res/MaX(Reaction_et_PVExterne))";
tab_norme(9) = "E_cinetique/E_statique_ET_ResSurReact";
tab_norme(10) = "E_cinetique/E_statique_ET_Res/Reac_et_Fext";
tab_norme(11) = "E_cinetique";
tab_norme(12) = "Bilan_puissance/Max(puiss)";
tab_norme(13) = "Residu/Reaction_et_Residu";
tab_norme(14) = "fonction_nD: <un nom de fonction nD> ";
int nb_car_maxi=0; // init
// on recherche le nombre de caractères maxi
for (int i=1;i<nb_string+1;i++)
nb_car_maxi = MaX(nb_car_maxi, tab_norme(i).length());
// on affiche le menu
for (int i=1;i<nb_string+1;i++)
cout <<"\n "<< setw(nb_car_maxi) << left << tab_norme(i) <<" ("<<i<<")";
cout << "\n ? ";
val_string= lect_chaine();cout << " valeur lue ="<< val_string;
int num_choix = ChangeEntier(val_string);
if ((num_choix == 0) || (Minuscules(val_string) == "f"))
break;
if ((num_choix > 0)&&(num_choix < nb_string+1))
{ cout << " norme enregistree: " << tab_norme(num_choix);
norme.nom1 = tab_norme(num_choix);tab_modif(numa)=true;
bonne_lecture=true;break;
}
else { cout << "\n type incorrect on conserve: " << norme ;};
if (norme.nom1 == "fonction_nD:") // on doit demander le nom de la fonction nD
{cout << " nom de la fonction nD ? ";
norme.nom2= lect_chaine();cout << " valeur lue ="<< norme.nom2;
};
break;
}
case 23:
{ if (norme.nom1 == "fonction_nD:") // si on a déjà enregisté une fonction nD
// la suite n'est pas possible
{cout << "\n cas d'une norme controlee par une fonction nD, on ne peut pas rajouter d'indication! ";
}
else
{cout << "\n un nom au choix parmi: et_miniVarDdl et_VarRes et_maxiVarDdl ou un blanc ? ";
int nb_string = 3;
Tableau <string > tab_norme(nb_string);
tab_norme(1) = "et_miniVarDdl";
tab_norme(2) = "et_VarRes";
tab_norme(3) = "et_maxiVarDdl";
int nb_car_maxi=0; // init
// on recherche le nombre de caractères maxi
for (int i=1;i<nb_string+1;i++)
nb_car_maxi = MaX(nb_car_maxi, tab_norme(i).length());
// on affiche le menu
for (int i=1;i<nb_string+1;i++)
cout <<"\n "<< setw(nb_car_maxi) << left << tab_norme(i) <<" ("<<i<<")";
cout << "\n ? ";
val_string= lect_chaine();cout << " valeur lue ="<< val_string;
int num_choix = ChangeEntier(val_string);
if ((num_choix == 0) || (Minuscules(val_string) == "f"))
break;
if ((num_choix > 0)&&(num_choix < nb_string+1))
{ norme.nom1 += val_string;tab_modif(numa)=true;
cout << " norme enregistree: " << norme;
bonne_lecture=true;
break;
}
else { cout << "\n type incorrect on conserve: " << norme ;};
};
break;
}
};
if (bonne_lecture)
switch (numa)
{ case 0: // préparation de sortie
{ break;} // normalement cela a déjà été filtré avant
case 1: { sauvegarde = val_double;tab_modif(numa)=true;break;}
case 3: { force_deltat = val_bool;tab_modif(numa)=true;break;}
case 4: { coef_pas_critique_deltatmaxi = val_double;tab_modif(numa)=true;break;}
case 5: { coef_pas_critique_deltatmini = val_double;tab_modif(numa)=true;break;}
case 6: { typeDFC_pas_critique_deltatmaxi = val_bool;tab_modif(numa)=true;break;}
case 7: { typeDFC_pas_critique_deltatmini = val_bool;tab_modif(numa)=true;break;}
case 8: { iterations = val_int;tab_modif(numa)=true;break;}
case 9: { precision = val_double;tab_modif(numa)=true;break;}
case 10: { tempo_specifique_algo.prectemps = val_double;tab_modif(numa)=true;break;}
case 12: { cinematique = val_bool;tab_modif(numa)=true;break;}
case 13: { conv_forcee = val_bool;tab_modif(numa)=true;break;}
case 14: { multiplicateur = val_double;tab_modif(numa)=true;break;}
case 15: { tempo_specifique_algo.deltat = val_double;tab_modif(numa)=true;break;}
case 16: { tempo_specifique_algo.tempsfin = val_double;tab_modif(numa)=true;break;}
case 17: { maxincre = val_int;tab_modif(numa)=true;break;}
case 18: { restart = val_int;tab_modif(numa)=true;break;}
case 19: { max_puissance = val_double;tab_modif(numa)=true;break;}
case 20: { line_search = val_bool;tab_modif(numa)=true;break;}
case 21: { var_charge_externe = val_bool;tab_modif(numa)=true;break;}
case 22: { var_D = val_bool;tab_modif(numa)=true;break;}
case 24: { tempo_specifique_algo.deltatmaxi = val_double;tab_modif(numa)=true;break;}
case 25: { tempo_specifique_algo.deltatmini = val_double;tab_modif(numa)=true;break;}
case 26: { max_essai_incre = val_int;tab_modif(numa)=true;break;}
};
}
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 interne
// écriture des paramètres de contrôle
for (int i=1;i<=26;i++)
if (tab_modif(i))
{switch (i)
{ case 1: { sort << "\n SAUVEGARDE ";
switch (cas_de_sauvegarde)
{case 2: sort << " INTER_TEMPS " << sauvegarde ;break;
case 3: sort << " DERNIER_CALCUL ";break;
case 4: sort << " INTER_INCREMENT " << sauvegarde << " DERNIER_CALCUL ";break;
case 5: sort << " INTER_TEMPS " << sauvegarde << " DERNIER_CALCUL ";break;
default: sort << sauvegarde;
};
break;}
case 3: { sort << "\n FORCE_DELTAT_DU_.INFO "<< force_deltat;break;}
case 8: { sort << "\n ITERATIONS " << iterations ;break;}
case 9: { sort << "\n PRECISION "<< precision ;break;}
case 10: { sort << "\n PRECTEMPS " << tempo_specifique_algo.prectemps;break;}
case 11: { sort << "\n NORME " << norme;break;}
case 12: { sort << "\n CINEMATIQUE " << cinematique;break;}
case 13: { sort << "\n CONV_FORCEE " << conv_forcee;break;}
case 14: { sort << "\n MULTIPLICATEUR " << multiplicateur;break;}
case 15: { sort << "\n DELTAt " << tempo_specifique_algo.deltat;break;}
case 16: { sort << "\n TEMPSFIN " << tempo_specifique_algo.tempsfin;break;}
case 17: { sort << "\n MAXINCRE " << maxincre ;break;}
case 18: { sort << "\n RESTART " << restart;break;}
case 19: { sort << "\n MAX_PUISSANCE " << max_puissance;break;}
case 20: { sort << "\n LINE_SEARCH " << line_search;break;}
case 21: { sort << "\n VARIATION_CHARGE_EXTERNE_SUR_RAIDEUR " << var_charge_externe;break;}
case 22: { sort << "\n VARIATION_VITESSE_DEFORMATION_SUR_RAIDEUR " << var_D;break;}
case 24: { sort << "\n DELTAtMAXI " << tempo_specifique_algo.deltatmaxi;break;}
case 25: { sort << "\n DELTAtMINI " << tempo_specifique_algo.deltatmini;break;}
case 26: { sort << "\n MAX_ESSAI_INCRE " << max_essai_incre ;break;}
};
};
// cas du pas de temps maxi
if (tab_modif(4) || tab_modif(6)) // ou car si l'on change un des deux cela veut dire un facteur du coef critique
{if (typeDFC_pas_critique_deltatmaxi)
{sort << "\n DELTAtMAXI COEF_PASCRITIQUE_DFC "<< coef_pas_critique_deltatmaxi ;}
else
{sort << "\n DELTAtMAXI COEF_PASCRITIQUE "<< coef_pas_critique_deltatmaxi ;};
};
if (tab_modif(5) || tab_modif(7))
{if (typeDFC_pas_critique_deltatmini)
{sort << "\n DELTAtMINI COEF_PASCRITIQUE_DFC "<< coef_pas_critique_deltatmini ;}
else
{sort << "\n DELTAtMINI COEF_PASCRITIQUE "<< coef_pas_critique_deltatmini ;};
};
break;
}
case 2: // parametres lies au systeme d'equation lineaire
{ sort << "\n\n para_syteme_lineaire #------------ "
<< "\n#--------------------------- "
<< "\n# PARAMETRE | VALEUR | "
<< "\n#--------------------------- ";
int nb_item = 8; // nombre d'item du menu
Tableau<bool> tab_modif(nb_item,false); // indique qu'est-ce qui a été modifié
//On va proposer un menu
string repa=" ";
cout << "\n --- parametre de la resolution du systeme lineaire global ------ ";
while ((Minuscules(repa) != "f")&&(Minuscules(repa) != "0"))
{try
{ cout << "\n (0 ou f) (fin) "
<< "\n --- parametres de controle et para par defaut "
<< "\n [c] -> para tres classique [-] para assez courants "
<< "\n (1) TYPE_MATRICE = BANDE_SYMETRIQUE "
<< "\n (2) SYMETRIE_MATRICE = 1 "
<< "\n (3) TYPE_RESOLUTION = CHOLESKY "
<< "\n (4) TYPE_PRECONDITIONNEMENT = DIAGONAL "
<< "\n (5) NB_ITER_NONDIRECTE = 30"
<< "\n (6) TOLERANCE = 1.e-7 "
<< "\n (7) NB_VECT_RESTART = 32 "
<< "\n (8) OPTIMISATION_POINTEURS_ASSEMBLAGE = 0 [-] "
<< "\n NB: pour les matrices secondaires: voir doc. \n";
repa = lect_return_defaut(false,"f");
if ((Minuscules(repa) == "f") || (Minuscules(repa) == "0"))// sortie directe
break;
int numa = ChangeEntier(repa);
if (!((numa >= 0)&&(numa<=nb_item)))
{ cout << "\n Erreur on attendait un entier entre 0 et "<<nb_item<<" !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour arreter le programme";
};
int val_int;
bool val_bool;
double val_double;
string val_string,string_inter;
bool bonne_lecture = false;
switch (numa)
{ case 0: // sortie
{ break;} // normalement cela a déjà été filtré avant
case 1:
{ cout << "\n nouveau type de matrice (un nom cf. doc ) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est recevable
if (Existe_Enum_matrice(string_inter))
{ val_string = string_inter;bonne_lecture=true;}
else
{ cout << " *** erreur: ce type de matrice n'est pas correcte !! ";};
break;
}
case 2:
{ cout << "\n symetrie de la matrice (1 ou 0 ) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est recevable
if (isNumeric( string_inter.c_str(), 10))
{ int essai = ChangeEntier(string_inter);
if ((essai == 1) || (essai == 0))
{val_int = essai;bonne_lecture=true;}
else
{ cout << " ** erreur il faut 1 ou 0 ! "; };
}
else
{ cout << " *** erreur: valeur non numerique !! ";};
break;
}
case 3:
{ cout << "\n type de resolution (un nom cf. doc ) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est recevable
if (Existe_Enum_type_resolution_matri(string_inter))
{ val_string = string_inter;bonne_lecture=true;}
else
{ cout << " *** erreur: ce type de resolution n'est pas correcte !! ";};
break;
}
case 4:
{ cout << "\n type de preconditionnement (un nom cf. doc ) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est recevable
if (Existe_Enum_preconditionnement(string_inter))
{ val_string = string_inter;bonne_lecture=true;}
else
{ cout << " *** erreur: ce type de preconditionnement n'est pas correcte !! ";};
break;
}
case 5:
{ cout << "\n nb iteration pour un methode iterative (un entier) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est recevable
if (isNumeric( string_inter.c_str(), 10))
{ val_int = ChangeEntier(string_inter);bonne_lecture=true;}
else
{ cout << " *** erreur: valeur non numerique !! ";};
break;
}
case 6:
{ cout << "\n precision de convergence pour un methode iterative (un reel) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est recevable
if (isNumeric( string_inter.c_str(), 10))
{ val_double = ChangeReel(string_inter);bonne_lecture=true;}
else
{ cout << " *** erreur: valeur non numerique !! ";};
break;
}
case 7:
{ cout << "\n nb vecteurs sauvegarde pour un methode iterative (un entier) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est recevable
if (isNumeric( string_inter.c_str(), 10))
{ val_int = ChangeEntier(string_inter);bonne_lecture=true;}
else
{ cout << " *** erreur: valeur non numerique !! ";};
break;
}
case 8:
{ cout << "\n optimisation des pointeurs d'assemblage (1 ou 0) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est recevable
if (isNumeric( string_inter.c_str(), 10))
{ val_int = ChangeEntier(string_inter);bonne_lecture=true;}
else
{ cout << " *** erreur: valeur non numerique !! ";};
break;
}
};
if (bonne_lecture)
switch (numa)
{ case 0: // préparation de sortie
{ break;} // normalement cela a déjà été filtré avant
case 1: { type_matrice = Id_nom_matrice(val_string);tab_modif(numa)=true;break;}
case 2: { symetrie_matrice = val_int;tab_modif(numa)=true;break;}
case 3: { type_resolution = Id_nom_resolution(val_string);tab_modif(numa)=true;break;}
case 4: { type_preconditionnement = Id_nom_preconditionnement(val_string);tab_modif(numa)=true;break;}
case 5: { nb_iter_nondirecte = val_int;tab_modif(numa)=true;break;}
case 6: { tolerance = val_double;tab_modif(numa)=true;break;}
case 7: { nb_vect_restart = val_int;tab_modif(numa)=true;break;}
case 8: { opti_pointeur_assemblage = val_int;tab_modif(numa)=true;break;}
};
}
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 interne
// écriture des paramètres de contrôle
for (int i=1;i<=nb_item;i++)
if (tab_modif(i))
{switch (i)
{ case 1: { sort << "\n TYPE_MATRICE " << Nom_matrice(type_matrice);break;}
case 2: { sort << "\n SYMETRIE_MATRICE " << symetrie_matrice;break;}
case 3: { sort << "\n TYPE_RESOLUTION "<< Nom_resolution(type_resolution);break;}
case 4: { sort << "\n TYPE_PRECONDITIONNEMENT " << Nom_preconditionnement(type_preconditionnement) ;break;}
case 5: { sort << "\n NB_ITER_NONDIRECTE "<< nb_iter_nondirecte ;break;}
case 6: { sort << "\n TOLERANCE " << tolerance;break;}
case 7: { sort << "\n NB_VECT_RESTART " << nb_vect_restart;break;}
case 8: { sort << "\n OPTIMISATION_POINTEURS_ASSEMBLAGE " << opti_pointeur_assemblage;break;}
};
};
break;
}
case 3: // parametres lies à la dynamique
{ break;
}
case 4: // parametres lies à l'affichage des resultats
{ sort << "\n\n para_affichage #------------ "
<< "\n#--------------------------- "
<< "\n# PARAMETRE | VALEUR | "
<< "\n#--------------------------- ";
int nb_choix = 7; // nombre de choix
Tableau<bool> tab_modif(nb_choix,false); // indique qu'est-ce qui a été modifié
//On va proposer un menu
string repa=" ";
cout << "\n --- affichage ------ ";
while ((Minuscules(repa) != "f")&&(Minuscules(repa) != "0"))
{try
{ cout << "\n (0 ou f) (fin) "
<< "\n --- parametres de controle de l'algorithmes et para par defaut "
<< "\n [c] -> para tres classique [-] para assez courants "
<< "\n (1) frequence d'affichage sur les increment = 1 [-]"
<< "\n (FREQUENCE_AFFICHAGE_INCREMENT) "
<< "\n (2) frequence d'affichage sur les iteration = 1 [-]"
<< "\n (FREQUENCE_AFFICHAGE_ITERATION) "
<< "\n (3) frequence de la sortie au fil du calcul = -1000000 [c]"
<< "\n (FREQUENCE_SORTIE_FIL_DU_CALCUL) "
<< "\n (4) cas de_sortie_fil_calcul"
<< "\n (FREQUENCE_AFFICHAGE_INCREMENT) "
<< "\n (5) NB chiffre significatifs pour archive et ecran = 17 "
<< "\n (NB_CHIFFRE_POUR_DOUBLE_CALCUL) "
<< "\n (6) NB chiffre significatifs pour graphique = 12 "
<< "\n (NB_CHIFFRE_POUR_DOUBLE_GRAPHIQUE) "
<< "\n (7) NB chiffre significatifs pour ecran = 8 "
<< "\n (NB_CHIFFRE_POUR_DOUBLE_ECRAN) "
<< "\n ";
repa = lect_return_defaut(false,"f");
if ((Minuscules(repa) == "f") || (Minuscules(repa) == "0"))// sortie directe
break;
int numa = ChangeEntier(repa);
if (!((numa >= 0)&&(numa<=nb_choix)))
{ cout << "\n Erreur on attendait un entier entre 0 et "<<nb_choix<<" !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour arreter le programme";
};
int val_int;
bool val_bool;
double val_double;
string val_string,string_inter;
switch (numa)
{ case 0: // sortie
{ break;} // normalement cela a déjà été filtré avant
case 4:
{ cout << "\n (1) type par intervalle d'increment "
<< "\n (2) type par intervalle de temps "
<< "\n (3) uniquement le dernier increment \n";
string type_de_cas_de_sortie_fil_calcul;
type_de_cas_de_sortie_fil_calcul= lect_chaine();
cout << " valeur lue :" << type_de_cas_de_sortie_fil_calcul;
if (type_de_cas_de_sortie_fil_calcul == "1")
{cas_de_sortie_fil_calcul=1;tab_modif(numa)=true;break;}
else if (type_de_cas_de_sortie_fil_calcul == "2")
{cas_de_sortie_fil_calcul=2;tab_modif(numa)=true;break;}
else if (type_de_cas_de_sortie_fil_calcul == "3")
{cas_de_sortie_fil_calcul=3;tab_modif(numa)=true;break;}
else
{cout << "\n valeur lue erronee, on concerve la valeur "<< cas_de_sortie_fil_calcul;};
}
case 1: case 2: case 5: case 6: case 7:
{ cout << "\n nouvelle valeur (un entier) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est numérique
if (isNumeric( string_inter.c_str(), 10))
{ val_int = ChangeEntier(string_inter);}
else
{ cout << " erreur: valeur non numerique !! ";};
break;
}
case 3:
{ cout << "\n nouvelle valeur (un reel) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est numérique
if (isNumeric( string_inter.c_str(), 10))
{ val_double = ChangeReel(string_inter);}
else
{ cout << " *** erreur: valeur non numerique !! ";};
break;
}
};
switch (numa)
{ case 0: // préparation de sortie
{ break;} // normalement cela a déjà été filtré avant
case 1: { frequence_affichage_increment = val_int;tab_modif(numa)=true;break;}
case 2: { frequence_affichage_iteration = val_int;tab_modif(numa)=true;break;}
case 3: { sortie_fil_calcul = val_double;tab_modif(numa)=true;break;}
case 5: { nb_diggit_double_calcul = val_int;tab_modif(numa)=true;break;}
case 6: { nb_diggit_double_graphique = val_int;tab_modif(numa)=true;break;}
case 7: { nb_diggit_double_ecran = val_int;tab_modif(numa)=true;break;}
};
// écriture
}
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 interne
// écriture des paramètres de contrôle
for (int i=1;i<=nb_choix;i++)
if (tab_modif(i))
{switch (i)
{ case 3: case 4 :
{ sort << "\n FREQUENCE_SORTIE_FIL_DU_CALCUL ";
switch (cas_de_sortie_fil_calcul)
{case 2: sort << " INTER_TEMPS " << sortie_fil_calcul ;break;
case 3: sort << " DERNIER_CALCUL ";break;
default: sort << sortie_fil_calcul;
};
break;
}
case 1: { sort << "\n FREQUENCE_AFFICHAGE_INCREMENT "<< frequence_affichage_increment;break;}
case 2: { sort << "\n FREQUENCE_AFFICHAGE_ITERATION " << frequence_affichage_iteration ;break;}
case 5: { sort << "\n NB_CHIFFRE_POUR_DOUBLE_CALCUL "<< nb_diggit_double_calcul ;break;}
case 6: { sort << "\n NB_CHIFFRE_POUR_DOUBLE_GRAPHIQUE " << nb_diggit_double_graphique;break;}
case 7: { sort << "\n NB_CHIFFRE_POUR_DOUBLE_ECRAN " << nb_diggit_double_ecran;break;}
};
};
break;
}
case 5: // parametres lies au contact
{ sort << "\n\n para_contact #------------ "
<< "\n#--------------------------- "
<< "\n# PARAMETRE | VALEUR | "
<< "\n#--------------------------- ";
Tableau<bool> tab_modif(33,false); // indique qu'est-ce qui a été modifié
//On va proposer un menu
string repa=" ";
cout << "\n --- controle generaux ------ ";
while ((Minuscules(repa) != "f")&&(Minuscules(repa) != "0"))
{try
{ cout << "\n (0 ou f) (fin) "
<< "\n --- parametres de controle du contact "
<< "\n [c] -> para tres classique [-] para assez courants "
<< "\n (1) PRECISION_POINT_INTERNE_DEBUT = 1.e-6 "
<< "\n (2) FACT_POUR_RAYON_ACCOSTAGE = 1. "
<< "\n (3) DISTANCE_MAXI_AU_PT_PROJETE = tres grand "
<< "\n (4) PRECISION_BOITE_PRELOCALISATION = 1.05 "
<< "\n (5) MINI_EXTRA_BOITE_PRELOCALISATION = -0.001 "
<< "\n (6) CONTACT_TYPE = 0 "
<< "\n (7) PENALISATION_PENETRATION = 0.1 "
<< "\n (8) TYPE_PENALISATION_PENETRATION = 2 "
<< "\n (9) PENETRATION_CONTACT_MAXI = 0.1 "
<< "\n (10) PENETRATION_BORNE_REGULARISATION = tres grand "
<< "\n (11) FORCE_CONTACT_NOEUD_MAXI = tres grand "
<< "\n (12) PENALISATION_TANGENTIELLE = 1.e6 "
<< "\n (13) PRECISION_PT_SUR_FRONTIERE = 1.e-4 "
<< "\n (14) NB_BOUCLE_NEWTON_SUR_POSITION_FRONTIERE = 10 "
<< "\n (15) NB_DECOLLEMENT_MAXI = 1 "
<< "\n (16) TYPE_DE_DECOLLEMENT = 0 "
<< "\n (17) NB_MOY_GLISSANT = 1 "
<< "\n (18) NIVEAU_COMMENTAIRE_CONTACT = 0 "
<< "\n (19) TYPE_PENALISATION_TANGENTIELLE = 2 "
<< "\n (20) TANGENTIELLE_CONTACT_MAXI = 0.1 "
<< "\n (21) TANGENTIELLE_BORNE_REGULARISATION = tres grand "
<< "\n (22) FORCE_TANGENTIELLE_NOEUD_MAXI = tres grand "
<< "\n (23) AJOUT_EXTRA_BOITE_PRELOCALISATION = 0. "
<< "\n (24) OPTIMISATION_NUMEROTATION = 0 "
<< "\n (25) FCT_ND_BASCUL_CONTACT_TYPE_4 = '_' "
<< "\n (26) FCT_ND_PENALISATION_PENETRATION "
<< "\n (27) FCT_ND_PENETRATION_CONTACT_MAXI "
<< "\n (28) FCT_ND_PENETRATION_BORNE_REGULARISATION "
<< "\n (29) FCT_ND_FORCE_CONTACT_NOEUD_MAXI "
<< "\n (30) FCT_ND_PENALISATION_TANGENTIELLE "
<< "\n (31) FCT_ND_TANGENTIELLE_CONTACT_MAXI "
<< "\n (32) FCT_ND_TANGENTIELLE_BORNE_REGULARISATION "
<< "\n (33) FCT_ND_FORCE_TANGENTIELLE_NOEUD_MAXI "
<< "\n (34 ou h ou ? ) informations "
<< "\n ";
repa = lect_return_defaut(false,"f");
if ((Minuscules(repa) == "f") || (Minuscules(repa) == "0"))// sortie directe
break;
int numa = ChangeEntier(repa);
if (repa == "?") numa = 34;
if (!((numa >= 0)&&(numa<=34)))
{ cout << "\n Erreur on attendait un entier entre 0 et 34 !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour arreter le programme";
};
int val_int;
bool val_bool;
double val_double;
string val_string,string_inter;
switch (numa)
{ case 0: // sortie
{ break;} // normalement cela a déjà été filtré avant
case 6: case 8: case 14: case 15: case 16: case 17: case 18: case 19: case 24:
{ cout << "\n nouvelle valeur (un entier ) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est numérique
if (isNumeric( string_inter.c_str(), 10))
{ val_int = ChangeEntier(string_inter);}
else
{ cout << " *** erreur: valeur non numerique !! ";};
break;
}
case 1: case 2: case 3: case 4: case 5: case 23: case 7: case 9: case 10: case 11:
case 12: case 13: case 20: case 21: case 22:
{ cout << "\n nouvelle valeur (un reel) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est numérique
if (isNumeric( string_inter.c_str(), 10))
{ val_double = ChangeReel(string_inter);}
else
{ cout << " *** erreur: valeur non numerique !! ";};
break;
}
case 25:
{ cout << "\n donner le nom de la fonction nD (un string ) ? ";
val_string= lect_chaine();cout << " nom lue ="<<val_string;
break;
}
case 34:
{ cout << "\n PRECISION_POINT_INTERNE_DEBUT: precision du test: point interieur ?, "
<< " avant le debut des calculs "
<< "\n FACT_POUR_RAYON_ACCOSTAGE: facteur multiplicatif du deplacement maxi entre t et tdt"
<< " donnant la distance maxi admissible entre le point et le point projete "
<< "\n DISTANCE_MAXI_AU_PT_PROJETE: a priori grand, est ensuite eventuellement "
<< " gere par l'entree des donnees"
<< "\n PRECISION_BOITE_PRELOCALISATION: donne la proportion de plus qui est "
<< " attribuee aux boites de prelocalisation "
<< "\n MINI_EXTRA_BOITE_PRELOCALISATION: permet le calcul de la bande mini autour de la boite de prelocalisation "
<< "\n AJOUT_EXTRA_BOITE_PRELOCALISATION: ajout dans toutes les directions autour de la boite de prelocalisation "
<< "\n CONTACT_TYPE: a priori il n'y a pas de contact d'element "
<< "\n PENALISATION_PENETRATION: facteur pour le calcul du coefficient de penalisation "
<< "\n TYPE_PENALISATION_PENETRATION: par defaut le calcul est identique a ls-dyna avec "
<< " la compressibilite du maitre "
<< "\n PENETRATION_CONTACT_MAXI: cf doc "
<< "\n PENETRATION_BORNE_REGULARISATION: cf doc "
<< "\n FORCE_CONTACT_NOEUD_MAXI: borne maxi pour la force de reaction du noeud "
<< "\n PENALISATION_TANGENTIELLE: facteur de penalisation pour le deplacement tangentiel "
<< "\n PRECISION_PT_SUR_FRONTIERE: precision de positionnement sur les X^ar d'un pt "
<< " en contact sur une frontiere "
<< "\n NB_BOUCLE_NEWTON_SUR_POSITION_FRONTIERE: nb de boucle maxi pour la recherche du "
<< " positionnement du pt en contact "
<< "\n NB_DECOLLEMENT_MAXI: nb de fois qu'un noeud decolle pour n'etre plus considere en contact "
<< "\n TYPE_DE_DECOLLEMENT: cf doc "
<< "\n NB_MOY_GLISSANT: nb de pt utilise pour la moyenne glissante cf doc "
<< "\n NIVEAU_COMMENTAIRE_CONTACT: si sup au niveau global, gere les sorties de commentaires "
<< "\n pour la penalisation sur le deplacement tangentiel, meme logique que la "
<< "\n penalisation en penetration "
<< "\n OPTIMISATION_NUMEROTATION : si diff de 0, indique une renumerotation en fct"
<< "\n du contact, en particulier apres l'apparition ou la disparition "
<< "\n d'element de contact"
<< "\n FCT_ND_BASCUL_CONTACT_TYPE_4: nom d'une fonction nD permettant de piloter "
<< "\n le basculement du type de contact 4 a 2 (cf. doc) "
<< endl;
break;
}
default:
cout << "\n cas non prevu, recommencer ! ";
};
switch (numa)
{ case 0: // préparation de sortie
{ break;} // normalement cela a déjà été filtré avant
case 1: { prec_pt_int_deb = val_double;tab_modif(numa)=true;break;}
case 2: { factPourRayonAccostage = val_double;tab_modif(numa)=true;break;}
case 3: { distanceMaxiAuPtProjete = val_double;tab_modif(numa)=true;break;}
case 4: { extra_boite_prelocalisation = val_double;tab_modif(numa)=true;break;}
case 5: { mini_extra_boite_prelocalisation = val_double;tab_modif(numa)=true;break;}
case 6: { contact_type = val_int;tab_modif(numa)=true;break;}
case 7: { penalisationPenetration = val_double;tab_modif(numa)=true;break;}
case 8: { typePenalisationPenetration = val_int;tab_modif(numa)=true;break;}
case 9: { penetration_contact_maxi = val_double;tab_modif(numa)=true;break;}
case 10: { penetration_borne_regularisation = val_double;tab_modif(numa)=true;break;}
case 11: { force_contact_noeud_maxi = val_double;tab_modif(numa)=true;break;}
case 12: { penalisationTangentielle = val_double;tab_modif(numa)=true;break;}
case 13: { prec_pt_sur_frontiere = val_double;tab_modif(numa)=true;break;}
case 14: { nb_boucle_newton_position_frontiere = val_int;tab_modif(numa)=true;break;}
case 15: { nbDecolAutorise = val_int;tab_modif(numa)=true;break;}
case 16: { typeDeDecolement = val_int;tab_modif(numa)=true;break;}
case 17: { nb_glissant = val_int;tab_modif(numa)=true;break;}
case 18: { niveau_commentaire_contact = val_int;tab_modif(numa)=true;break;}
case 19: { typePenalisationTangentielle = val_int;tab_modif(numa)=true;break;}
case 20: { tangentielle_contact_maxi = val_double;tab_modif(numa)=true;break;}
case 21: { tangentielle_borne_regularisation = val_double;tab_modif(numa)=true;break;}
case 22: { force_tangentielle_noeud_maxi = val_double;tab_modif(numa)=true;break;}
case 23: { ajout_extra_boite_prelocalisation = val_double;tab_modif(numa)=true;break;}
case 24: { optimisation_numerotation = val_int;tab_modif(numa)=true;break;}
case 25: { fct_nD_bascul_contact_type_4 = val_string;tab_modif(numa)=true;break;}
case 26: { fct_nD_penalisationPenetration = val_string;tab_modif(numa)=true;break;}
case 27: { fct_nD_penetration_contact_maxi = val_string;tab_modif(numa)=true;break;}
case 28: { fct_nD_penetration_borne_regularisation = val_string;tab_modif(numa)=true;break;}
case 29: { fct_nD_force_contact_noeud_maxi = val_string;tab_modif(numa)=true;break;}
case 30: { fct_nD_penalisationTangentielle = val_string;tab_modif(numa)=true;break;}
case 31: { fct_nD_tangentielle_contact_maxi = val_string;tab_modif(numa)=true;break;}
case 32: { fct_nD_tangentielle_borne_regularisation = val_string;tab_modif(numa)=true;break;}
case 33: { fct_nD_force_tangentielle_noeud_maxi = val_string;tab_modif(numa)=true;break;}
default: break;
};
// écriture
}
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 interne
// écriture des paramètres de contrôle
for (int i=1;i<=17;i++)
if (tab_modif(i))
{switch (i)
{ case 1: { sort << "\n PRECISION_POINT_INTERNE_DEBUT "<< prec_pt_int_deb;break;}
case 2: { sort << "\n FACT_POUR_RAYON_ACCOSTAGE "<< factPourRayonAccostage;break;}
case 3: { sort << "\n DISTANCE_MAXI_AU_PT_PROJETE "<< distanceMaxiAuPtProjete;break;}
case 4: { sort << "\n PRECISION_BOITE_PRELOCALISATION " << extra_boite_prelocalisation ;break;}
case 5: { sort << "\n MINI_EXTRA_BOITE_PRELOCALISATION "<< mini_extra_boite_prelocalisation ;break;}
case 6: { sort << "\n CONTACT_TYPE " << contact_type;break;}
case 7: { sort << "\n PENALISATION_PENETRATION " << penalisationPenetration;break;}
case 8: { sort << "\n TYPE_PENALISATION_PENETRATION " << typePenalisationPenetration;break;}
case 9: { sort << "\n PENETRATION_CONTACT_MAXI " << penetration_contact_maxi;break;}
case 10: { sort << "\n PENETRATION_BORNE_REGULARISATION " << penetration_borne_regularisation;break;}
case 11: { sort << "\n FORCE_CONTACT_NOEUD_MAXI " << force_contact_noeud_maxi;break;}
case 12: { sort << "\n PENALISATION_TANGENTIELLE " << penalisationTangentielle ;break;}
case 13: { sort << "\n PRECISION_PT_SUR_FRONTIERE " << prec_pt_sur_frontiere;break;}
case 14: { sort << "\n NB_BOUCLE_NEWTON_SUR_POSITION_FRONTIERE " << nb_boucle_newton_position_frontiere;break;}
case 15: { sort << "\n NB_DECOLLEMENT_MAXI " << nbDecolAutorise;break;}
case 16: { sort << "\n TYPE_DE_DECOLLEMENT " << typeDeDecolement;break;}
case 17: { sort << "\n NB_MOY_GLISSANT " << nb_glissant;break;}
case 18: { sort << "\n NIVEAU_COMMENTAIRE_CONTACT " << niveau_commentaire_contact;break;}
case 19: { sort << "\n TYPE_PENALISATION_TANGENTIELLE " << typePenalisationTangentielle;break;}
case 20: { sort << "\n TANGENTIELLE_CONTACT_MAXI " << tangentielle_contact_maxi;break;}
case 21: { sort << "\n TANGENTIELLE_BORNE_REGULARISATION " << tangentielle_borne_regularisation;break;}
case 22: { sort << "\n FORCE_TANGENTIELLE_NOEUD_MAXI " << force_tangentielle_noeud_maxi;break;}
case 23: { sort << "\n AJOUT_EXTRA_BOITE_PRELOCALISATION "<< ajout_extra_boite_prelocalisation ;break;}
case 24: { sort << "\n OPTIMISATION_NUMEROTATION "<< optimisation_numerotation ;break;}
case 25: { sort << "\n FCT_ND_BASCUL_CONTACT_TYPE_4 "<< fct_nD_bascul_contact_type_4 ;break;}
case 26: { sort << "\n PENALISATION_PENETRATION FCT_ND_PENALISATION_PENETRATION "<< fct_nD_penalisationPenetration ;break;}
case 27: { sort << "\n PENETRATION_CONTACT_MAXI FCT_ND_PENETRATION_CONTACT_MAXI "<< fct_nD_penetration_contact_maxi ;break;}
case 28: { sort << "\n PENETRATION_BORNE_REGULARISATION FCT_ND_PENETRATION_BORNE_REGULARISATION "<< fct_nD_penetration_borne_regularisation ;break;}
case 29: { sort << "\n FORCE_CONTACT_NOEUD_MAXI FCT_ND_FORCE_CONTACT_NOEUD_MAXI "<< fct_nD_force_contact_noeud_maxi ;break;}
case 30: { sort << "\n PENALISATION_TANGENTIELLE FCT_ND_PENALISATION_TANGENTIELLE "<< fct_nD_penalisationTangentielle ;break;}
case 31: { sort << "\n TANGENTIELLE_CONTACT_MAXI FCT_ND_TANGENTIELLE_CONTACT_MAXI "<< fct_nD_tangentielle_contact_maxi ;break;}
case 32: { sort << "\n TANGENTIELLE_BORNE_REGULARISATION FCT_ND_TANGENTIELLE_BORNE_REGULARISATION "<< fct_nD_tangentielle_borne_regularisation ;break;}
case 33: { sort << "\n FORCE_TANGENTIELLE_NOEUD_MAXI FCT_ND_FORCE_TANGENTIELLE_NOEUD_MAXI "<< fct_nD_force_tangentielle_noeud_maxi ;break;}
default: break;
};
};
break;
}
case 6: // parametres lies aux energies
{ break;
}
case 7: // parametres lies aux calculs geometriques sur les elements
{ sort << "\n\n para_calculs_geometriques #------------ "
<< "\n#--------------------------- "
<< "\n# PARAMETRE | VALEUR | "
<< "\n#--------------------------- ";
int nb_choix = 7; // nombre de choix
Tableau<bool> tab_modif(nb_choix,false); // indique qu'est-ce qui a été modifié
//On va proposer un menu
string repa=" ";
cout << "\n --- affichage ------ ";
while ((Minuscules(repa) != "f")&&(Minuscules(repa) != "0"))
{try
{ cout << "\n (0 ou f) (fin) "
<< "\n --- parametres lies aux calculs geometriques sur les elements et para par defaut "
<< "\n [c] -> para tres classique [-] para assez courants "
<< "\n (1) precision sur theta_i pour test in/out element = 1.e-4 "
<< "\n (POINT_INTERNE_DELTA_THETAI_MAXI) "
<< "\n (2) precision sur theta_i pour test si in/sur frontiere/out element = 1.e-6 "
<< "\n (POINT_INTERNE_PREC_THETAI_INTERNE) "
<< "\n (3) nb de boucle de Newton pour recherche des theta_i pour surface non lineaire = 10 "
<< "\n (POINT_INTERNE_NB_BOUCLE_SUR_DELTA_THETAI) "
<< "\n (4) nb de fois le pt est externe dans boucle de Newton (3) avant que "
<< "\n declare definitivement externe -> arret boucle : = 3 "
<< "\n (POINT_INTERNE_NB_EXTERNE) "
<< "\n (5) indique si oui non -> calcul des volumes entre la membrane et les plans de ref (= 0) "
<< "\n (CAL_VOL_TOTAL_ENTRE_SURFACE_ET_PLANS_REF) "
<< "\n (6) rapport maxi entre jacobien de la facette centrale et du pti en epaisseur "
<< "\n pour les elements coques = 200. "
<< "\n (RATIO_MAXI_JACOMEMBRANE_JACOPTI) "
<< "\n (7) methode pour inversion du tenseur metrique (CRAMER ou LU_EQUILIBRE) = CRAMER "
<< "\n (TYPE_CALNUM_INVERSION_METRIQUE) "
<< "\n ";
repa = lect_return_defaut(false,"f");
if ((Minuscules(repa) == "f") || (Minuscules(repa) == "0"))// sortie directe
break;
int numa = ChangeEntier(repa);
if (!((numa >= 0)&&(numa<=nb_choix)))
{ cout << "\n Erreur on attendait un entier entre 0 et "<<nb_choix<<" !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour arreter le programme";
};
int val_int;
bool val_bool;
double val_double;
string val_string,string_inter;
bool bonne_lecture = false;
switch (numa)
{ case 0: // sortie
{ break;} // normalement cela a déjà été filtré avant
case 3: case 4:
{ cout << "\n nouvelle valeur (un entier) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est numérique
if (isNumeric( string_inter.c_str(), 10))
{ val_int = ChangeEntier(string_inter);bonne_lecture=true;}
else
{ cout << " erreur: valeur non numerique !! ";};
break;
}
case 1: case 2: case 6:
{ cout << "\n nouvelle valeur (un reel) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est numérique
if (isNumeric( string_inter.c_str(), 10))
{ val_double = ChangeReel(string_inter);bonne_lecture=true;}
else
{ cout << " *** erreur: valeur non numerique !! ";};
break;
}
case 5:
{ cout << "\n calcul des volumes (1 ou 0 ) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est recevable
if (isNumeric( string_inter.c_str(), 10))
{ int essai = ChangeEntier(string_inter);
if ((essai == 1) || (essai == 0))
{val_int = essai;bonne_lecture=true;}
else
{ cout << " ** erreur il faut 1 ou 0 ! "; };
}
else
{ cout << " *** erreur: valeur non numerique !! ";};
break;
}
case 7:
{ cout << "\n methode d'inversion (CRAMER ou LU_EQUILIBRE) ? ";
string_inter= lect_chaine();cout << " valeur lue ="<<string_inter;
// on test si c'est recevable
if (Existe_Enum_type_resolution_matri(val_string))
{ val_string = string_inter;bonne_lecture=true;}
else
{ cout << " *** erreur: ce type n'est pas correcte !! ";};
break;
}
};
switch (numa)
{ case 0: // préparation de sortie
{ break;} // normalement cela a déjà été filtré avant
case 1: { point_interne_delta_thetai_maxi = val_double;tab_modif(numa)=true;break;}
case 2: { point_interne_prec_thetai_interne = val_double;tab_modif(numa)=true;break;}
case 3: { point_interne_nb_boucle_sur_delta_thetai = val_int;tab_modif(numa)=true;break;}
case 4: { point_interne_nb_externe= val_int; tab_modif(numa) = true; break;}
case 5: { cal_vol_total_entre_surface_et_plans_ref = val_int;tab_modif(numa)=true;break;}
case 6: { ratio_maxi_jacoMembrane_jacoPti = val_double;tab_modif(numa)=true;break;}
case 7: { type_calnum_inversion_metrique = Id_nom_resolution(val_string);tab_modif(numa)=true;break;}
};
// écriture
}
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 interne
// écriture des paramètres de contrôle
for (int i=1;i<=nb_choix;i++)
if (tab_modif(i))
{switch (i)
{ case 1: { sort << "\n POINT_INTERNE_DELTA_THETAI_MAXI "<< point_interne_delta_thetai_maxi;break;}
case 2: { sort << "\n POINT_INTERNE_PREC_THETAI_INTERNE " << point_interne_prec_thetai_interne ;break;}
case 3: { sort << "\n POINT_INTERNE_NB_BOUCLE_SUR_DELTA_THETAI " << point_interne_nb_boucle_sur_delta_thetai; break;}
case 4: { sort << "\n POINT_INTERNE_NB_EXTERNE " << point_interne_nb_externe ;break;}
case 5: { sort << "\n CAL_VOL_TOTAL_ENTRE_SURFACE_ET_PLANS_REF "<< cal_vol_total_entre_surface_et_plans_ref ;break;}
case 6: { sort << "\n RATIO_MAXI_JACOMEMBRANE_JACOPTI " << ratio_maxi_jacoMembrane_jacoPti;break;}
case 7: { sort << "\n TYPE_CALNUM_INVERSION_METRIQUE " << type_calnum_inversion_metrique;break;}
};
};
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 << "\n "<<flush;
};
// ramène vraie si le numéro d'increment est nulle modulo la frequence d'affichage d'incrément
// si ce dernier est > 0, sinon =0 modulo la fréquence de sauvegarde si celle-ci est < 0 sinon false
// dans le cas où les sorties s'effectue en fonction du temps, passage du dernier temps de sauvegarde
bool ParaAlgoControle::Vrai_commande_sortie(int icharge,const double& temps_derniere_sauvegarde) const
{ if (frequence_affichage_increment > 0)
{ if ((icharge % frequence_affichage_increment) == 0) return true;}
else if (frequence_affichage_increment < 0)
{ // cas où on se cale sur la sauvegarde
bool dernier_calcul = false; // par défaut on considère que ce n'est pas le dernier calcul
return SauvegardeAutorisee(icharge, temps_derniere_sauvegarde,dernier_calcul);
}
return false;
};
// indique si la sauvegarde est autorisée, en fonction des paramètres données par l'utilisateur et les variables
// passée en argument
// dernier_calcul : indique si c'est le dernier calcul ou pas
bool ParaAlgoControle::SauvegardeAutorisee(int incre,const double& temps_derniere_sauvegarde,bool dernier_calcul) const
{ bool ret=false;
switch (cas_de_sauvegarde)
{ case 1:
{ // cas d'une sauvegarde par numéro d'incrément
if (sauvegarde > 0.) { if ((incre % ((int)sauvegarde)) == 0) ret = true;}
else { return false;}; // cas où sauvegarde == 0
break;
}
case 2:
{ // cas d'une sauvegarde tous les intervals de temps = sauvegarde
if (sauvegarde >0)
{ if ((tempo_specifique_algo.TempsCourant()-temps_derniere_sauvegarde) > sauvegarde) return true;}
else { return false;}; // cas où sauvegarde == 0
break;
}
case 3:
{ // cas d'une sauvegarde uniquement au dernier calcul
if (dernier_calcul)
{ return true;}
else { return false;};
break;
}
case 4:
{ // cas d'une sauvegarde par numéro d'incrément + dernier incrément
if (sauvegarde > 0.) { if (((incre % ((int)sauvegarde)) == 0)|| dernier_calcul) return true;}
else if (dernier_calcul) {return true;}
else { return false;}; // cas où sauvegarde == 0
break;
}
case 5:
{ // cas d'une sauvegarde par numéro d'incrément
if (sauvegarde > 0.) { if (((tempo_specifique_algo.TempsCourant()-temps_derniere_sauvegarde) > sauvegarde)
|| dernier_calcul)
return true;
}
else if (dernier_calcul) {return true;}
else { return false;}; // cas où sauvegarde == 0
break;
}
default:
cout << "\n *** warning ce n'est pas normal, aucun type de sauvegarde n'est definit ! on continue quand meme ! "
<< endl;
if (ParaGlob::NiveauImpression() > 3 )
cout << "\n ParaAlgoControle::SauvegardeAutorisee(... " << endl;
break;
}
return ret; // au cas où
};
// indique si la sauvegarde au fil du calcul est autorisée, en fonction des paramètres données par l'utilisateur et les variables
// passée en argument
bool ParaAlgoControle::SauvegardeFilCalculAutorisee(int incre,const double& temps_derniere_sauvegarde,bool dernier_calcul) const
{ bool ret=false;
if (cas_de_sortie_fil_calcul==1)
{ // cas d'une sauvegarde par numéro d'incrément
if (dernier_calcul)
{ ret = true;} // par défaut le dernier calcul est valide
else if (sortie_fil_calcul > 0.)
{ if ((incre % ((int)sortie_fil_calcul)) == 0)
{ret = true;
//cout << "\n debug ParaAlgoControle::SauvegardeFilCalculAutorisee( "
// << "int sortie_fil_calcul) " << ((int)sortie_fil_calcul)
// << " (incre % ((int)sortie_fil_calcul)) "<< (incre % ((int)sortie_fil_calcul))
// << flush;
};
}
else { ret = false;}; // cas où sortie_fil_calcul == 0
}
else if (cas_de_sortie_fil_calcul == 2)
{ // cas d'une sauvegarde tous les intervals = sauvegarde
if (dernier_calcul) { ret = true;} // par défaut le dernier calcul est valide
else if (sortie_fil_calcul >0)
{ if ((tempo_specifique_algo.TempsCourant()-temps_derniere_sauvegarde) > sortie_fil_calcul) return true;}
else { ret = false;}; // cas où sortie_fil_calcul == 0
}
else if (cas_de_sortie_fil_calcul == 3)
{ // cas d'une sauvegarde uniquement au dernier calcul
if (dernier_calcul)
{ ret = true;}
else { ret = false;};
}
return ret;
};
// modification de l'increment de temps,
// si c'est >= au deltat mini et <= deltat maxi, => retour 0
// modif
// si c'est < au deltat mini ==> retour -1 : pas de modification du deltat
// si c'est > au deltat maxi ==> retour 1 : pas de modification du deltat
/* // si c'est < au deltat mini et que l'on est déjà au temps mini ==> retour -1 : pas de modification du deltat
// si c'est > au deltat maxi et que l'on est déjà au temps maxi ==> retour 1 : pas de modification du deltat
// si c'est > au deltat maxi et que l'on est < au temps maxi ==> retour 3 : pas de modification du deltat
// si c'est < au deltat mini et que l'on est > au temps mini ==> retour 4 : pas de modification du deltat */
int ParaAlgoControle::Modif_Deltat(double nouveau_temps)
{ int retour=0;
// le cas sans pb
if ((tempo_specifique_algo.deltatmini <= nouveau_temps) && (nouveau_temps <= tempo_specifique_algo.deltatmaxi))
{tempo_specifique_algo.deltat = tempo.deltat = nouveau_temps;};
// cas particuliers
if (nouveau_temps > tempo_specifique_algo.deltatmaxi)
{ retour = 1; }; // cas ou on veut un delta t plus grand que le maxi, on ne fait rien
if (nouveau_temps < tempo_specifique_algo.deltatmini)
{ retour = -1; }; // cas ou l'on veut un delta t plus petit que le mini, on ne fait rien
/*
if ((tempo.deltat==tempo.deltatmaxi)&&(nouveau_temps > tempo.deltatmaxi))
// cas ou l'on est déjà au delta t maxi et on veut un delta t encore plus grand, on ne fait rien
{ retour = 1; }
else if ((tempo.deltat==tempo.deltatmini)&&(nouveau_temps < tempo.deltatmini))
// cas ou l'on est déjà au delta t mini et on veut un delta t encore plus petit, on ne fait rien
{ retour = -1; }
else if ((tempo.deltat < tempo.deltatmaxi)&&(nouveau_temps > tempo.deltatmaxi))
// cas où le delta t actuel est plus petit que le maxi, et que l'on veut un delta t plus grand que le maxi
// on ne fait rien
{ retour = 3; //tempo.deltat=tempo.deltatmaxi;
}
else if ((tempo.deltat > tempo.deltatmini)&&(nouveau_temps < tempo.deltatmini))
// cas où le delta t actuel est plus grand que le mini, et que l'on veut un delta t plus petit que le mini
// on ne fait rien
{ retour = 4; //tempo.deltat=tempo.deltatmini;
};
else if ((tempo.deltat < tempo.deltatmaxi)&&(nouveau_temps > tempo.deltatmaxi))
// cas où le delta t actuel est plus petit que le maxi, et que l'on veut un delta t plus grand que le maxi
// on limite le deltat au deltat maxi, mais il y a modification
{ retour = 0; tempo.deltat=tempo.deltatmaxi;}
else if ((tempo.deltat > tempo.deltatmini)&&(nouveau_temps < tempo.deltatmini))
// cas où le delta t actuel est plus grand que le mini, et que l'on veut un delta t plus petit que le mini
// on limite le deltat au deltat mini, mais il y a modification
{ retour = 0; tempo.deltat=tempo.deltatmini;}
;
// if ((nouveau_temps == tempo.deltatmaxi) || (nouveau_temps == tempo.deltatmini))
// { retour = 0; } // on ne change rien
// else if ((nouveau_temps < tempo.deltatmini ) { retour = -1;}
// else if (tempo.deltatmaxi < nouveau_temps ) { retour = 1;}; */
return retour;
};
// modification de l'incrément dans les bornes
// si nouveau_temps < deltat mini ==> nouveau_temps = deltat mini
// si nouveau temps > deltat maxi ==> nouveau_temsp = deltat maxi
// sinon on laisse le delta_t à la valeur qu'il a actuellement
// ramène oui ou non si ça a été modifié
bool ParaAlgoControle::Modif_Detat_dans_borne(double& nouveau_temps)
{ bool modif=false;
if (nouveau_temps < tempo_specifique_algo.deltatmini)
{tempo_specifique_algo.deltat = tempo.deltat = tempo.deltatmini;
nouveau_temps = tempo.deltat;modif=true;
};
if (nouveau_temps > tempo_specifique_algo.deltatmaxi)
{tempo_specifique_algo.deltat = tempo.deltat = tempo.deltatmaxi;
nouveau_temps = tempo.deltat;modif=true;
};
return modif;
};
// mise à jour éventuel du pas de temps et du pas de temps maxi et mini dans le cas où ils sont définit avec des coeff
// d'un pas critique, ramène true s'il y a eu modification du pas de temps courant, false sinon
// temps_critique : temps critique de l'algorithme
// temps_critiqueDFC : temps critique de l'algo DFC = condition de courant
bool ParaAlgoControle::Modif_Deltat_DeltatMaxi(double temps_critique, double temps_critiqueDFC)
{ bool modif=false;
if (coef_pas_critique_deltat!= coef_defaut_pa_critique)
{// cas ou le coef multiplicateur du pas critique a été donné par l'utilisateur c'est-a-dire
// que le deltat voulu est une fraction du deltat critique
if (typeDFC_pas_critique_deltat)
{tempo_specifique_algo.deltat = tempo.deltat
= coef_pas_critique_deltat * temps_critiqueDFC - ConstMath::trespetit; modif = true;}
else {tempo_specifique_algo.deltat = tempo.deltat
= coef_pas_critique_deltat * temps_critique - ConstMath::trespetit; modif = true;}
};
if (coef_pas_critique_deltatmaxi != 0.)
{if (typeDFC_pas_critique_deltatmaxi)
{tempo_specifique_algo.deltatmaxi = tempo.deltatmaxi
= coef_pas_critique_deltatmaxi * temps_critiqueDFC; }
else {tempo_specifique_algo.deltatmaxi = tempo.deltatmaxi
= coef_pas_critique_deltatmaxi * temps_critique; };
}
if (coef_pas_critique_deltatmini != -3333256794.)
{if (typeDFC_pas_critique_deltatmini)
{tempo_specifique_algo.deltatmini = tempo.deltatmini
= coef_pas_critique_deltatmini * temps_critiqueDFC; }
else {tempo_specifique_algo.deltatmini = tempo.deltatmini
= coef_pas_critique_deltatmini * temps_critique; };
};
return modif;
};
// on met à jour les infos globales
std::vector <double>& ParaAlgoControle::Mise_a_jour_Grandeurs_globales()
{return ParaGlob::Mise_a_jour_Grandeurs_globales();};
Reference in a new issue Copy permalink