rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Algo/GalerkinContinu/AlgoDynaImplicite/AlgoriNewmark.cc

981 lines
54 KiB
C++
Raw Normal View History

ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +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)
ajout de tous les algorithmes globaux
2021-09-26 14:31:23 +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/>.
#include "AlgoriNewmark.h"
#include "ConstMath.h"
// CONSTRUCTEURS :
AlgoriNewmark::AlgoriNewmark () : // par defaut
Algori(),beta_newmark(NULL),gamma_newmark(NULL),hht(NULL),stabilite(false)
,delta_t(),delta_t_2(),unSurBetaDeltaTcarre(),betaDelta_t_2()
,betaMoinsGammaSurBeta(),unSurGammaDeltat(),unMoinGamma(),unMoinGammasurgamma()
,zero5deltatcarreUnMoinDeuxBeta(),zero5deltatcarredeuxBeta(),deltatUnMoinGamma()
,deltatGamma(),unsurbetadeltat(),unmoinsdeuxbetasurdeuxbeta(),unSurBetaDeltaTcarre_o()
,nuAphaPrime(),coef_masse(),nuBetaPrime(),coef_raideur(),nuAphaPrimeunsurcoef_masse(),unsurcoef_masse()
//----- cas du masse scaling pilotée
,avec_masse_scaling(false)
,et_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique(false)
,ou_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique(false)
,ratioForce_inertieSurStatique(0.)
,et_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur(false)
,ou_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur(false)
,ratioDiag_masseSurRaideur(0.)
,cL_a_chaque_iteration(0)
// --------------------------------------------------------------------------------------
// -- variables de transferts internes entre: InitAlgorithme, CalEquilibre, FinCalcul --
// --------------------------------------------------------------------------------------
,Ass1_(NULL),Ass2_(NULL),Ass3_(NULL),cas_combi_ddl(0),icas(0),prepa_avec_remont(false)
,brestart(false),type_incre(OrdreVisu::INCRE_0),vglobin(),vglobex(),vglobaal()
,vglobal_n(),vglobal_n_inter(),vcontact()
,delta_prec_X(),inter_tdt()
,X_Bl(),V_Bl(),G_Bl(),forces_vis_num(0)
,li_gene_asso(),t_assemb(),tenuXVG(),mat_masse(NULL),mat_C_pt(NULL)
,matglob(NULL),assembMat(NULL),sauve_deltadept(NULL),sauve_dept_a_tdt(NULL)
,tab_mato(1)
,Vres(NULL),v_travail(NULL)
// ------------------------------------------------------------------------------------------
// -- fin variables de transferts internes entre: InitAlgorithme, CalEquilibre, FinCalcul --
// ------------------------------------------------------------------------------------------
{// a priori ce constructeur n'est pas utilisé
cout << "\n $$$$$$$$$ a priori ce constructeur n'est pas utilisable $$$$$$$ "
<< "\n revoir: AlgoriNewmark::AlgoriNewmark() " << endl;
Sortie(1);
};
// constructeur en fonction du type de calcul et du sous type
// il y a ici lecture des parametres attaches au type
AlgoriNewmark::AlgoriNewmark (const bool avec_typeDeCal
,const list <EnumSousTypeCalcul>& soustype
,const list <bool>& avec_soustypeDeCal
,UtilLecture& entreePrinc) :
Algori(DYNA_IMP,avec_typeDeCal,soustype,avec_soustypeDeCal,entreePrinc)
,beta_newmark(NULL),gamma_newmark(NULL),hht(NULL),stabilite(false)
,delta_t(),delta_t_2(),unSurBetaDeltaTcarre(),betaDelta_t_2()
,betaMoinsGammaSurBeta(),unSurGammaDeltat(),unMoinGamma(),unMoinGammasurgamma()
,zero5deltatcarreUnMoinDeuxBeta(),zero5deltatcarredeuxBeta(),deltatUnMoinGamma()
,deltatGamma(),unsurbetadeltat(),unmoinsdeuxbetasurdeuxbeta(),unSurBetaDeltaTcarre_o()
,nuAphaPrime(),coef_masse(),nuBetaPrime(),coef_raideur(),nuAphaPrimeunsurcoef_masse(),unsurcoef_masse()
//----- cas du masse scaling pilotée
,avec_masse_scaling(false)
,et_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique(false)
,ou_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique(false)
,ratioForce_inertieSurStatique(0.)
,et_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur(false)
,ou_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur(false)
,ratioDiag_masseSurRaideur(0.)
,cL_a_chaque_iteration(0)
// --------------------------------------------------------------------------------------
// -- variables de transferts internes entre: InitAlgorithme, CalEquilibre, FinCalcul --
// --------------------------------------------------------------------------------------
,Ass1_(NULL),Ass2_(NULL),Ass3_(NULL),cas_combi_ddl(0),icas(0),prepa_avec_remont(false)
,brestart(false),type_incre(OrdreVisu::INCRE_0),vglobin(),vglobex(),vglobaal()
,vglobal_n(),vglobal_n_inter(),vcontact()
,delta_prec_X(),inter_tdt()
,X_Bl(),V_Bl(),G_Bl(),forces_vis_num(0)
,li_gene_asso(),t_assemb(),tenuXVG(),mat_masse(NULL),mat_C_pt(NULL)
,matglob(NULL),assembMat(NULL),sauve_deltadept(NULL),sauve_dept_a_tdt(NULL)
,tab_mato(1)
,Vres(NULL),v_travail(NULL)
// ------------------------------------------------------------------------------------------
// -- fin variables de transferts internes entre: InitAlgorithme, CalEquilibre, FinCalcul --
// ------------------------------------------------------------------------------------------
{ //vglobaal = &vglobin;
// lecture des paramètres attachés au type de calcul (ici aucun)
switch (entreePrinc.Lec_ent_info())
{ case 0 :
{ lecture_Parametres(entreePrinc); break;}
case -11 : // cas de la création d'un fichier de commande
{ Info_commande_parametres(entreePrinc); break;}
case -12 : // cas de la création d'un schéma XML, on ne fait rien à ce niveau
{ break;}
default:
Sortie(1);
}
// associations pour les tableaux de matrices
tab_mato(1)=matglob;
};
// constructeur de copie
AlgoriNewmark::AlgoriNewmark (const AlgoriNewmark& algo):
Algori(algo)
,beta_newmark(NULL),gamma_newmark(NULL),hht(NULL),stabilite(false)
,delta_t(),delta_t_2(),unSurBetaDeltaTcarre(),betaDelta_t_2()
,betaMoinsGammaSurBeta(),unSurGammaDeltat(),unMoinGamma(),unMoinGammasurgamma()
,zero5deltatcarreUnMoinDeuxBeta(),zero5deltatcarredeuxBeta(),deltatUnMoinGamma()
,deltatGamma(),unsurbetadeltat(),unmoinsdeuxbetasurdeuxbeta(),unSurBetaDeltaTcarre_o()
,nuAphaPrime(),coef_masse(),nuBetaPrime(),coef_raideur(),nuAphaPrimeunsurcoef_masse(),unsurcoef_masse()
//----- cas du masse scaling pilotée
,avec_masse_scaling(algo.avec_masse_scaling)
,et_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique
(algo.et_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique)
,ou_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique
(algo.ou_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique)
,ratioForce_inertieSurStatique(algo.ratioForce_inertieSurStatique)
,et_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur
(algo.et_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur)
,ou_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur
(algo.ou_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur)
,ratioDiag_masseSurRaideur(algo.ratioDiag_masseSurRaideur)
,cL_a_chaque_iteration(algo.cL_a_chaque_iteration)
// --------------------------------------------------------------------------------------
// -- variables de transferts internes entre: InitAlgorithme, CalEquilibre, FinCalcul --
// --------------------------------------------------------------------------------------
,Ass1_(NULL),Ass2_(NULL),Ass3_(NULL),cas_combi_ddl(0),icas(0)
,prepa_avec_remont(false)
,brestart(false),type_incre(OrdreVisu::INCRE_0),vglobin(),vglobex(),vglobaal()
,vglobal_n(),vglobal_n_inter(),vcontact()
,delta_prec_X(),inter_tdt()
,X_Bl(),V_Bl(),G_Bl(),forces_vis_num(0)
,li_gene_asso(),t_assemb(),tenuXVG(),mat_masse(NULL),mat_C_pt(NULL)
,matglob(NULL),assembMat(NULL),sauve_deltadept(NULL),sauve_dept_a_tdt(NULL)
,tab_mato(1)
,Vres(NULL),v_travail(NULL)
// ------------------------------------------------------------------------------------------
// -- fin variables de transferts internes entre: InitAlgorithme, CalEquilibre, FinCalcul --
// ------------------------------------------------------------------------------------------
{ //vglobaal = &vglobin;
beta_newmark = & paraTypeCalcul(1);
gamma_newmark = & paraTypeCalcul(2);
hht = & paraTypeCalcul(3);
// associations pour les tableaux de matrices
tab_mato(1)=matglob;
};
// destructeur
AlgoriNewmark::~AlgoriNewmark ()
{
// --------------------------------------------------------------------------------------
// -- variables de transferts internes entre: InitAlgorithme, CalEquilibre, FinCalcul --
// --------------------------------------------------------------------------------------
if (mat_masse != NULL) delete mat_masse;
if (mat_C_pt != NULL) delete mat_C_pt;
if (Ass1_ != NULL) delete Ass1_;
if (Ass2_ != NULL) delete Ass2_;
if (Ass3_ != NULL) delete Ass3_;
{int taille = tab_mato.Taille();
for (int i=1;i<=taille;i++)
if (tab_mato(i)!= NULL)
delete tab_mato(i);
}
// if (mato != NULL) delete mato;
if (sauve_deltadept != NULL) delete sauve_deltadept;
if (sauve_dept_a_tdt != NULL) delete sauve_dept_a_tdt;
if (Vres != NULL) delete Vres;
if (v_travail != NULL) delete v_travail;
// ------------------------------------------------------------------------------------------
// -- fin variables de transferts internes entre: InitAlgorithme, CalEquilibre, FinCalcul --
// ------------------------------------------------------------------------------------------
};
// execution de l'algorithme
void AlgoriNewmark::Execution(ParaGlob * paraGlob,LesMaillages * lesMail
,LesReferences* lesRef,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,VariablesExporter* varExpor,LesLoisDeComp* lesLoisDeComp, DiversStockage* divStock
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts,Resultats* resultats)
{ Tableau < Fonction_nD* > * tb_combiner = NULL; // ici ne sert pas
// on définit le type de calcul a effectuer :
if ( soustypeDeCalcul->size()==0 )
// cas où il n'y a pas de sous type, on fait le calcul d'équilibre classique
// signifie que le type principal est forcément valide
{ // initialisation du calcul : deux cas, soit avec une lecture initiale du .info, soit une lecture secondaire
if (paraGlob->EtatDeLaLecturePointInfo() == 0)
{ // initialisation du calcul
InitAlgorithme(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
,divStock,charge,lesCondLim,lesContacts,resultats );
}
else
{MiseAJourAlgo(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
,divStock,charge,lesCondLim,lesContacts,resultats );
};
// on ne continue que si on n'a pas dépasser le nombre d'incréments maxi ou le temps maxi
if (! (charge->Fin(icharge,true) ) )
{ // calcul de l'équilibre
CalEquilibre(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
,divStock,charge,lesCondLim,lesContacts,resultats
,tb_combiner);
// fin du calcul, pour l'instant on ne considère pas les autres sous-types
FinCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
,divStock,charge,lesCondLim,lesContacts,resultats );
};
}
else
{if ( avec_typeDeCalcul )
// cas où le type principal est valide et qu'il y a des sous_types
{// on regarde si le sous-type "commandeInteractive" existe, si oui on le met en place
// détermine si le sous type de calcul existe et s'il est actif
if (paraGlob->SousTypeCalcul(commandeInteractive))
{// -- cas avec commandes interactives
// initialisation du calcul
InitAlgorithme(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
,divStock,charge,lesCondLim,lesContacts,resultats );
// calcul de l'équilibre tant qu'il y a des commandes
while (ActionInteractiveAlgo())
{// on ne continue que si on n'a pas dépasser le nombre d'incréments maxi ou le temps maxi
if (! (charge->Fin(icharge,true) ) )
CalEquilibre(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
,divStock,charge,lesCondLim,lesContacts,resultats
,tb_combiner);
};
// fin du calcul, pour l'instant on ne considère pas les autres sous-types
FinCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
,divStock,charge,lesCondLim,lesContacts,resultats );
}
else // cas sans commandes interactives
{// on fait le calcul d'équilibre
// initialisation du calcul : deux cas, soit avec une lecture initiale du .info, soit une lecture secondaire
if (paraGlob->EtatDeLaLecturePointInfo() == 0)
{InitAlgorithme(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
,divStock,charge,lesCondLim,lesContacts,resultats );
}
else {// on est en lecture secondaire
MiseAJourAlgo(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
,divStock,charge,lesCondLim,lesContacts,resultats );;
};
// on ne continue que si on n'a pas dépasser le nombre d'incréments maxi ou le temps maxi
if (! (charge->Fin(icharge,true) ) )
{ // calcul de l'équilibre
CalEquilibre(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
,divStock,charge,lesCondLim,lesContacts,resultats
,tb_combiner);
// fin du calcul, pour l'instant on ne considère pas les autres sous-types
FinCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor,lesLoisDeComp
,divStock,charge,lesCondLim,lesContacts,resultats );
};
};// fin du cas sans commandes interactives
// ensuite on teste en fonction des calculs complémentaires
// dépendant des sous_types. Pour l'instant ici uniquement la remontée
list <EnumSousTypeCalcul>::const_iterator ili,ili_fin = soustypeDeCalcul->end();
list <bool>::const_iterator ila;
for (ili = soustypeDeCalcul->begin(),ila = avec_soustypeDeCalcul->begin();
ili!=ili_fin;ili++,ila++)
if (*ila) // cas où le sous type est valide
{if (Remonte_in(*ili)) // on test la présence du calcul de remonté
{ // certaines initialisations sont nécessaires car c'est le premier calcul
Algori::InitRemontSigma(lesMail,lesRef,divStock,charge,lesCondLim,lesContacts,resultats);
Algori::InitErreur(lesMail,lesRef,divStock,charge,lesCondLim,lesContacts,resultats);
Algori::RemontSigma(lesMail);
Algori::RemontErreur(lesMail);
}
else if ( (*ili) == sauveMaillagesEnCours )
{ cout << "\n================================================================="
<< "\n| ecriture des maillages en cours en .her et .lis |"
<< "\n================================================================="
<< endl;
// ----- sort les informations sur fichiers
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
// à partir du nom de chaque maillage au format ".her" et ".lis"
lesMail->Affiche_maillage_dans_her_lis(TEMPS_tdt,*lesRef);
};
};
}
else
// cas ou le type principal n'est pas valide
// on ne fait que le calcul complémentaire
{ list <EnumSousTypeCalcul>::const_iterator ili,ili_fin = soustypeDeCalcul->end();
list <bool>::const_iterator ila;
for (ili = soustypeDeCalcul->begin(),ila = avec_soustypeDeCalcul->begin();
ili!=ili_fin;ili++,ila++)
if (*ila) // cas où le sous type est valide
{if (Remonte_in(*ili)) // on test la présence du calcul de remonté
{ // certaines initialisations sont nécessaires car c'est le premier calcul
Algori::InitRemontSigma(lesMail,lesRef,divStock,charge,lesCondLim,lesContacts,resultats);
Algori::InitErreur(lesMail,lesRef,divStock,charge,lesCondLim,lesContacts,resultats);
Algori::RemontSigma(lesMail);
Algori::RemontErreur(lesMail);
}
else if ( (*ili) == sauveMaillagesEnCours )
{ cout << "\n================================================================="
<< "\n| ecriture des maillages en cours en .her et .lis |"
<< "\n================================================================="
<< endl;
// ----- sort les informations sur fichiers
// Affichage des donnees des maillages dans des fichiers dont le nom est construit
// à partir du nom de chaque maillage au format ".her" et ".lis"
lesMail->Affiche_maillage_dans_her_lis(TEMPS_0,*lesRef);
};
};
};
};
// si on a forcé la sortie des itérations et incréments, il faut réinitialiser l'indicateur
if (!(pa.EtatSortieEquilibreGlobal()))
pa.ChangeSortieEquilibreGlobal(false);
};
// lecture des paramètres du calcul
void AlgoriNewmark::lecture_Parametres(UtilLecture& entreePrinc)
{ // dimensionnement
paraTypeCalcul.Change_taille(3); // donc le troisième est nulle par défaut
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(DYNA_IMP); // transfert info
MotCle motCle; // ref aux mots cle
deja_lue_entete_parametre = 1; // a priori pas de lecture d'entête
// on se positionne sur le prochain mot clé
do
{ entreePrinc.NouvelleDonnee();
}
while ( !motCle.SimotCle(entreePrinc.tablcar)) ;
// si le mot clé est "PARA_TYPE_DE_CALCUL" cela signifie
// qu'il y a un paramètre à lire
bool lecture_effective = false;
if (strstr(entreePrinc.tablcar,"PARA_TYPE_DE_CALCUL")!=NULL)
{ //cas de la définition de paramètres
// on signale à Algori qu'il y a eu déjà une lecture de paramètre
deja_lue_entete_parametre=2;
// lecture du premier paramètres de l'algorithme
entreePrinc.NouvelleDonnee(); // ligne suivante
if (strstr(entreePrinc.tablcar,"hht")!=NULL)
{ // cas de la méthode hht, dans ce cas les paramètres beta et gamma sont fixés
// le seul paramètre à lire est donc le hht c'est-à-dire alpha
// lecture du nom du paramètre et vérification
string st1;
*(entreePrinc.entree) >> st1 ;
if (st1 == "beta_et_gamma=")
{ cout << "\n erreur en lecture du parametre de l'algorithme newmark "
<< "\n on attendait le mot : hht= , au lieu de " << st1
<< "\n dans la methode hht les parametres beta et gamma sont definit à partir de hht"
<< "\n AlgoriNewmark::lecture_Parametres( ... ";
Sortie(1);
}
// lecture du paramètre hht
*(entreePrinc.entree) >> paraTypeCalcul(3);
lecture_effective=true;
hht = & paraTypeCalcul(3);
// on calcul les paramètres beta et gamma
paraTypeCalcul(1) = (1.- (*hht))*(1.- (*hht))/4.;
paraTypeCalcul(2) = 1./2. - (*hht);
beta_newmark = & paraTypeCalcul(1);
gamma_newmark = & paraTypeCalcul(2);
stabilite=true;
}
else
// cas de la méthode de newmark classique
{ // lecture du nom du paramètre et vérification
string st1;
*(entreePrinc.entree) >> st1 ;
if (st1 != "beta_et_gamma=")
{ cout << "\n erreur en lecture du parametre de l'algorithme de newmark "
<< "\n on attendait le mot : beta_et_gamma= , au lieu de " << st1
<< "\n AlgoriNewmark::lecture_Parametres( ... ";
Sortie(1);
}
// lecture du parametre
*(entreePrinc.entree) >> paraTypeCalcul(1) >> paraTypeCalcul(2);
lecture_effective=true;
// on relie les paramètres à béta et gamma
beta_newmark = & paraTypeCalcul(1);
gamma_newmark = & paraTypeCalcul(2);
// si gamma n'est pas supérieur à 0.5 il ne peut pas y avoir stabilité même conditionnelle
// hughes p.94, an. 1983 (belytschko et hughes)
if ((*gamma_newmark) < 0.5)
{ cout << "\n erreur sur le parametre gamma de l'algorithme de newmark "
<< "\n gamma doit etre superieur a 0.5 quelque soit la stabilite requise " << st1
<< "\n AlgoriNewmark::lecture_Parametres( ... ";
Sortie(1);
}
hht = & paraTypeCalcul(3); // le troisième est nulle par défaut donc ici == 0
// vérification de la stabilité
if ((2. *(*beta_newmark)) >= (*gamma_newmark))
{ // cas d'une stabilité inconditionnelle
stabilite=true;}
else { stabilite = false;} // stabilité conditionnelle
};
// si on a déjà lue une ligne on passe à l'enreg suivant
if ((lecture_effective) && ( !motCle.SimotCle(entreePrinc.tablcar)))
{entreePrinc.NouvelleDonnee(); // ligne suivante
lecture_effective = false; // on re-init pour la suite
};
// -- cas où on veut faire du masse scaling avec éventuellement du pilotage
if(strstr(entreePrinc.tablcar,"avec_pilote_masse_scaling_")!=0)
{avec_masse_scaling = 1;
string nom;
entreePrinc.NouvelleDonnee(); // on se positionne sur un nouvel enreg
// on lit tant que l'on ne rencontre pas la ligne contenant "fin_pilote_masse_scaling_"
// ou un nouveau mot clé global auquel cas il y a pb !!
MotCle motCle; // ref aux mots cle
while (strstr(entreePrinc.tablcar,"fin_pilote_masse_scaling_")==0)
{
// si on a un mot clé global dans la ligne courante c-a-d dans tablcar --> erreur
if ( motCle.SimotCle(entreePrinc.tablcar))
{ cout << "\n erreur de lecture des parametre de reglage de masse scaling: on n'a pas trouve le mot cle "
<< " fin_pilote_masse_scaling_ et par contre la ligne courante contient un mot cle global ";
entreePrinc.MessageBuffer("** erreur des parametres de pilotage de masse scaling **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// lecture d'un mot clé
*(entreePrinc.entree) >> nom;
if ((entreePrinc.entree)->rdstate() == 0)
{} // lecture normale
#ifdef ENLINUX
else if ((entreePrinc->entree)->fail())
// on a atteind la fin de la ligne et on appelle un nouvel enregistrement
{ entreePrinc->NouvelleDonnee(); // lecture d'un nouvelle enregistrement
*(entreePrinc->entree) >>nom;
}
#else
else if ((entreePrinc.entree)->eof())
// la lecture est bonne mais on a atteind la fin de la ligne
{ if(nom != "fin_pilote_masse_scaling_")
{entreePrinc.NouvelleDonnee(); *(entreePrinc.entree) >> nom;};
}
#endif
else // cas d'une erreur de lecture
{ cout << "\n erreur de lecture inconnue ";
entreePrinc.MessageBuffer("** erreur2 des parametres de reglage de masse scaling **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// cas et_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique
if(nom == "et_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique_")
{et_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique=true;
// si on a déjà lue ou au lieu de et -> pas possible -> erreur
if (ou_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique)
{ cout << "\n erreur en lecture on a auparavant: ou_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique_ "
<< " c'est donc incoherent (car incompatible) "
<< "\n AlgoriNewmark::lecture_Parametres(.. " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc.entree) >> ratioForce_inertieSurStatique;
lecture_effective = true;
}
// cas ou_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique
else if(nom == "ou_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique_")
{ou_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique=true;
// si on a déjà lue et au lieu de ou -> pas possible -> erreur
if (et_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique)
{ cout << "\n erreur en lecture on a auparavant: et_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique_ "
<< " c'est donc incoherent (car incompatible) "
<< "\n AlgoriNewmark::lecture_Parametres(.. " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc.entree) >> ratioForce_inertieSurStatique;
lecture_effective = true;
}
// cas ou_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur
else if(nom == "ou_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur_")
{ou_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur=true;
// si on a déjà lue et au lieu de ou -> pas possible -> erreur
if (et_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur)
{ cout << "\n erreur en lecture on a auparavant: et_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur_ "
<< " c'est donc incoherent (car incompatible) "
<< "\n AlgoriNewmark::lecture_Parametres(.. " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc.entree) >> ratioDiag_masseSurRaideur;
lecture_effective = true;
}
// cas et_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur
else if(nom == "et_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur_")
{et_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur=true;
// si on a déjà lue ou au lieu de et -> pas possible -> erreur
if (ou_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur)
{ cout << "\n erreur en lecture on a auparavant: ou_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur_ "
<< " c'est donc incoherent (car incompatible) "
<< "\n AlgoriNewmark::lecture_Parametres(.. " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
*(entreePrinc.entree) >> ratioDiag_masseSurRaideur;
lecture_effective = true;
}
// sinon ce n'est pas un mot clé connu, on le signale
else if(nom != "fin_pilote_masse_scaling_")
{ cout << "\n erreur en lecture d'un parametre, le mot cle est inconnu "
<< " on a lu : " << nom << endl;
if (ParaGlob::NiveauImpression()>3)
cout << "\n AlgoriNewmark::lecture_Parametres( " << endl ;
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
}; //-- fin du while
}; //-- fin de la lecture des paramètres de réglage du masse scaling
// on prépare la prochaine lecture si la lecture a été effective et que l'on n'est pas
// sur un mot clé
if ((lecture_effective) && ( !motCle.SimotCle(entreePrinc.tablcar)))
{entreePrinc.NouvelleDonnee(); // ligne suivante
lecture_effective = false; // on re-init pour la suite
};
//---- autres paramètres particuliers ---
// on s'arrête lorsqu'il n'y a plus de mot clé spécifique à lire
while ( (strstr(entreePrinc.tablcar,"cL_a_chaque_iteration_")!=NULL)
)
{ string nom_mot_cle="";
*(entreePrinc.entree) >> nom_mot_cle;
if (nom_mot_cle == "cL_a_chaque_iteration_")
{ // on lit le paramètre
*(entreePrinc.entree) >> cL_a_chaque_iteration;
lecture_effective = true;
}
// gestion des fins de ligne
if ( ((strstr(entreePrinc.tablcar,"cL_a_chaque_iteration_")==NULL)
)
&& ((lecture_effective) && ( !motCle.SimotCle(entreePrinc.tablcar)))
)
// s'il n'y a plus rien et que l'on vient de lire dans ce cas on tente la ligne suivante
{entreePrinc.NouvelleDonnee(); // ligne suivante
lecture_effective = false; // on re-init pour la suite
};
#ifdef ENLINUX
if ((entreePrinc.entree)->fail())
// on a atteind la fin de la ligne et on appelle un nouvel enregistrement
{ entreePrinc.NouvelleDonnee(); // lecture d'un nouvelle enregistrement
}
#else
if ((entreePrinc.entree)->eof())
// la lecture est bonne mais on a atteind la fin de la ligne
{ entreePrinc.NouvelleDonnee(); // lecture d'un nouvelle enregistrement
}
// #endif
#endif
// sinon ce n'est pas une ligne ad hoc, la lecture s'arrêtera
}; // -- fin du while sur les paramètres particulier
}
else // sinon on met une valeur par défaut
{ paraTypeCalcul(1) = 0.25; paraTypeCalcul(2) = 0.5;paraTypeCalcul(3) = 0.;
beta_newmark = & paraTypeCalcul(1);
gamma_newmark = & paraTypeCalcul(2);
hht = & paraTypeCalcul(3); //c-a-d 0 par défaut
stabilite=true;
cL_a_chaque_iteration = 0;
};
// on vérifie que la valeur hht lue conduit à un algo inconditionnellement stable
if (((*hht) < -(1./3.)) || ((*hht) > 0))
cout << "\n *** attention le parametre de la methode HHT est en dehors de l'interval [-1/3,0]"
<< " la stabilite sera donc conditionnellement stable !!"
<< " \n cependant aucune modification du pas de temps propose par l'utilisateur n'est realise"
<< " \n la stabilite est donc a controler par l'utilisateur !!";
// on prépare la prochaine lecture si la lecture a été effective et que l'on n'est pas
// sur un mot clé
if ((lecture_effective) && ( !motCle.SimotCle(entreePrinc.tablcar)))
entreePrinc.NouvelleDonnee(); // ligne suivante
// puis appel de la méthode de la classe mère
Algori::lecture_Parametres(entreePrinc);
};
// écriture des paramètres dans la base info
// = 1 : on écrit tout
// = 2 : on écrot uniquement les données variables (supposées comme telles)
void AlgoriNewmark::Ecrit_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas)
{
// récup du flot
ofstream * sort = entreePrinc.Sort_BI();
// (*sort) << "\n parametres_algo_specifiques_ "<< Nom_TypeCalcul(this->TypeDeCalcul());
if (cas == 1)
{ // ecriture des parametres
*(sort) << " beta_et_gamma= " << paraTypeCalcul(1) << " "
<< paraTypeCalcul(2) << " ";
// écriture du paramètre hht
*(sort) << " hht= " << paraTypeCalcul(3) << " ";
// et le paramètre
*(sort) << " cL_a_chaque_iteration "<< cL_a_chaque_iteration << " ";
};
// (*sort) << "\n fin_parametres_algo_specifiques_ ";
};
// lecture des paramètres dans la base info
// = 1 : on récupère tout
// = 2 : on récupère uniquement les données variables (supposées comme telles)
// choix = true : fonctionnememt normal
// choix = false : la méthode ne doit pas lire mais initialiser les données à leurs valeurs par défaut
// car la lecture est impossible
void AlgoriNewmark::Lecture_Base_info_Parametre(UtilLecture& entreePrinc,const int& cas,bool choix)
{if (cas == 1)
{// dimensionnement
paraTypeCalcul.Change_taille(3);
if (choix)
{// cas d'une lecture normale
// récup du flot
ifstream * ent = entreePrinc.Ent_BI();
string toto;
// lecture du premier parametre
*(ent) >> toto ;
if (toto != "beta_et_gamma=")
{ cout << "\n erreur en lecture du parametre de l'algorithme explicite "
<< "\n on attendait le mot : beta_et_gamma= , au lieu de " << toto
<< "\n AlgoriNewmark::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> paraTypeCalcul(1) >> paraTypeCalcul(2);
// idem pour le paramètre hht
*(ent) >> toto >> paraTypeCalcul(3);
// lecture de cL_a_chaque_iteration
*(ent) >> toto ;
if (toto != "cL_a_chaque_iteration")
{ cout << "\n erreur en lecture du parametre cL_a_chaque_iteration"
<< "\n on attendait le mot : cL_a_chaque_iteration , au lieu de " << toto
<< "\n AlgoriNewmark::Lecture_Base_info_Parametre( ... ";
Sortie(1);
}
*(ent) >> cL_a_chaque_iteration ;
}
else
{// cas où la lecture n'est pas possible, attribution des valeurs par défaut
paraTypeCalcul(1) = 0.25; paraTypeCalcul(2) = 0.5;paraTypeCalcul(3) = 0.;
cL_a_chaque_iteration = 0;
}
// on relie les paramètres à béta et gamma
beta_newmark = & paraTypeCalcul(1);
gamma_newmark = & paraTypeCalcul(2);
hht = & paraTypeCalcul(3);
}
};
// création d'un fichier de commande: cas des paramètres spécifiques
void AlgoriNewmark::Info_commande_parametres(UtilLecture& entreePrinc)
{ // écriture dans le fichier de commande
ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
sort << "\n#-------------------------------------------------------------------"
<< "\n| parametres (falcultatifs) associes l'algorithme de Newmark |"
<< "\n#-------------------------------------------------------------------"
<< "\n"
<< "\n PARA_TYPE_DE_CALCUL"
<< "\n # ..........................................................."
<< "\n # / facteur beta puis facteur gamma, (ou facteur hht) /"
<< "\n # / (dans le cas de la methode hht: beta et gamma sont fixe)/"
<< "\n # / ( il ne sont donc pas à indiquer ) /"
<< "\n #..........................................................."
<< "\n # hht= 0.05 "
<< "\n beta_et_gamma= 0.25 0.5 "
<< "\n # ................................................................"
<< "\n # / mise en place des conditions limites a chaque iteration /"
<< "\n #.................................................................."
<< "\n # mot cle : cL_a_chaque_iteration_ suivi de 0 ou 1 "
<< "\n # par defaut == 0, c-a-d que les CL sont mises en place "
<< "\n # au debut de chaque increment et ensuite reste fixe pendant les iterations "
<< "\n # == 1 : a chaque iteration, les CL sont de nouveaux imposes "
<< "\n ";
// appel de la classe mère
Algori::Info_com_parametres(entreePrinc);
sort << "\n" << endl;
};
// gestion et vérification du pas de temps et modif en conséquence si nécessaire
// cas = 1: initialisation du pas de temps et de l'amortissement numérique si nécessaire
// ceci pour le temps t=0
// cas = 2: initialisation du pas de temps
// ceci pour le temps t
void AlgoriNewmark::Gestion_pas_de_temps(LesMaillages * lesMail,int cas)
{ bool modif_deltat = false; // booleen pour la prise en compte éventuelle de la modif du temps éventuelle
static double coef_delta_crit; // coef multiplicateur du pas critique
if (cas==1)
{ // dans le cas où le pas de temps ou le pas de temps maxi dépendent d'un pas critique,
// ou dans le cas où la stabilitée est conditionnelle on calcul le pas de temps critique
// et on met à jour les pas de temps
if ((pa.DeltatOuDeltatmaxDependantTempsCritique())|| !stabilite)
// on calcul le pas de temps minimal pour cela on utilise
// les caractéristiques dynamiques d'une biellette de longueur
// valant le minimum d'un coté d'arrête
{ // --<NM>-- on calcul le pas de temps minimal
delta_t = pa.Deltat(); double delta_t_old = delta_t;
double l_sur_c = lesMail->Longueur_arrete_mini_sur_c(TEMPS_0);
double delta_t_essai = l_sur_c ;
if (!stabilite) // calcul du delta t critique conditionnel
{ coef_delta_crit = ConstMath::Pi * pow((0.5 * (*gamma_newmark) - (*beta_newmark)),-0.5);
delta_t_essai *= coef_delta_crit;
}
// mise à jour éventuel du pas de temps et du pas de temps maxi et mini s'ils sont définit à partir du temps critique,
// par contre il n'y a pas adéquation entre le deltat et les mini et maxi
modif_deltat = pa.Modif_Deltat_DeltatMaxi(delta_t_essai,l_sur_c); // mais pas de test vis-a-vis des bornes
delta_t = pa.Deltat(); // mise à jour éventuelle du pas de temps
// maintenant on vérifie le pas de temps choisit
if (!stabilite && (pa.Limit_temps_stable() && ( delta_t > delta_t_essai)))
{ cout << "\n ** ATTENTION ** , l'increment de temps propose : " << delta_t
<< ", ne satisfait pas la condition de stabilite conditionnelle de Newmark, "
<< "\n on le regle donc pour que cette condition soit satisfaite: nouvel increment: "
<< delta_t_essai;
delta_t = delta_t_essai;
// modification de l'increment de temps dans les paramètres
switch (pa.Modif_Deltat(delta_t))
{ case -1: { cout << "\n initialisation du pas de temps avec la condition de Courant impossible, le nouveau pas"
<< "\n de temps calcule est plus petit que le pas de temps mini limite: " << pa.Deltatmini();
Sortie(1); break;
}
case 0: { break;} // cas normal
case 1: { pa.Modif_Detat_dans_borne(delta_t);
cout << "\n >>>> rectification du pas de temps "<<delta_t_old<<" dans les bornes : nouvel increment:" << delta_t;
break;
} // cas ou on dépasse la borne maxi
};
modif_deltat=true;
};
// on modifie éventuellement le pas de temps dans les bornes mini et maxi
if (pa.Modif_Detat_dans_borne(delta_t))
{ cout << "\n **** modification du pas de temps "<<delta_t_old<<" entre les bornes mini et maxi "
<< " le nouveau pas de temps = "<<delta_t<<endl;
};
};
delta_t = pa.Deltat();
delta_t_2 = delta_t * delta_t;
unSurBetaDeltaTcarre = 1./delta_t_2/(*beta_newmark);
betaDelta_t_2 = (*beta_newmark) * delta_t_2;
// def de coeffs simplificateurs
betaMoinsGammaSurBeta = ((*beta_newmark)-(*gamma_newmark))/(*beta_newmark);
unSurGammaDeltat = 1./( (*gamma_newmark)* delta_t);
unMoinGamma = 1. - (*gamma_newmark);
unMoinGammasurgamma = unMoinGamma/(*gamma_newmark);
zero5deltatcarreUnMoinDeuxBeta= (0.5 * (delta_t*delta_t)) * ((1.- 2. * (*beta_newmark)));
zero5deltatcarredeuxBeta = (0.5 * (delta_t*delta_t)) * (2. * (*beta_newmark));
deltatUnMoinGamma = delta_t * (1.-(*gamma_newmark));
deltatGamma = delta_t * (*gamma_newmark);
unsurbetadeltat = 1./( (*beta_newmark) * delta_t);
unmoinsdeuxbetasurdeuxbeta = (1.-2.*(*beta_newmark))/(2.*(*beta_newmark));
// cas de l'amortissement numérique
nuAphaPrime=0.; coef_masse = 1.; nuAphaPrimeunsurcoef_masse = 0.;
unsurcoef_masse =1.; nuBetaPrime=0.; coef_raideur = 1.;
// dans le cas où l'on utilise de l'amortissement numérique, calcul des coefs
// 1° la matrice masse vaux théoriquement : (1/(beta*delta t2) + nu * alphaPrime * gamma/(beta*delta t)) [M]
// mais ici dans le programme on utilise [M]/(beta delta t2), donc pour tenir compte de la viscosité il faut
// multiplier cette viscosité dynamique par le coef : coef_masse
// 2° la matrice raideur vaux théoriquement (1. + nu*betaPrime*gamme / (beta*Delta t))[K] d'où le coef coef_raideur
// 3° pour le second membre on a pour la partie visqueuse: [C] qPoint = nu(alphaPrime[M] + betaPrime[K]) qPoint
// mais on utilisera pour plus de facilité, la prémultiplication des vecteurs ce qui permettra de ne pas
// modifier les matrices d'où les coef nuAphaPrimeBetatDelta_t_2 et nuBetaPrime, le premier étant particulier
// parceque l'on utilise une matrice masse modifiée
if (pa.Amort_visco_artificielle())
{if (pa.CoefRayleighMasse()!=0.)
{nuAphaPrime = pa.Visco_artificielle() * pa.CoefRayleighMasse();
coef_masse= betaDelta_t_2 * (unSurBetaDeltaTcarre + nuAphaPrime * (*gamma_newmark)*unsurbetadeltat);
unsurcoef_masse = 1./coef_masse;
nuAphaPrimeunsurcoef_masse = nuAphaPrime * unsurcoef_masse;
};
if (pa.CoefRayleighRaideur()!=0.)
{ nuBetaPrime = pa.Visco_artificielle() * pa.CoefRayleighRaideur();
coef_raideur = 1. + nuBetaPrime * (*gamma_newmark)*unsurbetadeltat;
};
};
}
else if (cas==2)
{ // dans le cas ou la stabilité est conditionnelle
// on regarde si le pas de temps n'est pas devenu supérieur au pas critique
if (!stabilite)
{ double l_sur_c = lesMail->Longueur_arrete_mini_sur_c(TEMPS_t);
double delta_t_essai = l_sur_c * coef_delta_crit ;double ancien_pas=delta_t;
// on intervient que si le nouveau pas de temps critique est inférieur au pas de temps en cours
if ( delta_t_essai < delta_t)
{// mise à jour éventuel du pas de temps et du pas de temps maxi s'ils sont définit à partir du temps critique
bool modif = pa.Modif_Deltat_DeltatMaxi(delta_t_essai,l_sur_c); // mais pas de test vis-a-vis des bornes
// s'il y a eu modif du pas de temps on met à jour le pas courant
if (modif) { delta_t = pa.Deltat(); modif_deltat=true;}
// maintenant on vérifie néanmoins le pas de temps choisit au cas où
// en particulier cette vérification n'est en fait pas utile si l'utilisateur
// à utilisé un facteur du pas critique < 1
if (pa.Limit_temps_stable() && ( delta_t > delta_t_essai))
{ delta_t = pa.Coefficient_pas_critique_deltat() * delta_t_essai;
// modification de l'increment de temps dans les paramètres
switch (pa.Modif_Deltat(delta_t))
{case -1: { cout << "\n **** modification du pas de temps impossible,"
<< " le nouveau pas de temps calcule est plus petit que le pas de temps mini limite: "
<< pa.Deltatmini();
Sortie(1); break;
}
case 0: { break;} // cas normal
case 1: { pa.Modif_Detat_dans_borne(delta_t); break;} // cas ou on dépasse la borne maxi
};
modif_deltat=true;
}
if (modif_deltat)
cout << "\n --->>>> modif increment de temps de " << ancien_pas << " a " << delta_t;
}
} // -- fin du cas de la stabilité conditionnelle
// maintenant on regarde le cas ou on a définit des temps maxi et/ou min, dépendants du pas de temps critique
if (pa.DeltatOuDeltatmaxDependantTempsCritique())
// on calcul le pas de temps minimal pour cela on utilise
// les caractéristiques dynamiques d'une biellette de longueur
// valant le minimum d'un coté d'arrête
{ // --<NM>-- on calcul le pas de temps minimal
double delta_t_old = delta_t;
double l_sur_c = lesMail->Longueur_arrete_mini_sur_c(TEMPS_0);
double delta_t_essai = l_sur_c ;
// mise à jour éventuel du pas de temps et du pas de temps maxi et mini s'ils sont définit à partir du temps critique,
// par contre il n'y a pas adéquation entre le deltat et les mini et maxi
modif_deltat = pa.Modif_Deltat_DeltatMaxi(delta_t_essai,l_sur_c); // mais pas de test vis-a-vis des bornes
delta_t = pa.Deltat(); // mise à jour éventuelle du pas de temps
// maintenant on vérifie le pas de temps choisit
// on modifie éventuellement le pas de temps dans les bornes mini et maxi
if (pa.Modif_Detat_dans_borne(delta_t))
{ cout << "\n **** modification du pas de temps "<<delta_t_old<<" entre les bornes mini et maxi "
<< " le nouveau pas de temps = "<<delta_t<<endl;
};
};
delta_t = pa.Deltat(); delta_t_2 = delta_t * delta_t;
// mise à jour du coef de la matrice de masse en fonction de la nouvelle
// valeur de unSurBetaDeltaTcarre
unSurBetaDeltaTcarre_o = unSurBetaDeltaTcarre; // sauvegarde de l'ancienne facteur de la matrice masse
unSurBetaDeltaTcarre = 1./delta_t_2/(*beta_newmark); // nouvelle valeur
betaDelta_t_2 = (*beta_newmark) * delta_t_2;
// mise à jour des coeffs simplificateurs
unSurGammaDeltat = 1./( (*gamma_newmark)* delta_t);
zero5deltatcarreUnMoinDeuxBeta= (0.5 * (delta_t*delta_t)) * ((1.- 2. * (*beta_newmark)));
zero5deltatcarredeuxBeta = (0.5 * (delta_t*delta_t)) * (2. * (*beta_newmark));
deltatUnMoinGamma = delta_t * (1.-(*gamma_newmark));
deltatGamma = delta_t * (*gamma_newmark);
unsurbetadeltat = 1./( (*beta_newmark) * delta_t);
// cas où l'on utilise de l'amortissement numérique, calcul des coefs (cf intro visqueux au début du programme)
coef_masse = 1.; // initialisation
if (pa.Amort_visco_artificielle())
{ if (Arret_A_Equilibre_Statique()) // si on veut un équilibre statique, on sauvegarde les forces statiques
(*vglob_stat) = vglobaal;
if (pa.CoefRayleighMasse()!=0.)
{nuAphaPrime = pa.Visco_artificielle() * pa.CoefRayleighMasse();
coef_masse= betaDelta_t_2 * (unSurBetaDeltaTcarre + nuAphaPrime * (*gamma_newmark)*unsurbetadeltat);
unsurcoef_masse = 1./coef_masse;
nuAphaPrimeunsurcoef_masse = nuAphaPrime * unsurcoef_masse;
};
if (pa.CoefRayleighRaideur()!=0.)
{ nuBetaPrime = pa.Visco_artificielle() * pa.CoefRayleighRaideur();
coef_raideur = 1. + nuBetaPrime * (*gamma_newmark)*unsurbetadeltat;
};
};
} //-- fin du cas == 2
};
// pilotage éventuel du masse scaling
void AlgoriNewmark::Pilotage_masse_scaling(const double& moy_diag_masse,const double& moy_diag_K
,const int& sauve_indic_convergence)
{
// on adapte en fonction de la cible si on a une différence de plus de 3%
const double diffPermi=0.03;
double multi=5.; // init
if (sauve_indic_convergence >= 0)
{if ( ((et_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur)
&& (Dabs(moy_diag_K)>ConstMath::trespetit)
)
&& ((et_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur)
&& (Dabs(moy_diag_K)>ConstMath::trespetit)
)
)
{// on calcul le rapport
double ratio_actuel_1 = moy_diag_masse/moy_diag_K;
double ratio_actuel_2 = (P_acc_t+ConstMath::trespetit)/(Dabs(- P_int_t - P_ext_t)+ConstMath::trespetit);
if (Dabs(ratioDiag_masseSurRaideur/ratio_actuel_1) > Dabs(ratioDiag_masseSurRaideur/ratio_actuel_2))
{if (diffpourcent(ratio_actuel_1,ratioDiag_masseSurRaideur,ratioDiag_masseSurRaideur,diffPermi))
{(*mat_masse) *= Dabs(ratioDiag_masseSurRaideur/ratio_actuel_1);
if (ParaGlob::NiveauImpression()>3)
cout << "\n Pilotage_masse_scaling diag : modif coeff mat_mass= "<< Dabs(ratioDiag_masseSurRaideur/ratio_actuel_1)
<< endl;
}
else
{if (diffpourcent(ratio_actuel_2,ratioForce_inertieSurStatique,ratioForce_inertieSurStatique,diffPermi))
{(*mat_masse) *= Dabs(ratioForce_inertieSurStatique/ratio_actuel_2);
if (ParaGlob::NiveauImpression()>3)
{cout << "\n Pilotage_masse_scaling puiss : modif coeff mat_mass= "<< Dabs(ratioForce_inertieSurStatique/ratio_actuel_2);
cout << "\n debug: P_acc_t= "<<P_acc_t<<", abs(- P_int_t - P_ext_t)= "<< Dabs(- P_int_t - P_ext_t)
<< " ratio_actuel= "<<ratio_actuel_2<<", ratio_cible= "<<ratioForce_inertieSurStatique;
cout << endl;
};
};
};
};
}
else if ((et_pilotage_masse_scaling_par_maxRatioDiag_masseSurRaideur)
&& (Dabs(moy_diag_K)>ConstMath::trespetit))
{// on calcul le rapport
double ratio_actuel = moy_diag_masse/moy_diag_K;
if (diffpourcent(ratio_actuel,ratioDiag_masseSurRaideur,ratioDiag_masseSurRaideur,diffPermi))
{(*mat_masse) *= Dabs(ratioDiag_masseSurRaideur/ratio_actuel);
if (ParaGlob::NiveauImpression()>3)
cout << "\n Pilotage_masse_scaling: modif coeff mat_mass= "<< Dabs(ratioDiag_masseSurRaideur/ratio_actuel)
<< endl;
};
}
else if (et_pilotage_masse_scaling_par_maxRatioForce_inertieSurStatique)
{// on calcul le rapport. Pour cela on se sert des puissances déjà stockées
// pour éviter des divergences au moment des itérations, on utilise les grandeurs à t
double ratio_actuel = (P_acc_t+ConstMath::trespetit)/(Dabs(- P_int_t - P_ext_t)+ConstMath::trespetit);
if (diffpourcent(ratio_actuel,ratioForce_inertieSurStatique,ratioForce_inertieSurStatique,diffPermi))
{(*mat_masse) *= Dabs(ratioForce_inertieSurStatique/ratio_actuel);
if (ParaGlob::NiveauImpression()>3)
{cout << "\n Pilotage_masse_scaling: modif coeff mat_mass= "<< Dabs(ratioForce_inertieSurStatique/ratio_actuel);
cout << "\n debug: P_acc_t= "<<P_acc_t<<", abs(- P_int_t - P_ext_t)= "<< Dabs(- P_int_t - P_ext_t)
<< " ratio_actuel= "<<ratio_actuel<<", ratio_cible= "<<ratioForce_inertieSurStatique;
cout << endl;
};
};
};
}
// si on a eu une divergence on multiplie par un coef l'augmentation de masse
else //if (sauve_indic_convergence < 0)
{ if (ParaGlob::NiveauImpression()>3)
cout << "\n Pilotage_masse_scaling: divergence donc multi mat_mass= "<< multi
<< endl;
(*mat_masse) *= multi;
};
};
//---- gestion des commndes interactives --------------
// écoute et prise en compte d'une commande interactive
// ramène true tant qu'il y a des commandes en cours
bool AlgoriNewmark::ActionInteractiveAlgo()
{ cout << "\n commande? ";
return false;
};
Reference in a new issue Copy permalink