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

694 lines
47 KiB
C
Raw Normal View History

introduction des répertoires flambages, Lecture et Parametres
2021-09-28 11:58:49 +02:00
// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
introduction des répertoires flambages, Lecture et Parametres
2021-09-28 11:58:49 +02:00
// 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/>.
/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Stockage des parametres de controle. *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef PARA_ALGOCONTROLE_H
#define PARA_ALGOCONTROLE_H
#include "UtilLecture.h"
#include "Enum_matrice.h"
#include "Enum_type_resolution_matri.h"
#include "Enum_calcul_masse.h"
#include "VariablesTemps.h"
#include "Basiques.h"
#include "EnumTypePilotage.h"
#include <vector>
/// @addtogroup Les_parametres_generaux
/// @{
///
class ParaAlgoControle
{ public :
// CONSTRUCTEUR
// par défaut
ParaAlgoControle();
// de copie
ParaAlgoControle(const ParaAlgoControle& p);
//destructeur
~ ParaAlgoControle() {};
// Méthodes publiques
// Surcharge de l'affectation
ParaAlgoControle& operator= (const ParaAlgoControle& p);
// lecture sur le flot d'entrée
void Lecture_paraAlgoControle(UtilLecture & entreePrinc);
// affichage des paramètres de controle
void Affiche() const ;
// définition interactive exhaustive des paramètres de contrôle indépendamment de l'algorithme
// écriture du fichier de commande
void Info_commande_ParaAlgoControle(UtilLecture& lec);
// sauvegarde sur base info
// cas donne le niveau de sauvegarde
// = 0 : initialisation de la sauvegarde -> c'est-à-dire de la sortie base info
// = 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 Ecriture_base_info_Para
(ofstream& sort,const int cas) const;
// cas de la lecture spécifique à l'algorithme dans base_info
void Lecture_base_info_Para(ifstream& ent,const int cas);
// --- fonctions d'accès en lecture des paramètres
// 1) ==== parametres de controle généraux pour la résolution de l'équilibre
// générale
// nombre servant à gérer la frequence de sauvegarde
// il faut utiliser Cas_de_sauvegarde() pour gérer correctement le nombre ramené en paramètre
bool Sauvegarde() const { if (sauvegarde != 0.) return true; else 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 SauvegardeAutorisee(int incre,const double& temps_derniere_sauvegarde,bool dernier_calcul) const;
// maxi d'iteration pour converger
int Iterations() const { return iterations;};
// precision de la convergence
double Precision() const { return precision;};
// precision sur le temps final
double Prectemps() const { return tempo_specifique_algo.prectemps;};
// type de norme de convergence
Deux_String Norme() const { return norme;};
// cinematique sur l'increment ?
bool Cinematique() const { return cinematique;};
// convergence forcee ?
bool Conv_forcee() const { return conv_forcee;};
// multiplicateur de la charge
double Multiplicateur() const { return multiplicateur;};
// increment de temps
double Deltat() const { return tempo_specifique_algo.deltat;};
// increment de temps maxi
double Deltatmaxi () const {return tempo_specifique_algo.deltatmaxi;};
// increment de temps mini
double Deltatmini () const {return tempo_specifique_algo.deltatmini;};
// temps de fin de calcul
double Tempsfin() const { return tempo_specifique_algo.tempsfin;};
// test pour savoir si les incréments de temps courant ou maxi dépendent d'un temps critique
bool DeltatOuDeltatmaxDependantTempsCritique() const
{if ((coef_pas_critique_deltat!= coef_defaut_pa_critique)
// ((coef_pas_critique_deltat!=0.)
||(coef_pas_critique_deltatmaxi!=0.)) return true; else return false;};
double Coefficient_pas_critique_deltat() const {return coef_pas_critique_deltat;};
static double Coef_defaut_pa_critique() {return coef_defaut_pa_critique;} // valeur par défaut de coef_pas_critique_deltat
double Coefficient_pas_critique_deltatmaxi() const {return coef_pas_critique_deltatmaxi;};
// maximum d'increment de temps
int Maxincre () const { return maxincre;};
// maximum de tentative d'increment de temps permis
int Max_essai_incre () const { return max_essai_incre;};
// increment de redemarage de calcul
int Restart() const { return restart;};
// maximum de puissance tolérée
double Max_puissance() const { return max_puissance;};
// indique si oui ou non on utilise le line_search
bool Line_search() const { return line_search;};
// indique si oui ou non le chargement externe participe à la raideur
bool Var_charge_externe() const {return var_charge_externe;};
// indique si oui ou non la variation du jacobine participe à la raideur
bool Var_jacobien() const {return var_jacobien;};
// indique si oui ou non la variation de la vitesse de déformation participe à la raideur
bool Var_D() const {return var_D;};
//--- globalisation des paramètres liés au temps
static const VariablesTemps& Variables_de_temps() {return tempo;};
// idem pour les grandeurs spécifique
const VariablesTemps& Variables_de_temps_specifiques_algo() {return tempo_specifique_algo;};
// 2) ==== paramètres liés au système d'équations linéaires
// type de stockage matriciel
Enum_matrice Type_Matrice() const { return type_matrice;};
// assemblage symétrique ou non
bool Symetrie_matrice () const {return symetrie_matrice;};
// type de résolution
Enum_type_resolution_matri Type_resolution() const { return type_resolution;};
// type de préconditionnement
Enum_preconditionnement Type_preconditionnement() const { return type_preconditionnement;};
// nombre d'itération dans le cas d'une méthode itérative
int Nb_iter_nondirecte() const { return nb_iter_nondirecte;};
// tolerance de convergence dans le cas d'une méthode itérative
double Tolerance() const { return tolerance;};
// nombre de vecteur sauvegardé dans le cas d'une méthode
// itérative avec redépart
int Nb_vect_restart() const { return nb_vect_restart;};
// même chose pour les matrices secondaires éventuelles
// a priori les listes sont parcourues selon l'orde de type_matrice_secondaire, si les listes ont des
// tailles différentes, les algos s'en débrouillent (à voir dans la doc et les algos)
// *** ce n'est pas la peine d'essayer de remplacer les listes par des tableaux, c'est impossible
// car Tableau_T intègre ParaGlob qui intègre ParaAgloControle et donc c'est un cercle infernal
// donc si l'on veut vraiment des tableaux il faut passer par Tableau<T>::Init_from_list
// et en dehors de la classe ParaAlgoControle !!
const list < Enum_matrice >& Type_matrice_secondaire() const {return type_matrice_secondaire;};
const list < Enum_type_resolution_matri >& Type_resolution_secondaire() const {return type_resolution_secondaire;};
const list < Enum_preconditionnement >& Type_preconditionnement_secondaire() const {return type_preconditionnement_secondaire;};
const list < int >& Nb_iter_nondirecte_secondaire() const {return nb_iter_nondirecte_secondaire;};
const list < double >& Tolerance_secondaire() const {return tolerance_secondaire;};
const list < int >& NB_vect_restart_secondaire() const {return nb_vect_restart_secondaire;};
// indique si l'on veut ou non une optimisation des pointeurs d'assemblage
// notamment en fonction des CLL
int Optimisation_pointeur_assemblage() const {return opti_pointeur_assemblage;};
// 3) ==== paramètres liés au pilotage de l'équilibre global
// indication du type de pilotage retenu
EnumTypePilotage TypeDePilotage() const {return type_de_pilotage;}
// facteur de diminution de l'incrément de chargement
double Facteur_diminution() const {return facteur_diminution;};
// facteur d'augmentation de l'incrément de chargement
double Facteur_augmentation() const {return facteur_augmentation;};
// facteurs de diminution après une mauvaise convergence
double Fact_dim_en_mauvaiseConv() const {return fact_dim_en_mauvaiseConv;};
// nb de bonne convergence -> augmentation du deltatt
int Nb_bonne_convergence() const {return nb_bonne_convergence;};
// nb d'iter pour statuer sur la bonne convergence
int Nb_iter_pour_bonne_convergence() const {return nb_iter_pour_bonne_convergence;};
// nb d'iter pour statuer sur une mauvaise convergence
int Nb_iter_pour_mauvaise_convergence() const {return nb_iter_pour_mauvaise_convergence;};
// nombre d'itération avec un comportement tangent simple
// type élasticité par exemple, pour stabiliser les itérations avec des
// comportements plus complexes.
int Init_comp_tangent_simple() const {return init_comp_tangent_simple;};
// récup du facteur de sur ou sous relaxation
double SurSousRelaxation() const {return sur_sous_relaxation;};
// récup de la limitation maxi de l'incrément de ddl
double NormeMax_increment() const {return norme_incre_max;};
// récup de la limitation maxi de l'incrément de ddl sur les déplacements
double NormeMax_X_increment() const {return norme_incre_X_max;};
// récup de la limitation maxi de l'incrément de ddl sur les vitesses
double NormeMax_V_increment() const {return norme_incre_V_max;};
// récup de la limite supérieure permise pour la variation des ddl, pour le test convergence
double VarMaxiDdl() const {return varMaxiDdl;};
// récup de la limite inférieure permise pour la variation des ddl, pour le test convergence
double VarMiniDdl() const {return varMiniDdl;};
// récup du nombre de cycle pour le controle du max de résidu
int NbCycleControleResidu() const {return nbCycleControleResidu;};
// récup de combien de fois à suivre il faut que le controle de variation de résidu soit faux
// pour conclure à la non convergence
int PlageControleResidu() const {return plageControleResidu;};
// initialisation de l'incrément avec l'incrément du pas précédent : oui ou non
double IniIncreAvecDeltaDdlPrec() const { return initIncreAvecDeltaDdlPrec; };
// ramène l'indicateur de cas : pour le traitement du cas d'un jacobien négatif
int JabobienNegatif() const { return jabobien_negatif; };
// ramène la variation maxi autorisé pour le jacobien
// si <=1 veut dire que le paramètre n'est pas activé (il ne faut pas en tenir compte)
double MaxiVarJacobien() const { return var_maxi_jacobien; };
// ramène l'indicateur de cas : pour le traitement ou une fonction nD
// pour le chargement, signale un pb
int Cas_fctnD_charge() const { return cas_fctnD_charge; };
// 4) paramètres liès à la dynamique
// type de calcul de la masse
Enum_calcul_masse Type_calcul_masse() const {return type_calcul_masse;};
// limitation du temps maxi stable : active ou pas
bool Limit_temps_stable() const { return limitation_temps_maxi_stable;};
// indique si l'on inclut automatiquement un amortissement visqueux artificiel
// =0 pas d'amortissement, = 1 amortissement de tyme rayleigh
// = 2 amortissement calculé à partir de l'amortissement critique approché(première méthode)
// = 3 idem 2, mais autre méthode de calcul
// = 4 amortissement critique utilisé avec les algo de relaxation dynamique
int Amort_visco_artificielle() const {return amort_visco_arti;};
// change le paramètre indiquant l'amortissement visqueux artificiel
void Change_amort_visco_artificielle(int val_amort) { amort_visco_arti = val_amort;};
// valeur de la viscosité dynamique
double Visco_artificielle() const {return visco_arti; };
// la matrice d'amortissement dynamique [C] est construite à partir des coeffs de rayleigh
// sur la masse et sur la raideur
// coefficient de rayleigh sur la masse, pour la construction de la matrice de viscosité
double CoefRayleighMasse( )const {return coef_rayleigh_masse;};
// coefficient de rayleigh sur la raideur, pour la construction de la matrice de viscosité
double CoefRayleighRaideur() const {return coef_rayleigh_raideur;};
// cas du calcul de la viscosité critique : coef de bornage de la viscosité critique
double BorneMaxiSurCfonctionDeLaMasse() const {return maxi_C_en_fonction_M;};
// booleen indiquant si l'on veut l'intervention du bulk viscosity ou non
int BulkViscosity() const { return bulk_viscosity;};
// les deux coefficients de la formule du bulk viscosity: q=ro l (coef1 l trace(D) - coef2 a trace(D)^2)
DeuxDoubles CoefsBulk() const { return DeuxDoubles(c_Tracebulk,c_Trace2bulk);};
// 5) paramètres liès à l'affichage des résultats
// fréquence sur les increments de l'affichage des résultats
int Freq_affich_incre() const {return frequence_affichage_increment;};
// fréquence sur les itération de l'affichage des résultats
int freq_affich_iter() const {return frequence_affichage_iteration;};
// nombre servant à gérer la frequence de sauvegarde au fil du calcul
// il faut utiliser SauvegardeFilCalculAutorisee() pour gérer correctement le nombre ramené en paramètre
bool Sortie_fil_calcul() const { if (sortie_fil_calcul > 0.) return true; else return false;};
// 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 SauvegardeFilCalculAutorisee(int incre,const double& temps_derniere_sauvegarde,bool dernier_calcul) const;
// 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 Vrai_commande_sortie(int icharge,const double& temps_derniere_sauvegarde) const;
// nombre de diggit utilisé pour afficher des réels en double précision pour l'archivage calcul (restart
// on sortie des résultats) (en fait utilisé avec ParaGlob avec une fonction statique)
int Nb_diggit_double_calcul() const { return nb_diggit_double_calcul;};
// nombre de diggit utilisé pour afficher des réels en double précision pour la visualisation graphique
// (en fait utilisé avec ParaGlob avec une fonction statique)
int Nb_diggit_double_graphique() const { return nb_diggit_double_graphique;};
// nombre de diggit utilisé pour afficher des réels en double précision sur l'écran
// (en fait utilisé avec ParaGlob avec une fonction statique)
int Nb_diggit_double_ecran() const { return nb_diggit_double_ecran;};
// 6) paramètres liès au contact
// ramène la précision voulu sur le test de la pénétration d'un point initial avant le début du calcul
double Precision_point_interne_debut() const { return prec_pt_int_deb; };
// ramène un facteur multiplicatif du déplacement maxi entre t et tdt, donnant la
// distance maxi admissible entre le point et le point projeté
double FacPourRayonAccostage() const {return factPourRayonAccostage;};
// ramène la distance maxi adminssible entre le point et le point projeté
double DistanceMaxiAuPtProjete() const {return distanceMaxiAuPtProjete;};
// ramène le pourcentage de plus que l'on prend pour les boites de prélocalisation d'élément
double Extra_boite_prelocalisation() const { return extra_boite_prelocalisation; };
// ramène un paramètre "r" qui multiplié par la taille maxi d'un élément donne l'épaisseur
// que l'on met autour de la boite de prélocalisation pour éviter certaine dimension nulle à cette boite
double Rapport_Extra_boite_mini_prelocalisation() const { return mini_extra_boite_prelocalisation; };
// ajout_extra_boite_prelocalisation est un paramètre qui est ajouté dans tous les directions aux boites de préloca
double Ajout_extra_boite_prelocalisation() const {return ajout_extra_boite_prelocalisation;};
// ramène le type de contact et son existance
// ==0 : pas de contact, !=0 -> le type de contact
// ==1 : contact cinématique, sans multiplicateur ni pénalisation (contact original)
// ==2 : contact avec pénalisation
int ContactType() const {return contact_type;};
// ramène un string décrivant une fonction nD de pilotage pour le type de contact 4
// = "_" si aucune fonction n'est définit
string Fct_nD_bascul_contact_type_4() const {return fct_nD_bascul_contact_type_4;};
// ramène le facteur brut de pénalisation pour la pénétration
double PenalisationPenetrationContact() const {return penalisationPenetration;};
// ramène un string décrivant une fonction nD de pilotage équivalente
// = "_" si aucune fonction n'est définit
string Fct_nD_penalisationPenetration() const {return fct_nD_penalisationPenetration;};
// ramène le type de contrôle du facteur de pénalisation pour la pénétration
int TypeCalculPenalisationPenetration() const {return typePenalisationPenetration;};
// ramène une borne maxi de pénétration (dont l'utilisation dépend de l'algo)
double Penetration_contact_maxi() const {return penetration_contact_maxi;};
// ramène un string décrivant une fonction nD de pilotage équivalente
// = "_" si aucune fonction n'est définit
string Fct_nD_penetration_contact_maxi() const {return fct_nD_penetration_contact_maxi;};
// ramène une borne de régularisation sur la penetration (dont l'utilisation dépend de l'algo)
double Penetration_borne_regularisation() const {return penetration_borne_regularisation;};
// ramène un string décrivant une fonction nD de pilotage équivalente
// = "_" si aucune fonction n'est définit
string Fct_nD_penetration_borne_regularisation() const {return fct_nD_penetration_borne_regularisation;};
// ramène une borne maxi pour la force de réaction du noeud (dont l'utilisation dépend de l'algo)
double Force_contact_noeud_maxi() const {return force_contact_noeud_maxi;};
// ramène un string décrivant une fonction nD de pilotage équivalente
// = "_" si aucune fonction n'est définit
string Fct_nD_force_contact_noeud_maxi() const {return fct_nD_force_contact_noeud_maxi;};
// ramène le facteur de pénalisation pour le déplacement tangentiel
double PenalisationTangentielleContact() const {return penalisationTangentielle;};
// ramène un string décrivant une fonction nD de pilotage équivalente
// = "_" si aucune fonction n'est définit
string Fct_nD_penalisationTangentielle() const {return fct_nD_penalisationTangentielle;};
// ramène le type de contrôle du facteur de pénalisation pour le dep tangentiel
int TypeCalculPenalisationTangentielle() const {return typePenalisationTangentielle;};
// ramène une borne maxi de dep tangentiel (dont l'utilisation dépend de l'algo)
double Tangentielle_contact_maxi() const {return tangentielle_contact_maxi;};
// ramène un string décrivant une fonction nD de pilotage équivalente
// = "_" si aucune fonction n'est définit
string Fct_nD_tangentielle_contact_maxi() const {return fct_nD_tangentielle_contact_maxi;};
// ramène une borne de régularisation sur le dep tangentiel (dont l'utilisation dépend de l'algo)
double Tangentielle_borne_regularisation() const {return tangentielle_borne_regularisation;};
// ramène un string décrivant une fonction nD de pilotage équivalente
// = "_" si aucune fonction n'est définit
string Fct_nD_tangentielle_borne_regularisation() const {return fct_nD_tangentielle_borne_regularisation;};
// ramène une borne maxi pour la force tangentiel sur le noeud (dont l'utilisation dépend de l'algo)
double Force_tangentielle_noeud_maxi() const {return force_tangentielle_noeud_maxi;};
// ramène un string décrivant une fonction nD de pilotage équivalente
// = "_" si aucune fonction n'est définit
string Fct_nD_force_tangentielle_noeud_maxi() const {return fct_nD_force_tangentielle_noeud_maxi;};
// précision de positionnement sur les X^ar d'un pt en contact sur une frontière
double Precision_pt_sur_front() const {return prec_pt_sur_frontiere;};
// nb de boucle maxi pour la recherche du positionnement du pt en contact
int Nb_boucle_newton_position_sur_frontiere()const {return nb_boucle_newton_position_frontiere;};
// nb de fois un noeud décolle pour n'être plus considéré en contact
int NbDecolAutorise()const {return nbDecolAutorise;};
// retourne le type de méthode utilisée pour gérer le décollement
int TypeDeDecolement() const {return typeDeDecolement;};
// retourne le nombre de positions successives, utilisé pour faire une moyenne glissante de ces positions
int Nb_moy_glissant() const {return nb_glissant;};
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// retourne le niveau de commentaire entre 0 et 10, pour la gestion globale
// du contact
// le niveau utilisé est a priori le max du niveau général et de celui-ci
int Niveau_commentaire_LesContact() const {return niveau_commentaire_lescontacts;};
introduction des répertoires flambages, Lecture et Parametres
2021-09-28 11:58:49 +02:00
// retourne le niveau de commentaire entre 0 et 10, pour les algo de contact
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// : concerne les éléments de contact
introduction des répertoires flambages, Lecture et Parametres
2021-09-28 11:58:49 +02:00
// le niveau utilisé est a priori le max du niveau général et de celui-ci
int Niveau_commentaire_contact() const {return niveau_commentaire_contact;};
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// ramène un string décrivant une fonction nD de pilotage équivalente
// = "_" si aucune fonction n'est définit
string Fct_niveau_commentaire_contact() const {return fct_niveau_commentaire_contact;};
introduction des répertoires flambages, Lecture et Parametres
2021-09-28 11:58:49 +02:00
// retour d'un indication concernant une optimisation éventuelle
//de la numerotation en tenant compte des éléments de contact
int Optimisation_numerotation() const {return optimisation_numerotation;};
// 7) paramètres liés aux calculs des énergies
// ramène l'incrément mini à partir duquel on calcul les énergies cumulées
int NbIncrCalEnergie() const {return nb_incr_cal_ener;};
// indique si oui ou non le calcul et l'affichage des énergies sur l'incrément est effectué
bool AfficheIncrEnergie() const {return affiche_incr_energie;};
// 8) paramètres liés aux calculs géométriques sur les éléments
// -- paramètres relatifs à la recherche d'un point interne à un élément (dans ElemMeca)
// coordonnée thetai ok si delta thetai < à la prec
double PointInterneDeltaThetaiMaxi() const {return point_interne_delta_thetai_maxi;};
// precision sur thetai sur le test du point interne
double PointInternePrecThetaiInterne() const {return point_interne_prec_thetai_interne;};
// maxi boucle de Newton sur la recherche des thetai
int PointInterneNbBoucleSurDeltaThetai() const {return point_interne_nb_boucle_sur_delta_thetai;};
//nb max de test positif "externe" pour statuer un point externe
int PointInterneNbExterne() const {return point_interne_nb_externe;};
// indique si oui ou non on calcul les volumes entre la surface et les 3 plans de ref (valable uniquement en 3D pour des surfaces)
bool CalVolTotalEntreSurfaceEtPlansRef() const {return cal_vol_total_entre_surface_et_plans_ref;};
// indique le rapport maxi autorisé entre le jacobien de la facette centrale
// et le jacobien au pti pour les éléments coques
double Ratio_maxi_jacoMembrane_jacoPti() const {return ratio_maxi_jacoMembrane_jacoPti;};
// indique quelle méthode numérique est utilisée pour effectuer
// l'inversion des tenseurs métriques: exe : utilisation de la méthode de Cramer (méthode historique)
// ou encore : utilisation d'une méthode LU avec équilibrage des ligne (second méthode implantée)
Enum_type_resolution_matri Type_calnum_inversion_metrique() const {return type_calnum_inversion_metrique;};
// --- fonctions d'accès en modification des paramètres -----------
// 1) ==== parametres de controle généraux pour la résolution de l'équilibre
// générale
// modification de l'increment de temps,
// si c'est >= au deltat mini et <= deltat maxi, => retour 0
// 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
int Modif_Deltat(double nouveau_temps);
// 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 Modif_Detat_dans_borne(double& nouveau_temps);
// modification directe du temps
void Modif_Temps(double nouveau_temps) { tempo_specifique_algo.temps = tempo.temps = nouveau_temps;};
// 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 Modif_Deltat_DeltatMaxi(double temps_critique, double temps_critiqueDFC);
// modif arbitraire (sans aucune vérification) des paramètres de temps courant
// ** a utiliser à bon essient
void Modif_temps(const double& tem,const double& deltatem)
{tempo_specifique_algo.temps = tempo.temps = tem;
tempo_specifique_algo.deltat = tempo.deltat = deltatem;};
// modification de var_D
void Modif_Var_D(bool va_D) {var_D = va_D;};
// modification de var_jacobien
void Modif_Var_jacobien(bool va_jacobien) {var_jacobien = va_jacobien;};
//------------ 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
//---
void ChangeSortieEquilibreGlobal(bool val) {sortieEquilibreGlobal=val;};
bool EtatSortieEquilibreGlobal() const {return sortieEquilibreGlobal;};
//---
void ChangeSortieEtatActuelDansBI(bool val) {sortieEtatActuelDansBI=val;};
bool EtatSortieEtatActuelDansBI() const {return sortieEtatActuelDansBI;};
//---
void ChangeSortieEtatActuelDansCVisu(bool val) {sortieEtatActuelDansCVisu=val;};
bool EtatSortieEtatActuelDansCVisu() const {return sortieEtatActuelDansCVisu;};
// on met à jour les infos globales
std::vector <double>& Mise_a_jour_Grandeurs_globales();
protected :
// VARIABLES PROTEGEES :
// 1) parametres de controle généraux pour la résolution de l'équilibre
// générale
double sauvegarde; // un entier ou double servant a contrôler la frequence de sauvegarde
// dans le cas le plus simple : = le nombre d'incrément séparant deux pas de sauvegarde
int cas_de_sauvegarde; // associé au paramètre sauvegarde: indique comment le contrôle de la fréquence de
// sauvegarde s'effectue: =1 : cas le plus simple (cf si-dessus)
// =2 : cas où sauvegarde indique le deltat qui existe entre 2 sauvegardes
// =3 : cas où on sauvegarde l'incrément 0 et le dernier incrément
// =4 : cas 1 + le dernier incrément
// =5 : cas 2 + le dernier incrément
int iterations; // maxi d'iteration pour converger
double precision; // precision de la convergence
Deux_String norme; // type de norme de convergence: le premier string = la norme sauf si
// le premier= fonction_nD: dans ce cas le second = le nom de la fonction nD
bool cinematique; // cinematique sur l'increment ?
bool conv_forcee; // convergence forcee ?
double multiplicateur; // multiplicateur de la charge
// ---- le temps,
// contrairement aux autres variables, il s'agit d'une variable static pour qu'il n'y ait qu'un seul
// temps dans le calcul. C'est aussi une nécessité pour la liaison avec la classe ParaGlob,
// sinon cela pose des pbs dans le cas de plusieurs variable ParaAlgoControle
static VariablesTemps tempo; // contients les grandeurs courantes:
// temps courant, l'increment de temps, l'incrément de temps maxi
// le temps fin, la précision sur les tests sur les temps
// les grandeurs spécifiques de l'algo:
// la seule grandeurs qui est commune c'est le temps courant: celui stocké dans "tempo"
VariablesTemps tempo_specifique_algo;
bool force_deltat; // indique si oui ou non, lors d'un restart on force l'utilisation de l'incrément de temps
// indiqué dans le .info, ou au contraire on reprend celui du pas précédent
// ne sert qu'une fois, ensuite elle est mise à false !!
double coef_pas_critique_deltat; // coeff du pas critique pour deltat s'il existe
static double coef_defaut_pa_critique; // valeur par défaut de coef_pas_critique_deltat
double coef_pas_critique_deltatmaxi; // coeff du pas critique pour deltatmaxi s'il existe
double coef_pas_critique_deltatmini; // coeff du pas critique pour deltatmini s'il existe
bool typeDFC_pas_critique_deltat; // = true: il s'agit du pas critique de DFC, false : pas critique spécifique
bool typeDFC_pas_critique_deltatmaxi; // idem
bool typeDFC_pas_critique_deltatmini; // idem
// --- fin pour le tempq
int maxincre ; // maximum d'increment de temps
int max_essai_incre ; // maximum de tentative d'increment de temps permis
int restart; // increment de redemarage de calcul
double max_puissance; // maximum de puissance tolérée
bool line_search; // indique si oui ou non on utilise le line_search
bool var_charge_externe; // indique si oui ou non le chargement externe
// participe à la raideur
bool var_jacobien; // indique si l'on tiend compte de la variation du jacobien
// dans le calcul de la raideur
bool var_D; // indique si l'on tiend compte de la variation de D* dans la raideur
// 2) paramètres liés au système d'équations linéaires
bool symetrie_matrice; // indique si le stockage est symétrique ou non
Enum_matrice type_matrice; // type de stockage matriciel
Enum_type_resolution_matri type_resolution; // type de résolution
Enum_preconditionnement type_preconditionnement; // type de préconditionnement
int nb_iter_nondirecte; // nombre d'itération dans le cas d'une méthode itérative
double tolerance; // tolerance de convergence dans le cas d'une méthode itérative
int nb_vect_restart; // nombre de vecteur sauvegardé dans le cas d'une méthode
// itérative avec redépart
// même chose pour les matrices secondaires éventuelles
list < Enum_matrice > type_matrice_secondaire; // type de stockage matriciel
list < Enum_type_resolution_matri > type_resolution_secondaire; // type de résolution
list < Enum_preconditionnement > type_preconditionnement_secondaire; // type de préconditionnement
list < int > nb_iter_nondirecte_secondaire; // nombre d'itération dans le cas d'une méthode itérative
list < double > tolerance_secondaire; // tolerance de convergence dans le cas d'une méthode itérative
list < int > nb_vect_restart_secondaire; // nombre de vecteur sauvegardé dans le cas d'une méthode
// itérative avec redépart
// indique si l'on veut ou non une optimisation des pointeurs d'assemblage
// notamment en fonction des CLL
int opti_pointeur_assemblage; // = 0 : pas d'optimisation,
// 3) paramètres liés au pilotage de l'équilibre global
EnumTypePilotage type_de_pilotage; // définit le type de pilotage retenue
double facteur_diminution; // facteurs d'augmentation, ou de diminution
double facteur_augmentation; // de l'incrément de chargement
double fact_dim_en_mauvaiseConv; // facteurs de diminution après une mauvaise convergence
int nb_bonne_convergence; // nb de bonne convergence -> augmentation du deltatt
int nb_iter_pour_bonne_convergence; // nb d'iter pour statuer sur la bonne convergence
int nb_iter_pour_mauvaise_convergence; // nb d'iter pour statuer sur une mauvaise convergence
double varMiniDdl, varMaxiDdl; // limites mini et maxi des ddl
int nbCycleControleResidu,plageControleResidu; // nb cycle et plage de controle du résidu
int init_comp_tangent_simple; // nombre d'itération avec un comportement tangent simple
// type élasticité par exemple, pour stabiliser les itérations avec des
// comportements plus complexes.
double sur_sous_relaxation; // facteur de sur ou sous relaxation
double norme_incre_max; // limitation de l'incrément maxi des ddl
double norme_incre_X_max; // limitation de l'incrément maxi des ddl de déplacement
double norme_incre_V_max; // limitation de l'incrément maxi des ddl de vitesse
double initIncreAvecDeltaDdlPrec; // initialisation de l'incrément avec l'incrément du pas précédent
int jabobien_negatif; // traitement des jacobiens négatifs
double var_maxi_jacobien; // variation maxi autorisée du jacobien, si <= 0 pas pris en compte
int cas_fctnD_charge; // traitement du cas ou une fonction nD pour le chargement, signale un pb
// 4) paramètres liès à la dynamique
Enum_calcul_masse type_calcul_masse; // type de calcul de la masse
// le type de stockage de la matrice masse est celui de type_matrice
// utilisé que si la matrice masse n'est pas diagonale
bool limitation_temps_maxi_stable; // booléen qui indique si la limitation supérieur
// du temps pour satisfaire la stabilité, est active ou pas
int amort_visco_arti; // indique si l'on inclut automatiquement un amortissement visqueux artificiel
// =0 pas d'amortissement, = 1 amortissement de tyme rayleigh
// = 2 amortissement calculé à partir de l'amortissement critique approché
double visco_arti; // valeur de la viscosité dynamique ou de la proportion d'amortissement critique
double maxi_C_en_fonction_M; // bornage de C: maxi C = maxi_C_en_fonction_M * M (cas du calcul de C critique)
// la matrice d'amortissement dynamique [C] est construite à partir des coeffs de rayleigh
// sur la masse et sur la raideur
double coef_rayleigh_masse,coef_rayleigh_raideur;
// int indiquant si l'on veut l'intervention du bulk viscosity ou non
// =0 pas d'intervention, =1 intervention si I_D est négatif, =2 intervention quelque soit I_D
int bulk_viscosity;
// les deux coefficients de la formule du bulk viscosity: q=ro l (coef1 l trace(D) - coef2 a trace(D)^2)
double c_Tracebulk,c_Trace2bulk;
// 5) paramètres liès à l'affichage des résultats
// ---- a l'écran
int frequence_affichage_increment; // fréquence sur les increments de l'affichage des résultats
int frequence_affichage_iteration; // fréquence sur les itération de l'affichage des résultats
// --- en sortie au fil du calcul
double sortie_fil_calcul; // fréquence sur les incréments, pour la sortie au fil du calcul
int cas_de_sortie_fil_calcul; // associé au paramètre sortie_fil_calcul:
//indique comment le contrôle de la fréquence de sortie au fil du calcul s'effectue
// =1 : cas le plus simple (cf si-dessus)
// =2 : cas où sauvegarde indique le deltat qui existe entre 2 sauvegardes
// 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
// le troisième pour l'affichage à l'écran
int nb_diggit_double_calcul;
int nb_diggit_double_graphique;
int nb_diggit_double_ecran;
// 6) paramètres liès au contact
double prec_pt_int_deb; // précision du test: point à l'intérieur d'un élément
double factPourRayonAccostage; // facteur multiplicatif du déplacement maxi entre t et tdt, donnant
// distance maxi admissible entre le point et le point projeté
double distanceMaxiAuPtProjete; // distance maxi admissible entre le point et le point projeté
double extra_boite_prelocalisation; // donne la proportion de plus que l'on prend pour les boites
// mini_extra_boite_prelocalisation est un paramètre qui multiplié par la taille maxi d'un élément donne
// l'épaisseur que l'on met autour de la boite de prélocalisation pour éviter certaine dimension nulle à cette boite
double mini_extra_boite_prelocalisation;
// ajout_extra_boite_prelocalisation est un paramètre qui est ajouté dans tous les directions aux boites de préloca
double ajout_extra_boite_prelocalisation;
int contact_type; // indique si oui (!= 0) ou non (==0) il y a contact, et le nombre indique le type de contact
string fct_nD_bascul_contact_type_4; // fonction nD qui permet de piloter le type 4
double penalisationPenetration; // facteur de pénalisation pour la pénétration
string fct_nD_penalisationPenetration; // fct nD dans le cas d'une valeur pilotée
int typePenalisationPenetration; // indique le type de calcul pour la pénalisation en pénétration
double penetration_contact_maxi; // indique une borne maxi de pénétration (dont l'utilisation dépend de l'algo)
string fct_nD_penetration_contact_maxi; // fct nD dans le cas d'une valeur pilotée
double penetration_borne_regularisation; // borne de régularisation sur la penetration (dont l'utilisation dépend de l'algo)
string fct_nD_penetration_borne_regularisation; // fct nD dans le cas d'une valeur pilotée
double force_contact_noeud_maxi; // indique une borne maxi pour la force de réaction du noeud (dont l'utilisation dépend de l'algo)
string fct_nD_force_contact_noeud_maxi; // fct nD dans le cas d'une valeur pilotée
double penalisationTangentielle; // facteur de pénalisation pour le déplacement tangentiel
string fct_nD_penalisationTangentielle;
int typePenalisationTangentielle; // indique le type de calcul pour la pénalisation en dep tangentiel
double tangentielle_contact_maxi; // indique une borne maxi de dep tangentiel (dont l'utilisation dépend de l'algo)
string fct_nD_tangentielle_contact_maxi; // fct nD dans le cas d'une valeur pilotée
double tangentielle_borne_regularisation; // borne de régularisation sur le dep tangentiel
string fct_nD_tangentielle_borne_regularisation; // fct nD dans le cas d'une valeur pilotée
double force_tangentielle_noeud_maxi; // indique une borne maxi pour la force tangentielle sur le noeud
string fct_nD_force_tangentielle_noeud_maxi; // fct nD dans le cas d'une valeur pilotée
double prec_pt_sur_frontiere; // précision de positionnement sur les X^ar d'un pt en contact sur une frontière
int nb_boucle_newton_position_frontiere; // nb de boucle maxi pour la recherche du positionnement du pt en contact
int nbDecolAutorise;// nb de fois un noeud décolle pour n'être plus considéré en contact
int typeDeDecolement; // indique le type de méthode utilisée pour gérer le décollement
int nb_glissant; // le nombre de positions successives du noeud esclave, utilisé pour faire une moyenne glissante
mise à jour 7.010
2023-05-03 17:23:49 +02:00
int niveau_commentaire_lescontacts; // de 0 à 10: niveau des commentaires pour la gestion globale du contact: i.e. LesContacts
int niveau_commentaire_contact; // de 0 à 10: niveau des commentaires dans les algo de contact: niveau élément de contact
string fct_niveau_commentaire_contact; // fct nD dans le cas d'une valeur pilotée
introduction des répertoires flambages, Lecture et Parametres
2021-09-28 11:58:49 +02:00
int optimisation_numerotation; // indique éventuellement une optimisation de la numerotation en tenant compte
// des éléments de contact
// 7) paramètres liés aux calculs des énergies et puissances
int nb_incr_cal_ener; // donne l'incrément mini, à partir duquel on calcul les énergie cumulée
bool affiche_incr_energie; // 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
double point_interne_delta_thetai_maxi; // coordonnée thetai ok si delta thetai < à la prec
double point_interne_prec_thetai_interne; // precision sur thetai sur le test du point interne
int point_interne_nb_boucle_sur_delta_thetai; // maxi boucle de Newton sur la recherche des thetai
int point_interne_nb_externe; // nb max de test positif "externe" pour statuer un point externe
bool cal_vol_total_entre_surface_et_plans_ref; // indique si oui ou non on calcul ces volumes (entre la surface et les 3 plans)
double ratio_maxi_jacoMembrane_jacoPti; // rapport maxi autorisé entre le jacobien de la facette centrale
// et le jacobien au pti pour les éléments coques
Enum_type_resolution_matri type_calnum_inversion_metrique; // indique quelle méthode numérique est utilisée pour effectuer
// l'inversion des tenseurs métriques: ex: utilisation de la méthode de Cramer (méthode historique)
// ou utilisation d'une méthode LU avec équilibrage des ligne (second méthode implantée)
//------------ 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
bool sortieEquilibreGlobal; // par défaut non
bool sortieEtatActuelDansBI; // par défaut non
bool sortieEtatActuelDansCVisu; // par défaut non
mise à jour 7.010
2023-05-03 17:23:49 +02:00
introduction des répertoires flambages, Lecture et Parametres
2021-09-28 11:58:49 +02:00
};
/// @} // end of group
#endif
Reference in a new issue Copy permalink