- fct nD: amélioration message d'erreur (arguments), et en fct du niveau géré par une fct nD - première validation du fct. en // en implicite statique et en RD, nombreuses modifications et amélioration ! Signed-off-by: Gérard Rio <gerardrio56@free.fr>
3178 lines
193 KiB
C++
Executable file
3178 lines
193 KiB
C++
Executable file
|
|
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
|
|
// AUTHOR : Gérard Rio
|
|
// E-MAIL : gerardrio56@free.fr
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
// 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
|
|
nb_change_frontiere_max = 4; // nb de changement maxi de frontière
|
|
|
|
niveau_commentaire_lescontacts = 0; // par défaut c'est le général qui commande
|
|
fct_niveau_commentaire_lescontacts = "_";// pas de fonction par défaut
|
|
niveau_commentaire_contact = 0; // par défaut c'est le général qui commande
|
|
fct_niveau_commentaire_contact = "_";// pas de fonction par défaut
|
|
|
|
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),nb_change_frontiere_max(p.nb_change_frontiere_max),
|
|
niveau_commentaire_lescontacts(p.niveau_commentaire_lescontacts),
|
|
fct_niveau_commentaire_lescontacts(p.fct_niveau_commentaire_lescontacts),
|
|
niveau_commentaire_contact(p.niveau_commentaire_contact),
|
|
fct_niveau_commentaire_contact(p.fct_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;nb_change_frontiere_max = p.nb_change_frontiere_max;
|
|
|
|
niveau_commentaire_lescontacts = p.niveau_commentaire_lescontacts;
|
|
fct_niveau_commentaire_lescontacts = p.fct_niveau_commentaire_lescontacts;
|
|
niveau_commentaire_contact = p.niveau_commentaire_contact;
|
|
fct_niveau_commentaire_contact = p.fct_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 == "NB_CHANGE_FRONTIERE_MAX")
|
|
{nb_change_frontiere_max = (int) entreePrinc.lect_avec_const_double_utilisateur("NB_CHANGE_FRONTIERE_MAX ");}
|
|
|
|
else if (nom == "NIVEAU_COMMENTAIRE_LESCONTACTS")
|
|
{if (strstr(entreePrinc.tablcar,"FCT_ND_NIVEAU_COMMENTAIRE_LESCONTACTS")!=NULL)
|
|
{*(entreePrinc.entree) >> nom_inter >> fct_niveau_commentaire_lescontacts;
|
|
niveau_commentaire_lescontacts = -1; // valeur négative arbitraire
|
|
}
|
|
else
|
|
{niveau_commentaire_lescontacts= (int) entreePrinc.lect_avec_const_double_utilisateur("NIVEAU_COMMENTAIRE_LESCONTACTS ");
|
|
fct_niveau_commentaire_lescontacts = "_";
|
|
};
|
|
}
|
|
else if (nom == "NIVEAU_COMMENTAIRE_CONTACT")
|
|
{if (strstr(entreePrinc.tablcar,"FCT_ND_NIVEAU_COMMENTAIRE_CONTACT")!=NULL)
|
|
{*(entreePrinc.entree) >> nom_inter >> fct_niveau_commentaire_contact;
|
|
niveau_commentaire_contact = -1; // valeur négative arbitraire
|
|
}
|
|
else
|
|
{niveau_commentaire_contact= (int) entreePrinc.lect_avec_const_double_utilisateur("NIVEAU_COMMENTAIRE_CONTACT ");
|
|
fct_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 << "NB_CHANGE_FRONTIERE_MAX " << nb_glissant << "\n";
|
|
|
|
sort << "NIVEAU_COMMENTAIRE_LESCONTACTS "<< niveau_commentaire_lescontacts
|
|
<< "FCT_ND_NIVEAU_COMMENTAIRE_LESCONTACT"<< fct_niveau_commentaire_lescontacts << "\n";
|
|
sort << "NIVEAU_COMMENTAIRE_CONTACT "<< niveau_commentaire_contact
|
|
<< "FCT_ND_NIVEAU_COMMENTAIRE_CONTACT"<< fct_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 ;
|
|
ent >> toto >> nb_glissant ;
|
|
|
|
ent >> toto >> niveau_commentaire_lescontacts >> toto >> fct_niveau_commentaire_lescontacts;
|
|
ent >> toto >> niveau_commentaire_contact >> toto >> fct_niveau_commentaire_contact;
|
|
ent >> toto >> optimisation_numerotation;
|
|
// 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 << "NB_CHANGE_FRONTIERE_MAX " << nb_glissant << "\n";
|
|
|
|
cout << "NIVEAU_COMMENTAIRE_LESCONTACTS " << niveau_commentaire_lescontacts
|
|
<< "FCT_ND_NIVEAU_COMMENTAIRE_LESCONTACTS"<< fct_niveau_commentaire_lescontacts << "\n";
|
|
cout << "NIVEAU_COMMENTAIRE_CONTACT " << niveau_commentaire_contact
|
|
<< "FCT_ND_NIVEAU_COMMENTAIRE_CONTACT"<< fct_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(38,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_LESCONTACTS = 0 "
|
|
<< "\n (19) NIVEAU_COMMENTAIRE_CONTACT = 0 "
|
|
<< "\n (20) TYPE_PENALISATION_TANGENTIELLE = 2 "
|
|
<< "\n (21) TANGENTIELLE_CONTACT_MAXI = 0.1 "
|
|
<< "\n (22) TANGENTIELLE_BORNE_REGULARISATION = tres grand "
|
|
<< "\n (23) FORCE_TANGENTIELLE_NOEUD_MAXI = tres grand "
|
|
<< "\n (24) AJOUT_EXTRA_BOITE_PRELOCALISATION = 0. "
|
|
<< "\n (25) OPTIMISATION_NUMEROTATION = 0 "
|
|
<< "\n (26) FCT_ND_BASCUL_CONTACT_TYPE_4 = '_' "
|
|
<< "\n (27) FCT_ND_PENALISATION_PENETRATION "
|
|
<< "\n (28) FCT_ND_PENETRATION_CONTACT_MAXI "
|
|
<< "\n (29) FCT_ND_PENETRATION_BORNE_REGULARISATION "
|
|
<< "\n (30) FCT_ND_FORCE_CONTACT_NOEUD_MAXI "
|
|
<< "\n (31) FCT_ND_PENALISATION_TANGENTIELLE "
|
|
<< "\n (32) FCT_ND_TANGENTIELLE_CONTACT_MAXI "
|
|
<< "\n (33) FCT_ND_TANGENTIELLE_BORNE_REGULARISATION "
|
|
<< "\n (34) FCT_ND_FORCE_TANGENTIELLE_NOEUD_MAXI "
|
|
<< "\n (35) FCT_ND_NIVEAU_COMMENTAIRE_CONTACT "
|
|
<< "\n (36) FCT_ND_NIVEAU_COMMENTAIRE_LESCONTACTS "
|
|
<< "\n (37) NB_CHANGE_FRONTIERE_MAX "
|
|
<< "\n (38 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 = 38;
|
|
|
|
if (!((numa >= 0)&&(numa<=38)))
|
|
{ cout << "\n Erreur on attendait un entier entre 0 et 38 !!, "
|
|
<< "\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 20: case 25: case 37:
|
|
{ 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 7: case 9: case 10: case 11:
|
|
case 12: case 13: case 21: case 22: case 23: case 24:
|
|
{ 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 26:case 27:case 28:case 29:case 30:case 31:case 32:case 33:case 34:case 35:case 36:
|
|
{ cout << "\n donner le nom de la fonction nD (un string ) ? ";
|
|
val_string= lect_chaine();cout << " nom lue ="<<val_string;
|
|
break;
|
|
}
|
|
|
|
case 38:
|
|
{ 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) "
|
|
<< "\n et tous les mots clef type FCT_ND_... representent des fonctions qui permettent "
|
|
<< "\n de moduler une grandeur (cf. doc) "
|
|
<< "\n NB_CHANGE_FRONTIERE_MAX : le nombre maximum de changement de frontiere "
|
|
<< 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_lescontacts = val_int;tab_modif(numa)=true;break;}
|
|
case 19: { niveau_commentaire_contact = val_int;tab_modif(numa)=true;break;}
|
|
case 20: { typePenalisationTangentielle = val_int;tab_modif(numa)=true;break;}
|
|
case 21: { tangentielle_contact_maxi = val_double;tab_modif(numa)=true;break;}
|
|
case 22: { tangentielle_borne_regularisation = val_double;tab_modif(numa)=true;break;}
|
|
case 23: { force_tangentielle_noeud_maxi = val_double;tab_modif(numa)=true;break;}
|
|
case 24: { ajout_extra_boite_prelocalisation = val_double;tab_modif(numa)=true;break;}
|
|
case 25: { optimisation_numerotation = val_int;tab_modif(numa)=true;break;}
|
|
case 26: { fct_nD_bascul_contact_type_4 = val_string;tab_modif(numa)=true;break;}
|
|
case 27: { fct_nD_penalisationPenetration = val_string;tab_modif(numa)=true;break;}
|
|
case 28: { fct_nD_penetration_contact_maxi = val_string;tab_modif(numa)=true;break;}
|
|
case 29: { fct_nD_penetration_borne_regularisation = val_string;tab_modif(numa)=true;break;}
|
|
case 30: { fct_nD_force_contact_noeud_maxi = val_string;tab_modif(numa)=true;break;}
|
|
case 31: { fct_nD_penalisationTangentielle = val_string;tab_modif(numa)=true;break;}
|
|
case 32: { fct_nD_tangentielle_contact_maxi = val_string;tab_modif(numa)=true;break;}
|
|
case 33: { fct_nD_tangentielle_borne_regularisation = val_string;tab_modif(numa)=true;break;}
|
|
case 34: { fct_nD_force_tangentielle_noeud_maxi = val_string;tab_modif(numa)=true;break;}
|
|
case 35: { fct_niveau_commentaire_contact = val_string;tab_modif(numa)=true;break;}
|
|
case 36: { fct_niveau_commentaire_lescontacts = val_string;tab_modif(numa)=true;break;}
|
|
case 37: { nb_change_frontiere_max = val_int;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<=37;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_LESCONTACTS " << niveau_commentaire_lescontacts;break;}
|
|
case 19: { sort << "\n NIVEAU_COMMENTAIRE_CONTACT " << niveau_commentaire_contact;break;}
|
|
case 20: { sort << "\n TYPE_PENALISATION_TANGENTIELLE " << typePenalisationTangentielle;break;}
|
|
case 21: { sort << "\n TANGENTIELLE_CONTACT_MAXI " << tangentielle_contact_maxi;break;}
|
|
case 22: { sort << "\n TANGENTIELLE_BORNE_REGULARISATION " << tangentielle_borne_regularisation;break;}
|
|
case 23: { sort << "\n FORCE_TANGENTIELLE_NOEUD_MAXI " << force_tangentielle_noeud_maxi;break;}
|
|
case 24: { sort << "\n AJOUT_EXTRA_BOITE_PRELOCALISATION "<< ajout_extra_boite_prelocalisation ;break;}
|
|
case 25: { sort << "\n OPTIMISATION_NUMEROTATION "<< optimisation_numerotation ;break;}
|
|
case 26: { sort << "\n FCT_ND_BASCUL_CONTACT_TYPE_4 "<< fct_nD_bascul_contact_type_4 ;break;}
|
|
case 27: { sort << "\n PENALISATION_PENETRATION FCT_ND_PENALISATION_PENETRATION "<< fct_nD_penalisationPenetration ;break;}
|
|
case 28: { sort << "\n PENETRATION_CONTACT_MAXI FCT_ND_PENETRATION_CONTACT_MAXI "<< fct_nD_penetration_contact_maxi ;break;}
|
|
case 29: { sort << "\n PENETRATION_BORNE_REGULARISATION FCT_ND_PENETRATION_BORNE_REGULARISATION "<< fct_nD_penetration_borne_regularisation ;break;}
|
|
case 30: { sort << "\n FORCE_CONTACT_NOEUD_MAXI FCT_ND_FORCE_CONTACT_NOEUD_MAXI "<< fct_nD_force_contact_noeud_maxi ;break;}
|
|
case 31: { sort << "\n PENALISATION_TANGENTIELLE FCT_ND_PENALISATION_TANGENTIELLE "<< fct_nD_penalisationTangentielle ;break;}
|
|
case 32: { sort << "\n TANGENTIELLE_CONTACT_MAXI FCT_ND_TANGENTIELLE_CONTACT_MAXI "<< fct_nD_tangentielle_contact_maxi ;break;}
|
|
case 33: { sort << "\n TANGENTIELLE_BORNE_REGULARISATION FCT_ND_TANGENTIELLE_BORNE_REGULARISATION "<< fct_nD_tangentielle_borne_regularisation ;break;}
|
|
case 34: { sort << "\n FORCE_TANGENTIELLE_NOEUD_MAXI FCT_ND_FORCE_TANGENTIELLE_NOEUD_MAXI "<< fct_nD_force_tangentielle_noeud_maxi ;break;}
|
|
case 35: { sort << "\n NIVEAU_COMMENTAIRE_CONTACT FCT_ND_NIVEAU_COMMENTAIRE_CONTACT "<< fct_niveau_commentaire_contact ;break;}
|
|
case 36: { sort << "\n NIVEAU_COMMENTAIRE_LESCONTACTS FCT_ND_NIVEAU_COMMENTAIRE_LESCONTACTS "
|
|
<< fct_niveau_commentaire_lescontacts ;break;}
|
|
case 37: { sort << "\n NB_CHANGE_FRONTIERE_MAX " << nb_change_frontiere_max;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();};
|
|
|
|
|