Herezh_dev/Algo/AlgorithmeCombiner/AlgoriCombine2.cc

445 lines
22 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-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "AlgoriCombine.h"
#include "MatBand.h"
#include <cmath>
//------- décomposition en 3 du calcul d'équilibre -------------
// a priori : InitAlgorithme et FinCalcul ne s'appellent qu'une fois,
// par contre : CalEquilibre peut s'appeler plusieurs fois, le résultat sera différent si entre deux calcul
// certaines variables ont-été changés
// initialisation
void AlgoriCombine::InitAlgorithme(ParaGlob * paraGlob,LesMaillages * lesMail,
LesReferences* lesRef,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,VariablesExporter* varExpor
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage,
Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts
,Resultats* resultats)
{ // INITIALISATION globale
tempsInitialisation.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(COMBINER); // transfert info
// on s'occupe des fonctions nD de pilotage
// 1) cas de choix_algo
if ((nom_choix_algo.length()) && (choix_algo == NULL))
// cas où on doit récupérer la fonction nD
{choix_algo = lesFonctionsnD->Trouve(nom_choix_algo);
if (choix_algo->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
{// on vérifie qu'en retour on a un 2 scalaires
choix_algo->Valeur_pour_variables_globales(); // pour simplifier
if (choix_algo->NbComposante() != 1)
{cout << "\n *** erreur parametre AlgoriCombine: la fonction nD " << nom_choix_algo
<< " qui permet de faire le choix de l'algo interne a utiliser "
<< " ne retourne pas 1 scalaire !! a priori ce n'est pas correct ";
Sortie(1);
};
}
else
{cout << "\n *** erreur parametre AlgoriCombine: la fonction nD " << nom_choix_algo
<< " qui permet de faire le choix de l'algo interne a utiliser "
<< " utilise des variables autres que globales, ce n'est pas possible ! ";
Sortie(1);
};
};
// 2) cas de la validation et sauvegarde
if ((nom_gestion_sauvegarde.length()) && (gestion_sauvegarde == NULL))
// cas où on doit récupérer la fonction nD
{gestion_sauvegarde = lesFonctionsnD->Trouve(nom_gestion_sauvegarde);
if (gestion_sauvegarde->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
{// on vérifie qu'en retour on a un scalaire
gestion_sauvegarde->Valeur_pour_variables_globales(); // pour simplifier
if (gestion_sauvegarde->NbComposante() != 1)
{cout << "\n *** erreur parametre AlgoriCombine: la fonction nD " << nom_gestion_sauvegarde
<< " qui permet le pilotage de la sauvegarde "
<< " ne retourne pas un scalaire unique !! a priori ce n'est pas correct ";
Sortie(1);
};
}
else
{cout << "\n *** erreur parametre AlgoriCombine: la fonction nD " << nom_gestion_sauvegarde
<< " qui permet le pilotage de la sauvegarde "
<< " utilise des variables autres que globales, ce n'est pas possible ! ";
Sortie(1);
};
};
// 3) gestion de la sortie à convergence de chaque algo
if ((nom_gestion_sortie_a_convergence.length()) && (gestion_sortie_a_convergence == NULL))
// cas où on doit récupérer la fonction nD
{gestion_sortie_a_convergence = lesFonctionsnD->Trouve(nom_gestion_sortie_a_convergence);
if (gestion_sortie_a_convergence->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
{// on vérifie qu'en retour on a un scalaire
gestion_sortie_a_convergence->Valeur_pour_variables_globales(); // pour simplifier
if (gestion_sortie_a_convergence->NbComposante() != 1)
{cout << "\n *** erreur parametre AlgoriCombine: la fonction nD " << nom_gestion_sortie_a_convergence
<< " qui permet de piloter la sortie a convergence de chaque algo "
<< " ne retourne pas un scalaire unique !! a priori ce n'est pas correct ";
Sortie(1);
};
}
else
{cout << "\n *** erreur parametre AlgoriCombine: la fonction nD " << nom_gestion_sortie_a_convergence
<< " qui permet de piloter la sortie a convergence de chaque algo "
<< " utilise des variables autres que globales, ce n'est pas possible ! ";
Sortie(1);
};
};
// on passe en revue tous les algorithmes et on les initialise
int nb_algo = tab_algo.Taille();
for (int i=1;i<=nb_algo;i++)
{ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
tab_algo(i)->InitAlgorithme(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor
,lesLoisDeComp,diversStockage,charge,lesCondLim,lesContacts,resultats);
};
// on regarde s'il y a besoin de sauvegarde
// explication: cela ce fait ici, car au niveau de chaque sous-algo, l'ouverture en écriture a été gelée
// du fait que chaque sous algo n'est pas le maitre, ceci pour éviter une sucession d'ouverture écritures
// mais il faut quand même finir par ouvrir en écriture si cela est demandé après toutes les lectures
if (this->Active_sauvegarde())
{ // on récupère la position de restart lue par le dernier algo
// récupération de la position lue par l'algo dans le .BI, changé lors d'un restart par exemple
// il s'agit de la sauvegarde par l'algo de la position qu'il a lue en restart
debut_increment = tab_algo(nb_algo)->Debut_increment();
//&& (ParaGlob::param->TypeCalcul_maitre() == this->typeCalcul) )
// si le fichier base_info n'est pas en service on l'ouvre
entreePrinc->Ouverture_base_info("ecriture");
// dans le cas ou se n'est pas un restart on sauvegarde l'incrément actuel
// c'est-à-dire le premier incrément
// après s'être positionné au début du fichier
if (this->Num_restart() == 0)
{ (entreePrinc->Sort_BI())->seekp(0);
int cas = 1;
paraGlob->Ecriture_base_info(*(entreePrinc->Sort_BI()),cas);
this->Ecriture_base_info
(cas,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,lesLoisDeComp,diversStockage
,charge,lesCondLim,lesContacts,resultats,OrdreVisu::INCRE_0);
}
else
{ // sinon on se place dans le fichier à la position du restart
// debut_increment a été définit dans algori (classe mère)
(entreePrinc->Sort_BI())->seekp(debut_increment);
}
};
tempsInitialisation.Arret_du_comptage(); // temps cpu
};
// mise à jour
void AlgoriCombine::MiseAJourAlgo(ParaGlob * paraGlob,LesMaillages * lesMail,
LesReferences* lesRef,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,VariablesExporter* varExpor
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage,
Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts
,Resultats* resultats)
{ // INITIALISATION globale
tempsMiseAjourAlgo.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(COMBINER); // transfert info
// on passe en revue tous les algorithmes et on demande leur mise à jour
int nb_algo = tab_algo.Taille();
for (int i=1;i<=nb_algo;i++)
{ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
tab_algo(i)->MiseAJourAlgo(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor
,lesLoisDeComp,diversStockage,charge,lesCondLim,lesContacts,resultats);
};
tempsMiseAjourAlgo.Arret_du_comptage(); // temps cpu
};
// calcul
// si tb_combiner est non null -> un tableau de 3 fonctions
// - la première fct dit si on doit valider ou non le calcul à convergence ok,
// - la deuxième dit si on doit sortir de la boucle ou non à convergence ok
// - la troisième sert d'indicateur: si == un pointeur nulle, cela signifie qu'au début du
// sous - algo on part pour le calcul final des positions à t, sinon on part des position à tdt
// ==> sert en I/O des sous-algo, chaque sous-algo disant au suivant s'il a valider ou pas
// le paramètre est figé pour le premier algo
//
// si la validation est effectuée, la sauvegarde pour le post-traitement est également effectuée
// en fonction de la demande de sauvegard,
// sinon pas de sauvegarde pour le post-traitement à moins que l'on a demandé un mode debug
// qui lui fonctionne indépendamment
void AlgoriCombine::CalEquilibre(ParaGlob * paraGlob,LesMaillages * lesMail
,LesReferences* lesRef,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,VariablesExporter* varExpor
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage
,Charge* charge,LesCondLim* lesCondLim,LesContacts* lescontacts
,Resultats* resultats,Tableau < Fonction_nD* > * )
{
tempsCalEquilibre.Mise_en_route_du_comptage(); // temps cpu
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(COMBINER); // transfert info
int nb_algo = tab_algo.Taille();
Tableau < Fonction_nD* > * tb_combiner = new Tableau < Fonction_nD* >;
tb_combiner->Change_taille(3,NULL); // init par défaut
// --- mise à jour du numéro de chargement des algos
// le numéro de chargement est initialement déterminé par le premier algo
icharge = tab_algo(1)->Num_increment();
for (int i=1;i<=nb_algo;i++)
tab_algo(i)->Affectation_icharge(icharge);
// concernant la troisième fonction qui gère le départ de chaque sous-algo
// à partir de X_t ou pas,
(*tb_combiner)(3)=NULL; // on part de la position X_t
// ensuite ce sont les sous-algos qui modifient le paramètre
// en fonction du fait qu'il valide ou pas le calcul
// on boucle sur les incréments de charge
bool affichage = true; // affichage a priori de la fin des calculs
while ( (!charge->Fin(icharge,affichage))
&& (charge->Fin(icharge,true)!=2) // si on a dépassé le nombre d'incrément permis on s'arrête dans tous les cas
&& (charge->Fin(icharge,false)!=3) // idem si on a dépassé le nombre d'essai d'incrément permis
// 1er appel avec true: pour affichage et second avec false car c'est déjà affiché
&& (!pa.EtatSortieEquilibreGlobal())
)
{
// l'appel des algos s'effectuent soit successivement si aucune info particulière
// soit en fonction du retour de la fonction choix
if (choix_algo == NULL)
{// cas où on passe les algos successivement dans l'ordre de leurs définitions
for (int i=1;i<=nb_algo;i++)
{// avant tout chose, on met à jour
// //------ debug
// cout << "\n ********* debug calequilibre Combiner: "
// << " tab_algo(1)->pa.Deltat()= " << tab_algo(1)->pa.Deltat()
// << "\n tab_algo(2)->pa.Deltat()= " << tab_algo(2)->pa.Deltat()
// << "\n tab_algo(3)->pa.Deltat()= " << tab_algo(3)->pa.Deltat() << flush;
// //--- fin debug
ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
bool aff_incr=pa.Vrai_commande_sortie(icharge,temps_derniere_sauvegarde); // pour simplifier
if (aff_incr)
cout << "\n---------------------------------------------------------------------"
<< "\n >>>> algorithme ("<< i <<"): "
<< Nom_TypeCalcul(tab_algo(i)->TypeDeCalcul())
<< " >>>> "
<< "\n---------------------------------------------------------------------"
<< flush;
tab_algo(i)->MiseAJourAlgo(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor
,lesLoisDeComp,diversStockage,charge,lesCondLim
,lescontacts,resultats
);
// on met à jour tb_combiner
if (gestion_sortie_a_convergence != NULL)
{(*tb_combiner)(2)=gestion_sortie_a_convergence;}
else // sinon par défaut
{(*tb_combiner)(2)=cst_1; // sortie de boucle à la convergence propre à l'algo
};
if (gestion_sauvegarde != NULL)
{(*tb_combiner)(1)=gestion_sauvegarde;}
else // sinon c'est le dernier algo qui sauvegarde par défaut
{if (i != nb_algo)
{(*tb_combiner)(1)=cst_0;}// pas de validation
else // pour le dernier algo
{(*tb_combiner)(1)=cst_1;}; // validation
};
// //------ debug
// cout << "\n ********* debug calequilibre Combiner: "
// << " tab_algo(1)->pa.Deltat()= " << tab_algo(1)->pa.Deltat()
// << "\n tab_algo(2)->pa.Deltat()= " << tab_algo(2)->pa.Deltat()
// << "\n tab_algo(3)->pa.Deltat()= " << tab_algo(3)->pa.Deltat() << flush;
// //--- fin debug
// puis on calcul l'équilibre
tab_algo(i)->CalEquilibre(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor
,lesLoisDeComp,diversStockage,charge,lesCondLim,lescontacts,resultats
,tb_combiner);
// //------ debug
// cout << "\n ********* debug calequilibre Combiner: apres tab_algo(i)->CalEquilibre "
// << " tab_algo(1)->pa.Deltat()= " << tab_algo(1)->pa.Deltat()
// << "\n tab_algo(2)->pa.Deltat()= " << tab_algo(2)->pa.Deltat()
// << "\n tab_algo(3)->pa.Deltat()= " << tab_algo(3)->pa.Deltat() << flush;
// //--- fin debug
// s'il y a une fctnD de sauvegarde on garde le numéro du dernier sous-algo qui a sauvegardé
// car c'est le seul important pour la sauvegarde
if (gestion_sauvegarde != NULL)
{if ((bool) gestion_sauvegarde->Valeur_pour_variables_globales()(1))
{nb_dernier_algo_qui_a_fait_une_sauvegarde = i;};
}
else // sinon c'est le dernier par défaut qui sauvegarde
{nb_dernier_algo_qui_a_fait_une_sauvegarde = nb_algo; };
};
// récup du numéro de chargement
icharge = tab_algo(nb_algo)->Num_increment(); // c'est le dernier qui sauvegarde
}
else // sinon il existe une fonction de choix, on s'en sert
{ bool sans_changement_increment = true;
do
{int i = choix_algo->Valeur_pour_variables_globales()(1);
if ((i >0)&&(i <= nb_algo))
{// on met à jour
ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
bool aff_incr=pa.Vrai_commande_sortie(icharge,temps_derniere_sauvegarde); // pour simplifier
if (aff_incr)
cout << "\n---------------------------------------------------------------------"
<< "\n >>>> algorithme ("<< i <<"): "
<< Nom_TypeCalcul(tab_algo(i)->TypeDeCalcul())
<< " >>>> "
<< "\n---------------------------------------------------------------------"
<< flush;
tab_algo(i)->MiseAJourAlgo(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor
,lesLoisDeComp,diversStockage,charge,lesCondLim
,lescontacts,resultats
);
// on met à jour tb_combiner
if (gestion_sortie_a_convergence != NULL)
{(*tb_combiner)(2)=gestion_sortie_a_convergence;}
else // sinon par défaut
{(*tb_combiner)(2)=cst_1; // sortie de boucle à la convergence propre à l'algo
};
if (gestion_sauvegarde != NULL)
{(*tb_combiner)(1)=gestion_sauvegarde;}
else // sinon c'est le dernier algo qui sauvegarde par défaut
{if (i != nb_algo)
{(*tb_combiner)(1)=cst_0;}// pas de validation
else // pour le dernier algo
{(*tb_combiner)(1)=cst_1;}; // validation
};
// puis on calcul l'équilibre
tab_algo(i)->CalEquilibre(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor
,lesLoisDeComp,diversStockage,charge,lesCondLim,lescontacts,resultats
,tb_combiner);
// récup du numéro de chargement
icharge = tab_algo(i)->Num_increment();
}
else
{cout << "\n erreur** la fonction de choix d'algo indique l'algo num: "<< i
<< " qui n'a pas ete defini !! on ne peut pas continuer "
<< "\n AlgoriCombine::CalEquilibre(..."<<flush;
Sortie(1);
};
// on regarde s'il était demandé une validation
sans_changement_increment = !((bool) gestion_sauvegarde->Valeur_pour_variables_globales()(1));
// si on a sauvegardé on va sortir de la boucle, on sauvegarde le num d'algo
if (!sans_changement_increment)
nb_dernier_algo_qui_a_fait_une_sauvegarde = i;
} while (sans_changement_increment);
};
// --- mise à jour du numéro de chargement pour tous les algos
for (int i=1;i<=nb_algo;i++)
tab_algo(i)->Affectation_icharge(icharge);
}; // fin du while
tempsCalEquilibre.Arret_du_comptage(); // temps cpu
};
// dernière passe
void AlgoriCombine::FinCalcul(ParaGlob * paraGlob,LesMaillages * lesMail,LesReferences* lesRef
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,VariablesExporter* varExpor
,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage,
Charge* charge,LesCondLim* lesCondLim,LesContacts* lesContacts,Resultats* resultats)
{
// fin des calculs
Transfert_ParaGlob_ALGO_GLOBAL_ACTUEL(COMBINER); // transfert info
// // on passe en revue tous les algorithmes et on demande la fin des calculs
// non, sinon on a plusieurs dernières sauvegardes !!
// donc on ne sauvegarde la fin que via le dernier sous_algo qui a sauvegardé
int nb_algo = tab_algo.Taille();
// for (int i=1;i<=nb_algo;i++)
int i=nb_dernier_algo_qui_a_fait_une_sauvegarde;
{ParaGlob::param->Change_ParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
charge->ChangeParaAlgoControle(tab_algo(i)->ParaAlgoControle_de_lalgo());
tab_algo(i)->FinCalcul(paraGlob,lesMail,lesRef,lesCourbes1D,lesFonctionsnD,varExpor
,lesLoisDeComp,diversStockage,charge,lesCondLim,lesContacts,resultats);
};
};
//---- 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 AlgoriCombine::ActionInteractiveAlgo()
{ cout << "\n commande? ";
return false;
};
// sortie du schemaXML: en fonction de enu
void AlgoriCombine::SchemaXML_Algori(ofstream& sort,const Enum_IO_XML enu) const
{
switch (enu)
{ case XML_TYPE_GLOBAUX :
{
break;
}
case XML_IO_POINT_INFO :
{
break;
}
case XML_IO_POINT_BI :
{
break;
}
case XML_IO_ELEMENT_FINI :
{
break;
}
case XML_ACTION_INTERACTIVE :
{sort << "\n <!-- ********** algorithme implicite non dynamique ******************** -->"
<< "\n<xs:complexType name=\"INIT\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> initialisation de l'algo "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n</xs:complexType>";
sort << "\n<xs:complexType name=\"EXECUTION\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> execution de l'ensemble de l'algo, sans l'initialisation et la derniere passe "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n</xs:complexType>";
sort << "\n<xs:complexType name=\"FIN_ALGO_EXPLI\" >"
<< "\n <xs:annotation>"
<< "\n <xs:documentation> fin de l'algo "
<< "\n </xs:documentation>"
<< "\n </xs:annotation>"
<< "\n</xs:complexType>";
break;
}
case XML_STRUCTURE_DONNEE :
{
break;
}
};
};