intégration des différents chargements: répertoire "Chargement"
This commit is contained in:
parent
5da18302a8
commit
0fc9c9c349
9 changed files with 7720 additions and 0 deletions
1248
Chargement/BlocCharge.cc
Normal file
1248
Chargement/BlocCharge.cc
Normal file
File diff suppressed because it is too large
Load diff
260
Chargement/BlocCharge.h
Normal file
260
Chargement/BlocCharge.h
Normal file
|
|
@ -0,0 +1,260 @@
|
|||
|
||||
// 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/>.
|
||||
|
||||
/************************************************************************
|
||||
* DATE: 28/01/2004 *
|
||||
* $ *
|
||||
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
|
||||
* $ *
|
||||
* PROJET: Herezh++ *
|
||||
* $ *
|
||||
************************************************************************
|
||||
* BUT: Gestion de divers bloc courant du fichier de lecture . *
|
||||
* Cas où ces blocs sont relatif au chargement. *
|
||||
* $ *
|
||||
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
|
||||
* VERIFICATION: *
|
||||
* *
|
||||
* ! date ! auteur ! but ! *
|
||||
* ------------------------------------------------------------ *
|
||||
* ! ! ! ! *
|
||||
* $ *
|
||||
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
|
||||
* MODIFICATIONS: *
|
||||
* ! date ! auteur ! but ! *
|
||||
* ------------------------------------------------------------ *
|
||||
* $ *
|
||||
************************************************************************/
|
||||
#ifndef BLOC_CHARGE_H
|
||||
#define BLOC_CHARGE_H
|
||||
|
||||
#include "Bloc.h"
|
||||
#include "LesFonctions_nD.h"
|
||||
#include "Noeud.h"
|
||||
|
||||
//================================================
|
||||
// cas d'un bloc type pour charge pour
|
||||
//================================================
|
||||
// un bloc e type correspond a une reference
|
||||
// un mot cle, et une seule valeur
|
||||
// un nom de courbe de charge
|
||||
// une échelle
|
||||
|
||||
/// @addtogroup Groupe_concernant_le_chargement
|
||||
/// @{
|
||||
///
|
||||
|
||||
|
||||
class BlocScalVecTypeCharge : public BlocGeneEtVecMultType
|
||||
{
|
||||
// surcharge de l'operator de lecture
|
||||
friend istream & operator >> (istream &, BlocScalVecTypeCharge &);
|
||||
// surcharge de l'operator d'ecriture
|
||||
friend ostream & operator << (ostream &, const BlocScalVecTypeCharge &);
|
||||
public :
|
||||
// VARIABLES PUBLIQUES :
|
||||
// stockage d'un element
|
||||
// class conforme a la specif de T de la class LectBloc_T
|
||||
|
||||
// Constructeur
|
||||
BlocScalVecTypeCharge () ; // par defaut
|
||||
// avec : n: le nombre de vecteurs, m le nombre de scalaires , n le nombre de ptnom
|
||||
BlocScalVecTypeCharge(int n,int m);
|
||||
// de copie
|
||||
BlocScalVecTypeCharge (const BlocScalVecTypeCharge& a) ; // de copie
|
||||
// destructeur
|
||||
~BlocScalVecTypeCharge () {};
|
||||
|
||||
// mise en place de l'association des fonctions nD, dont ensuite on garde un pointeur
|
||||
// en retour indique si l'association est ok: ici rien n'a faire
|
||||
bool Mise_en_place_des_fonction_nD(const LesFonctions_nD& lesFonctionsnD)
|
||||
{ return true;};
|
||||
|
||||
//-------- les méthodes constantes --------------
|
||||
// indique si c'est une référence de champ ou pas
|
||||
// = 0 : ce n'est pas une référence de champ
|
||||
// = 1 : c'est une référence de champ de valeur
|
||||
// = 2 : c'est une référence de champ de fonctions
|
||||
int Champ() const {return champ;};
|
||||
// affichage des informations
|
||||
void Affiche() const ;
|
||||
// surcharge des operateurs
|
||||
bool operator == ( const BlocScalVecTypeCharge& a) const
|
||||
{ return ( (this->BlocGeneEtVecMultType::operator==(a))
|
||||
&& (champ == a.champ ) ) ;
|
||||
};
|
||||
bool operator != ( const BlocScalVecTypeCharge& a) const
|
||||
{ return !(*this == a);};
|
||||
|
||||
//------------- les méthodes qui modifient -------------
|
||||
// lecture d'un bloc
|
||||
void Lecture(UtilLecture & entreePrinc);
|
||||
BlocScalVecTypeCharge& operator = (const BlocScalVecTypeCharge& a);
|
||||
|
||||
protected :
|
||||
int champ; // indique si c'est une référence de champ ou pas
|
||||
// = 0 : ce n'est pas une référence de champ
|
||||
// = 1 : c'est une référence de champ de valeur
|
||||
// = 2 : c'est une référence de champ de fonctions
|
||||
|
||||
// lecture dans le cas particulier d'un champ de valeurs
|
||||
void Lecture_champ_de_valeurs(UtilLecture & entreePrinc);
|
||||
// lecture dans le cas particulier d'un champ de fonctions
|
||||
void Lecture_champ_de_fonctions(UtilLecture & entreePrinc);
|
||||
|
||||
};
|
||||
/// @} // end of group
|
||||
|
||||
|
||||
/// @addtogroup Groupe_concernant_le_chargement
|
||||
/// @{
|
||||
///
|
||||
|
||||
/// bloc spécialisé pour les forces
|
||||
class BlocForces : public BlocScalVecTypeCharge
|
||||
{
|
||||
public :
|
||||
// Constructeur
|
||||
BlocForces () : BlocScalVecTypeCharge(1,0) {}; // par defaut
|
||||
};
|
||||
/// @} // end of group
|
||||
|
||||
|
||||
/// @addtogroup Groupe_concernant_le_chargement
|
||||
/// @{
|
||||
///
|
||||
|
||||
/// bloc spécialisé pour les intensités
|
||||
class BlocIntensite : public BlocScalVecTypeCharge
|
||||
{
|
||||
public :
|
||||
// Constructeur
|
||||
BlocIntensite () : BlocScalVecTypeCharge(0,1) {}; // par defaut
|
||||
};
|
||||
/// @} // end of group
|
||||
|
||||
|
||||
/// @addtogroup Groupe_concernant_le_chargement
|
||||
/// @{
|
||||
///
|
||||
|
||||
/// ---- bloc pour un torseur vers forces ponctuelles ----
|
||||
|
||||
class PTorseurPonct : public BlocGen
|
||||
{ public : // surcharge de l'operator de lecture
|
||||
friend istream & operator >> (istream & entree, PTorseurPonct & coo);
|
||||
// surcharge de l'operator d'ecriture
|
||||
friend ostream & operator << (ostream & sort, const PTorseurPonct & coo);
|
||||
//Constructeur par défaut
|
||||
PTorseurPonct ();
|
||||
// constructeur de copie
|
||||
PTorseurPonct (const PTorseurPonct & a);
|
||||
|
||||
// mise en place de l'association des fonctions nD, dont ensuite on garde un pointeur
|
||||
// en retour indique si l'association est ok
|
||||
bool Mise_en_place_des_fonction_nD(const LesFonctions_nD& lesFonctionsnD);
|
||||
// récup du nom de maillage et du nom de la ref éventuelle de noeuds
|
||||
// pour le centre du moment
|
||||
Deux_String Nom_Ref_pour_Ce() const
|
||||
{return Deux_String(nom_mail_ref_pour_Ce,nom_ref_pour_Ce);}
|
||||
// mise en place des infos pour le centre si celui-ci dépend des noeuds
|
||||
// en retour indique si c'est ok
|
||||
bool Def_tab_noeud_pour_centre(const list <const Noeud * > li_noe_ref_centre);
|
||||
// calcul éventuel et retour de la résultante (qui peut varier)
|
||||
// M: indique un point dont peut dépendre les éléments du torseur
|
||||
Coordonnee& Resultante(const Coordonnee& M );
|
||||
// calcul éventuel et retour du moment (qui peut varier)
|
||||
// M: indique un point dont peut dépendre les éléments du torseur
|
||||
Coordonnee& Moment(const Coordonnee& M );
|
||||
// calcul éventuel et retour du centre du moment (qui peut varier)
|
||||
// M: indique un point dont peut dépendre les éléments du torseur
|
||||
Coordonnee& Centre( );
|
||||
// calcul de l'effort ponctuelle correspondant au torseur
|
||||
// pour la position passée en paramètres
|
||||
// tab_P: tableau des points où sont exprimés les forces équivalentes au torseur
|
||||
// t_force : tableau des forces calculées, équivalentes au torseur
|
||||
void Force(const Tableau <Coordonnee >& tab_P, Tableau <Coordonnee >& t_force);
|
||||
|
||||
// affichage des informations
|
||||
void Affiche() const ;
|
||||
// surcharge des operateurs
|
||||
bool operator == (const PTorseurPonct& a) const;
|
||||
bool operator != (const PTorseurPonct& a) const
|
||||
{ return !(*this == a);};
|
||||
// lecture d'un bloc
|
||||
void Lecture(UtilLecture & entreePrinc);
|
||||
|
||||
// surcharge d'affectation
|
||||
PTorseurPonct& operator = (const PTorseurPonct& a);
|
||||
|
||||
// affichage et definition interactive des commandes
|
||||
// plusieurs_maillages : indique s'il y a ou pas
|
||||
// renvoi : true s'il y a effectivement une écriture
|
||||
bool Info_commande_Charges(bool plusieurs_maillages, UtilLecture & entreePrinc);
|
||||
|
||||
|
||||
protected :
|
||||
|
||||
Coordonnee Re; // résultante du torseur
|
||||
string nom_fnD_Re; // nom éventuelle de la fonction associée
|
||||
Fonction_nD* fnD_Re; // fonction nD associée, éventuelle
|
||||
Coordonnee Mo; // composantes du moment
|
||||
string nom_fnD_Mo; // nom éventuelle de la fonction associée
|
||||
Fonction_nD* fnD_Mo; // fonction nD associée, éventuelle
|
||||
Coordonnee Ce; // centre pour le calcul du moment
|
||||
Fonction_nD* fnD_Ce; // fonction nD associée, éventuelle
|
||||
string nom_fnD_Ce; // nom éventuelle de la fonction associée
|
||||
|
||||
// cas d'un centre à partir de position de noeud(s)
|
||||
const Noeud* noe_Ce; // noeud centre éventuel
|
||||
int num_noeud; // numéro du centre
|
||||
Enum_dure temps_noe_Ce; // si noeud centre ou centre de gravité: temps associé
|
||||
string nom_ref_pour_Ce; // si centre de gravité d'une ref de noeud
|
||||
string nom_mail_ref_pour_Ce; // le maillage associé soit à
|
||||
Tableau <const Noeud * > tab_noe_ref_centre; // tableau des noeuds qui correspondent à ref_pour_Ce
|
||||
// s'il y a un seul élément, c'est le même que noe_Ce
|
||||
int type_centre; // = 1 : centre fixe // par défaut
|
||||
// = 2 : centre fonction nD
|
||||
// = 3 : centre noeud
|
||||
// = 4 : centre de gravité d'une ref de noeud
|
||||
string nom_fnD_poids; // nom éventuelle de la fonction des poids
|
||||
// associé à CP_i et aux grandeurs globales
|
||||
Fonction_nD* fnD_poids; // fonction nD associée, éventuelle
|
||||
// ------- variable de travail -------
|
||||
Tableau <double > t_poids; // tableau de travail
|
||||
Tableau <Coordonnee > t_vec; // idem
|
||||
|
||||
|
||||
};
|
||||
/// @} // end of group
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
695
Chargement/BlocCharge_T.h
Normal file
695
Chargement/BlocCharge_T.h
Normal file
|
|
@ -0,0 +1,695 @@
|
|||
|
||||
// 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/>.
|
||||
|
||||
/************************************************************************
|
||||
* DATE: 28/01/2004 *
|
||||
* $ *
|
||||
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
|
||||
* $ *
|
||||
* PROJET: Herezh++ *
|
||||
* $ *
|
||||
************************************************************************
|
||||
* BUT: Gestion de divers bloc courant du fichier de lecture . *
|
||||
* Cas où ces blocs sont relatif au chargement, et héritent *
|
||||
* de bloc classiques. *
|
||||
* $ *
|
||||
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
|
||||
* VERIFICATION: *
|
||||
* *
|
||||
* ! date ! auteur ! but ! *
|
||||
* ------------------------------------------------------------ *
|
||||
* ! ! ! ! *
|
||||
* $ *
|
||||
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
|
||||
* MODIFICATIONS: *
|
||||
* ! date ! auteur ! but ! *
|
||||
* ------------------------------------------------------------ *
|
||||
* $ *
|
||||
************************************************************************/
|
||||
#ifndef BLOC_CHARGE_T_H
|
||||
#define BLOC_CHARGE_T_H
|
||||
|
||||
#include "BlocCharge.h"
|
||||
#include "ConstMath.h"
|
||||
#include "CharUtil.h"
|
||||
|
||||
|
||||
/// @addtogroup Groupe_concernant_le_chargement
|
||||
/// @{
|
||||
///
|
||||
|
||||
//================================================
|
||||
/// class template: cas d'un bloc avec charge
|
||||
//================================================
|
||||
template <class Bloc_particulier>
|
||||
class BlocCharge : public Bloc_particulier
|
||||
{
|
||||
// surcharge de l'operator de lecture
|
||||
friend istream & operator >> (istream & entree, BlocCharge<Bloc_particulier> & coo)
|
||||
{ // tout d'abord la classe mère
|
||||
entree >> ((Bloc_particulier&)(coo));
|
||||
// puis les valeurs propres
|
||||
string toto; string nomOuNombre;
|
||||
entree >> toto >> coo.co_charge >> toto >> coo.echelle;
|
||||
// lecture t_min en fonction d'une fonction nD ou pas
|
||||
entree >> toto >> nomOuNombre;
|
||||
if (nomOuNombre != "fct_nD:")
|
||||
{coo.t_min = ChangeReel(nomOuNombre);
|
||||
coo.nom_fnD_t_min = "";coo.fnD_t_min=NULL;
|
||||
}
|
||||
else
|
||||
{entree >> coo.nom_fnD_t_min;};
|
||||
// lecture t_max en fonction d'une fonction nD ou pas
|
||||
entree >> toto >> nomOuNombre;
|
||||
if (nomOuNombre != "fct_nD:")
|
||||
{coo.t_max = ChangeReel(nomOuNombre);
|
||||
coo.nom_fnD_t_max = "";coo.fnD_t_max=NULL;
|
||||
}
|
||||
else
|
||||
{entree >> coo.nom_fnD_t_max;};
|
||||
// entree >> toto >> coo.t_min >> toto >> coo.t_max;
|
||||
entree >> toto >> coo.precedent >> coo.attribut
|
||||
>> toto >> coo.f_charge;
|
||||
return entree;
|
||||
}
|
||||
// surcharge de l'operator d'ecriture
|
||||
friend ostream & operator << (ostream & sort, const BlocCharge<Bloc_particulier> & coo)
|
||||
{ // tout d'abord la classe mère
|
||||
sort << ((const Bloc_particulier&)(coo));
|
||||
// puis les valeurs propres
|
||||
sort << "\n nom_courbe_de_charge: " << coo.co_charge << " echelle: " << coo.echelle;
|
||||
sort << " temps_mini= " ;
|
||||
if (coo.nom_fnD_t_min == "")
|
||||
{sort << coo.t_min;}
|
||||
else {sort << " fct_nD: " << coo.nom_fnD_t_min ;};
|
||||
sort << " temps_maxi= ";
|
||||
if (coo.nom_fnD_t_max == "")
|
||||
{sort << coo.t_max;}
|
||||
else {sort << " fct_nD: " << coo.nom_fnD_t_max ;};
|
||||
// sort << " temps_mini= " << coo.t_min << " temps_maxi= " << coo.t_max;
|
||||
sort << " activité_actuelle: " << coo.precedent << " attribut: "<< coo.attribut
|
||||
<< " f_charge: "<< coo.f_charge
|
||||
<< endl;
|
||||
return sort;
|
||||
}
|
||||
|
||||
public :
|
||||
// VARIABLES PUBLIQUES :
|
||||
// stockage d'un element
|
||||
// class conforme a la specif de T de la class LectBloc_T
|
||||
|
||||
// Constructeur
|
||||
BlocCharge () : // par defaut
|
||||
Bloc_particulier(),co_charge(""),echelle(1.),f_charge("")
|
||||
,t_min(0.),t_max(ConstMath::tresgrand),precedent(false)
|
||||
,attribut("_")
|
||||
,nom_fnD_t_min(""),fnD_t_min(NULL),nom_fnD_t_max(""),fnD_t_max(NULL)
|
||||
{};
|
||||
BlocCharge (const BlocCharge& a) : // de copie
|
||||
Bloc_particulier(a),co_charge(a.co_charge),echelle(a.echelle)
|
||||
,t_min(a.t_min),t_max(a.t_max),precedent(a.precedent)
|
||||
,attribut(a.attribut),f_charge(a.f_charge)
|
||||
,nom_fnD_t_min(a.nom_fnD_t_min),fnD_t_min(a.fnD_t_min)
|
||||
,nom_fnD_t_max(a.nom_fnD_t_max),fnD_t_max(a.fnD_t_max)
|
||||
{};
|
||||
// destructeur
|
||||
~BlocCharge () {};
|
||||
|
||||
|
||||
|
||||
//-------- les méthodes constantes --------------
|
||||
// retourne le nom de la courbe de charge
|
||||
const string & NomCourbeCharge() const {return co_charge;};
|
||||
// retourne le nom de la fonction nD
|
||||
const string & NomF_charge() const {return f_charge;};
|
||||
// retourne l'échelle
|
||||
const double Echelle_courbe() const {return echelle;};
|
||||
// retourne la chaine de caratères attribut: si = "_" , signifie qu'il n'y a pas d'attribut
|
||||
const string & Attribut() const {return attribut;};
|
||||
// affichage des informations
|
||||
void Affiche() const ;
|
||||
// surcharge des operateurs
|
||||
bool operator == ( const BlocCharge& a) const;
|
||||
BlocCharge& operator = (const BlocCharge& a);
|
||||
bool operator != ( const BlocCharge& a) const;
|
||||
// retour du statut de validation
|
||||
// vrai signifie que l'état enregistré est actif
|
||||
bool Etat_validation() const {return precedent;};
|
||||
|
||||
//------------- les méthodes qui modifient -------------
|
||||
// lecture d'un bloc
|
||||
void Lecture(UtilLecture & entreePrinc);
|
||||
// Validation on non de l'activité de la charge
|
||||
void Validation(const double& temps) {precedent = Temps_actif(temps);};
|
||||
|
||||
// affichage et definition interactive des commandes
|
||||
// attribut : donne un attribut éventuel à afficher dans les choix
|
||||
void Info_commande_BlocCharge(ofstream & sort,string attribut = "_");
|
||||
|
||||
// mise en place de l'association des fonctions nD, dont ensuite on garde un pointeur
|
||||
// en retour indique si l'association est ok
|
||||
bool Mise_en_place_des_fonction_nD(const LesFonctions_nD& lesFonctionsnD);
|
||||
// retourne un booléen qui indique si oui ou non le temps passé en paramètre
|
||||
// est situé entre le temps min et maxi du ddllim
|
||||
bool Temps_actif(const double& temps)
|
||||
{if (fnD_t_min != NULL)
|
||||
{if (fnD_t_min->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
||||
{ t_min = (fnD_t_min->Valeur_pour_variables_globales())(1);}
|
||||
else
|
||||
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD utilisee pour donner le temps mini "
|
||||
<< " seule la dependance aux grandeurs globales est autorisee ";
|
||||
cout << "\n fonction nD: "; fnD_t_min->Affiche();this->Affiche();
|
||||
Sortie(1);
|
||||
};
|
||||
};
|
||||
if (fnD_t_max != NULL)
|
||||
{if (fnD_t_max->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
||||
{ t_max = (fnD_t_max->Valeur_pour_variables_globales())(1);}
|
||||
else
|
||||
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD utilisee pour donner le temps maxi "
|
||||
<< " seule la dependance aux grandeurs globales est autorisee ";
|
||||
cout << "\n fonction nD: "; fnD_t_max->Affiche();this->Affiche();
|
||||
Sortie(1);
|
||||
};
|
||||
};
|
||||
if ((t_min < temps) && (temps <= t_max))
|
||||
return true;
|
||||
else return false;
|
||||
};
|
||||
// ramène vrai si le temps est inférieur au temps actif
|
||||
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
||||
// il n'était pas également actif (? je ne comprends plus pourquoi j'ai fait cette fonction)
|
||||
bool Pas_a_prendre_en_compte(const double& temps)
|
||||
{if (fnD_t_min != NULL)
|
||||
{if (fnD_t_min->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
||||
{ t_min = (fnD_t_min->Valeur_pour_variables_globales())(1);}
|
||||
else
|
||||
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD utilisee pour donner le temps mini "
|
||||
<< " seule la dependance aux grandeurs globales est autorisee ";
|
||||
cout << "\n fonction nD: "; fnD_t_min->Affiche();this->Affiche();
|
||||
Sortie(1);
|
||||
};
|
||||
};
|
||||
if (fnD_t_max != NULL)
|
||||
{if (fnD_t_max->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
||||
{ t_max = (fnD_t_max->Valeur_pour_variables_globales())(1);}
|
||||
else
|
||||
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD utilisee pour donner le temps maxi "
|
||||
<< " seule la dependance aux grandeurs globales est autorisee ";
|
||||
cout << "\n fonction nD: "; fnD_t_max->Affiche();this->Affiche();
|
||||
Sortie(1);
|
||||
};
|
||||
};
|
||||
if ((temps <= t_min) || ((temps > t_max) && !precedent))
|
||||
return true;
|
||||
else return false;
|
||||
};
|
||||
|
||||
|
||||
protected :
|
||||
string co_charge; // nom d'une courbe de charge éventuelle
|
||||
string f_charge; // nom d'une fonction nD utilisant des variables globales et autres
|
||||
double echelle;
|
||||
double t_min,t_max; // temps mini et maxi de durée des ddl imposés
|
||||
string nom_fnD_t_min; // nom éventuelle de la fonction associée
|
||||
Fonction_nD* fnD_t_min; // fonction nD associée, éventuelle
|
||||
string nom_fnD_t_max; // nom éventuelle de la fonction associée
|
||||
Fonction_nD* fnD_t_max; // fonction nD associée, éventuelle
|
||||
int precedent; // pour la description de l'évolution du ddlLim
|
||||
string attribut; // une chaine de caractère qui sert pour donner une
|
||||
// information particularière au Bloc_particulier associé
|
||||
// apparaît uniquement si le mot clé: attribut_ est présent
|
||||
// et est constitué par la chaine qui suit ce mot cle
|
||||
};
|
||||
/// @} // end of group
|
||||
|
||||
|
||||
/// @addtogroup Groupe_concernant_le_chargement
|
||||
/// @{
|
||||
///
|
||||
|
||||
/// lecture d'un bloc
|
||||
template <class Bloc_particulier>
|
||||
void BlocCharge<Bloc_particulier>::Lecture(UtilLecture & entreePrinc)
|
||||
{ // tout d'abord lecture de la classe mère
|
||||
Bloc_particulier::Lecture(entreePrinc);
|
||||
// on regarde s'il y a un attribut ou non, si oui on le lit
|
||||
attribut="_"; // init par défaut
|
||||
if (strstr(entreePrinc.tablcar,"ATTRIBUT_")!=NULL)
|
||||
// cas où il y a un attribut
|
||||
{ string nom;
|
||||
*(entreePrinc.entree) >> nom ;
|
||||
if (nom != "ATTRIBUT_")
|
||||
{cout << "\n erreur de syntaxe en lecture de l'attribut "
|
||||
<< " on attendait le mot cle ATTRIBUT_ et on a lu"
|
||||
<< nom << endl;
|
||||
if (ParaGlob::NiveauImpression() > 4)
|
||||
cout << "\n BlocCharge::Lecture(.. " << endl ;
|
||||
entreePrinc.MessageBuffer("**erreur**");
|
||||
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||||
Sortie(1);
|
||||
}
|
||||
else
|
||||
{*(entreePrinc.entree) >> attribut;};
|
||||
};
|
||||
|
||||
// puis lecture des infos de la classe
|
||||
// on regarde s'il ne s'agit pas d'une courbe de charge imposée
|
||||
if (strstr(entreePrinc.tablcar,"COURBE_CHARGE:")!=NULL)
|
||||
{// cas d'une courbe de charge, on se positionne sur le mot clé
|
||||
string titi4; bool bonnefin4=false;
|
||||
while ((!entreePrinc.entree->rdstate())&& // lecture tant qu'il n'y a pas d'erreur
|
||||
(!(entreePrinc.entree->eof())))
|
||||
{ // lecture du prochain mot
|
||||
*(entreePrinc.entree) >> titi4 ;
|
||||
if (titi4 == "COURBE_CHARGE:"){bonnefin4=true; break;};
|
||||
};
|
||||
if (!bonnefin4)
|
||||
{cout << "\n erreur de syntaxe en lecture du nom de la courbe ";
|
||||
cout << "\n BlocCharge::Lecture(.. " << endl ;
|
||||
entreePrinc.MessageBuffer("**erreur**");
|
||||
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||||
Sortie(1);
|
||||
}
|
||||
else
|
||||
//lecture du nom de la courbe de charge
|
||||
{ *(entreePrinc.entree) >> co_charge; };
|
||||
// on récupère l'échelle éventuellement
|
||||
string toto1;
|
||||
if(strstr(entreePrinc.tablcar,"ECHELLE:")!=0)
|
||||
{ // cas où il y a un facteur d'échelle
|
||||
*(entreePrinc.entree) >> toto1;
|
||||
if (toto1 != "ECHELLE:")
|
||||
{cout << "\n erreur de syntaxe en lecture du facteur d'echelle ";
|
||||
cout << "\n BlocCharge::Lecture(.. " << endl ;
|
||||
entreePrinc.MessageBuffer("**erreur**");
|
||||
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||||
Sortie(1);
|
||||
}
|
||||
// lecture du facteur
|
||||
*(entreePrinc.entree) >> echelle;
|
||||
}; //-- fin récup de l'échelle
|
||||
}; //-- fin récup de la courbe de charge
|
||||
|
||||
// on regarde s'il n'y a pas une fonction nD de chargement
|
||||
if (strstr(entreePrinc.tablcar,"Fonction_nD_CHARGE:")!=NULL)
|
||||
{// cas d'une fonction de charge, on se positionne sur le mot clé
|
||||
string titi4; bool bonnefin4=false;
|
||||
while ((!entreePrinc.entree->rdstate())&& // lecture tant qu'il n'y a pas d'erreur
|
||||
(!(entreePrinc.entree->eof())))
|
||||
{ // lecture du prochain mot
|
||||
*(entreePrinc.entree) >> titi4 ;
|
||||
if (titi4 == "Fonction_nD_CHARGE:"){bonnefin4=true; break;};
|
||||
};
|
||||
if (!bonnefin4)
|
||||
{cout << "\n erreur de syntaxe en lecture du nom de la fonction nD ";
|
||||
cout << "\n BlocCharge::Lecture(.. " << endl ;
|
||||
entreePrinc.MessageBuffer("**erreur**");
|
||||
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||||
Sortie(1);
|
||||
}
|
||||
else
|
||||
//lecture du nom de la fonction de charge
|
||||
{ *(entreePrinc.entree) >> f_charge; };
|
||||
// on récupère l'échelle éventuellement
|
||||
string toto1;
|
||||
if(strstr(entreePrinc.tablcar,"ECHELLE:")!=0)
|
||||
{ // cas où il y a un facteur d'échelle
|
||||
*(entreePrinc.entree) >> toto1;
|
||||
if (toto1 != "ECHELLE:")
|
||||
{cout << "\n erreur de syntaxe en lecture du facteur d'echelle ";
|
||||
cout << "\n BlocCharge::Lecture(.. " << endl ;
|
||||
entreePrinc.MessageBuffer("**erreur**");
|
||||
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||||
Sortie(1);
|
||||
}
|
||||
// lecture du facteur
|
||||
*(entreePrinc.entree) >> echelle;
|
||||
}; //-- fin récup de l'échelle
|
||||
}; //-- fin récup de la courbe de charge
|
||||
|
||||
|
||||
// lecture éventuelle des temp mini et maxi : mais on doit doir d'abord passer éventuellement des infos
|
||||
|
||||
if (strstr(entreePrinc.tablcar,"TEMPS_MINI=") != 0)
|
||||
// on lit jusqu'à trouver le mot clé
|
||||
{ string titi; bool bonnefin=false;
|
||||
while ((!entreePrinc.entree->rdstate())&& // lecture tant qu'il n'y a pas d'erreur
|
||||
(!(entreePrinc.entree->eof())))
|
||||
{ // lecture du prochain mot
|
||||
*(entreePrinc.entree) >> titi ;
|
||||
if (titi == "TEMPS_MINI="){bonnefin=true; break;};
|
||||
};
|
||||
if (!bonnefin)
|
||||
{cout << "\n erreur inconnue de syntaxe en lecture du temps mini";
|
||||
cout << "\n BlocCharge::Lecture(.. " << endl ;
|
||||
entreePrinc.MessageBuffer("**erreur**");
|
||||
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||||
Sortie(1);
|
||||
}
|
||||
else
|
||||
//lecture du temps mini
|
||||
{ string nomOuNombre;
|
||||
*(entreePrinc.entree) >> nomOuNombre;
|
||||
if (nomOuNombre != "fct_nD:")
|
||||
{t_min = ChangeReel(nomOuNombre);
|
||||
nom_fnD_t_min = "";fnD_t_min=NULL;
|
||||
}
|
||||
else
|
||||
{*(entreePrinc.entree) >> nom_fnD_t_min;};
|
||||
//*(entreePrinc.entree) >> t_min;
|
||||
};
|
||||
}; //-- fin du cas temps mini
|
||||
|
||||
if (strstr(entreePrinc.tablcar,"TEMPS_MAXI=") != 0)
|
||||
// on lit jusqu'à trouver le mot clé
|
||||
{ string titi; bool bonnefine=false;
|
||||
while ((!entreePrinc.entree->rdstate())&& // lecture tant qu'il n'y a pas d'erreur
|
||||
(!(entreePrinc.entree->eof())))
|
||||
{ // lecture du prochain mot
|
||||
*(entreePrinc.entree) >> titi ;
|
||||
if (titi == "TEMPS_MAXI="){bonnefine=true; break;};
|
||||
};
|
||||
if (!bonnefine)
|
||||
{cout << "\n erreur inconnue de syntaxe en lecture du temps maxi";
|
||||
cout << "\n BlocCharge::Lecture(.. " << endl ;
|
||||
entreePrinc.MessageBuffer("**erreur**");
|
||||
throw (UtilLecture::ErrNouvelleDonnee(-1));
|
||||
Sortie(1);
|
||||
}
|
||||
else
|
||||
//lecture du temps maxi
|
||||
{ string nomOuNombre;
|
||||
*(entreePrinc.entree) >> nomOuNombre;
|
||||
if (nomOuNombre != "fct_nD:")
|
||||
{t_max = ChangeReel(nomOuNombre);
|
||||
nom_fnD_t_max = "";fnD_t_max=NULL;
|
||||
}
|
||||
else
|
||||
{*(entreePrinc.entree) >> nom_fnD_t_max;};
|
||||
//*(entreePrinc.entree) >> t_max;
|
||||
};
|
||||
}; //-- fin du cas temps maxi
|
||||
}
|
||||
/// @} // end of group
|
||||
|
||||
|
||||
/// @addtogroup Groupe_concernant_le_chargement
|
||||
/// @{
|
||||
///
|
||||
|
||||
/// affichage des infos
|
||||
template <class Bloc_particulier>
|
||||
void BlocCharge<Bloc_particulier>::Affiche() const
|
||||
{ // tout d'abord affichage des infos de la classe mère
|
||||
Bloc_particulier::Affiche();
|
||||
// puis des infos propres
|
||||
cout << "\n nom_courbe_de_charge: " << co_charge << " echelle: " << echelle;
|
||||
cout << " temps_mini= ";
|
||||
if (nom_fnD_t_min == "")
|
||||
{cout << t_min;}
|
||||
else {cout << " fct_nD: " << nom_fnD_t_min ;};
|
||||
cout << " temps_maxi= ";
|
||||
if (nom_fnD_t_max == "")
|
||||
{cout << t_max;}
|
||||
else {cout << " fct_nD: " << nom_fnD_t_max ;};
|
||||
cout << " activite_actuelle: " << precedent << " attribut: "<< attribut << endl
|
||||
<< " f_charge: "<< f_charge;
|
||||
}
|
||||
/// @} // end of group
|
||||
|
||||
|
||||
/// @addtogroup Groupe_concernant_le_chargement
|
||||
/// @{
|
||||
///
|
||||
|
||||
/// surcharge des operateurs
|
||||
template <class Bloc_particulier>
|
||||
bool BlocCharge<Bloc_particulier>::operator == ( const BlocCharge<Bloc_particulier>& a) const
|
||||
{ //if (!(((Bloc_particulier)(*this)) == ((const Bloc_particulier&)(a)) ))
|
||||
if ( !(((Bloc_particulier&)(*this)).operator==(a)) )
|
||||
return false;
|
||||
else
|
||||
{ if ((co_charge == a.co_charge) && (echelle == a.echelle)
|
||||
&& (t_min == a.t_min )&& (t_max == a.t_max )&& (precedent == a.precedent )
|
||||
&& (attribut == a.attribut) && (f_charge == a.f_charge)
|
||||
&& (nom_fnD_t_min == a.nom_fnD_t_min) && (fnD_t_min == a.fnD_t_min)
|
||||
&& (nom_fnD_t_max == a.nom_fnD_t_max) && (fnD_t_max == a.fnD_t_max)
|
||||
)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
}
|
||||
/// @} // end of group
|
||||
|
||||
|
||||
/// @addtogroup Groupe_concernant_le_chargement
|
||||
/// @{
|
||||
///
|
||||
|
||||
template <class Bloc_particulier>
|
||||
BlocCharge<Bloc_particulier>& BlocCharge<Bloc_particulier>::operator
|
||||
= ( const BlocCharge<Bloc_particulier>& a)
|
||||
{ // tout d'abord la classe mère
|
||||
// ((Bloc_particulier)(*this)) = ((const Bloc_particulier&)(a));
|
||||
// ((Bloc_particulier)(*this)) = a ;
|
||||
((Bloc_particulier&)(*this)).operator=(a);
|
||||
// puis les valeurs propres
|
||||
co_charge = a.co_charge; echelle = a.echelle; t_min = a.t_min;
|
||||
t_max = a.t_max; precedent = a.precedent;attribut = a.attribut;
|
||||
f_charge = a.f_charge;
|
||||
nom_fnD_t_min = a.nom_fnD_t_min ; fnD_t_min = a.fnD_t_min;
|
||||
nom_fnD_t_max = a.nom_fnD_t_max ; fnD_t_max = a.fnD_t_max;
|
||||
return *this;
|
||||
}
|
||||
/// @} // end of group
|
||||
|
||||
/// @addtogroup Groupe_concernant_le_chargement
|
||||
/// @{
|
||||
///
|
||||
template <class Bloc_particulier>
|
||||
bool BlocCharge<Bloc_particulier>::operator
|
||||
!= (const BlocCharge<Bloc_particulier>& a) const
|
||||
{ return !(*this == a);}
|
||||
/// @} // end of group
|
||||
|
||||
|
||||
|
||||
/// @addtogroup Groupe_concernant_le_chargement
|
||||
/// @{
|
||||
///
|
||||
|
||||
/// affichage et definition interactive des commandes
|
||||
/// attrib : donne un attribut éventuel à afficher dans les choix
|
||||
template <class Bloc_particulier>
|
||||
void BlocCharge<Bloc_particulier>::Info_commande_BlocCharge
|
||||
(ofstream & sort,string attrib)
|
||||
{ //On va proposer un menu
|
||||
string rep=" ";
|
||||
co_charge="_";
|
||||
f_charge="_";
|
||||
echelle = ConstMath::trespetit;
|
||||
t_min = - ConstMath::trespetit;
|
||||
t_max = ConstMath::tresgrand;
|
||||
|
||||
while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
|
||||
{
|
||||
try
|
||||
{ int nb_choix=5;//valeur par défaut
|
||||
cout
|
||||
<< "\n (0 ou f) (defaut) (fin) "
|
||||
<< "\n (1) utilisation d'une courbe de charge "
|
||||
<< "\n (2) fonction nD de charge "
|
||||
<< "\n (3) echelle "
|
||||
<< "\n (4) temps mini fixe "
|
||||
<< "\n (5) temps maxi fixe "
|
||||
<< "\n (6) temps mini via une fonction nD "
|
||||
<< "\n (7) temps maxi via une fonction nD";
|
||||
if (attrib != "_")
|
||||
{cout << "\n (8) attribut: "<<attrib <<" ";
|
||||
nb_choix=8;
|
||||
};
|
||||
cout << "\n ";
|
||||
// procédure de lecture avec prise en charge d'un retour chariot
|
||||
rep = lect_return_defaut(false,"f");
|
||||
if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie
|
||||
{if (attribut != "_")
|
||||
sort << " ATTRIBUT_ "<<attribut << " ";
|
||||
if (co_charge != "_")
|
||||
sort << " COURBE_CHARGE: "<<co_charge<<" ";
|
||||
if (f_charge != "_")
|
||||
sort << " Fonction_nD_CHARGE: "<<f_charge<<" ";
|
||||
if (echelle != ConstMath::trespetit)
|
||||
sort << " ECHELLE: "<< echelle<<" ";
|
||||
if ((t_min != (- ConstMath::trespetit)) || (nom_fnD_t_min != ""))
|
||||
{ sort << " TEMPS_MINI= ";
|
||||
if (nom_fnD_t_min == "")
|
||||
{sort << t_min << " ";}
|
||||
else {sort << " fct_nD: " << nom_fnD_t_min << " ";};
|
||||
};
|
||||
if ((t_max != ConstMath::tresgrand) || (nom_fnD_t_max != ""))
|
||||
{ sort << " TEMPS_MAXI= ";
|
||||
if (nom_fnD_t_max == "")
|
||||
{sort << t_max << " ";}
|
||||
else {sort << " fct_nD: " << nom_fnD_t_max << " ";};
|
||||
};
|
||||
break;
|
||||
};
|
||||
int num = ChangeEntier(rep);
|
||||
bool choix_valide=false;
|
||||
if ((num >= 0)&&(num<=nb_choix))
|
||||
{ choix_valide=true; }
|
||||
else { cout << "\n Erreur on attendait un entier entre 0 et "<<nb_choix<<" !!, "
|
||||
<< "\n redonnez une bonne valeur"
|
||||
<< "\n ou taper f ou 0 pour arreter le programme";
|
||||
choix_valide=false;
|
||||
}
|
||||
switch (num)
|
||||
{ case 0: // sortie
|
||||
{ break;} // normalement cela a déjà été filtré avant
|
||||
case 1: // courbe de charge
|
||||
{ cout << "\n nom de la courbe de charge ? ";
|
||||
co_charge=lect_chaine();cout << " nom lu = "<< co_charge;
|
||||
break;
|
||||
}
|
||||
case 2: // fonction nD
|
||||
{ cout << "\n nom de la fonction nD de charge ? ";
|
||||
f_charge=lect_chaine();cout << " nom lu = "<< f_charge;
|
||||
break;
|
||||
}
|
||||
case 3: // l'echelle
|
||||
{ cout << "\n valeur de l'echelle (un reel) ? ";
|
||||
echelle=lect_double();cout << " valeur lue = "<< echelle;
|
||||
break;
|
||||
}
|
||||
case 4: // temps mini fixe
|
||||
{ cout << "\n valeur du temps mini fixe(un reel) ? ";
|
||||
t_min=lect_double();cout << " valeur lue = "<< t_min;
|
||||
nom_fnD_t_min=""; // par précaution si plusieurs passes
|
||||
break;
|
||||
}
|
||||
case 5: // temps maxi fixe
|
||||
{ cout << "\n valeur du temps maxi fixe(un reel) ? ";
|
||||
t_max=lect_double();cout << " valeur lue = "<< t_max;
|
||||
nom_fnD_t_max=""; // par précaution si plisieurs passes
|
||||
break;
|
||||
}
|
||||
case 6: // temps mini via une fonction nD
|
||||
{ cout << "\n nom fonction nD pour temps mini (un string) ? ";
|
||||
nom_fnD_t_min=lect_chaine();cout << " valeur lue = "<< nom_fnD_t_min;
|
||||
break;
|
||||
}
|
||||
case 7: // temps maxi via une fonction nD
|
||||
{ cout << "\n nom fonction nD temps maxi (un string) ? ";
|
||||
nom_fnD_t_max=lect_chaine();cout << " valeur lue = "<< nom_fnD_t_max;
|
||||
break;
|
||||
}
|
||||
case 8: // attribut éventuel
|
||||
{cout << "\n ajout de l'attribut "<<attrib <<" (rep o ou n (defaut)) ? ";
|
||||
string reponse="";
|
||||
reponse = lect_return_defaut(false,"n");
|
||||
cout << " valeur lue ="<< reponse;
|
||||
if (Minuscules(reponse) == "o") { attribut = attrib;}
|
||||
else { attribut = "_";};
|
||||
break;
|
||||
}
|
||||
default:
|
||||
cout << "\n le cas "<<rep<<" n'est pas traite !!, bizarre, il faut se plaindre !! ";
|
||||
};
|
||||
}
|
||||
catch (ErrSortieFinale)
|
||||
// cas d'une direction voulue vers la sortie
|
||||
// on relance l'interuption pour le niveau supérieur
|
||||
{ ErrSortieFinale toto;
|
||||
throw (toto);
|
||||
}
|
||||
catch (...)//(UtilLecture::ErrNouvelleDonnee erreur)
|
||||
{ cout << "\n Erreur on attendait un des mots cles proposes !!, "
|
||||
<< "\n redonnez une bonne valeur"
|
||||
<< "\n ou taper f ou 0 pour sortir ";
|
||||
};
|
||||
}; //-- fin du while
|
||||
|
||||
};
|
||||
/// @} // end of group
|
||||
|
||||
|
||||
|
||||
/// @addtogroup Groupe_concernant_le_chargement
|
||||
/// @{
|
||||
///
|
||||
|
||||
/// mise en place de l'association des fonctions nD, dont ensuite on garde un pointeur
|
||||
/// en retour indique si l'association est ok
|
||||
template <class Bloc_particulier>
|
||||
bool BlocCharge<Bloc_particulier>::Mise_en_place_des_fonction_nD(const LesFonctions_nD& lesFonctionsnD)
|
||||
{ bool retour = true;
|
||||
// on regarde et on récupère s'il le faut la fct nD associée avec la résultante du torseur
|
||||
if (nom_fnD_t_min.length())
|
||||
{fnD_t_min = lesFonctionsnD.Trouve(nom_fnD_t_min);
|
||||
if (fnD_t_min != NULL)
|
||||
{// on vérifie qu'en retour on a un scalaire
|
||||
if (fnD_t_min->NbComposante() != 1)
|
||||
{cout << "\n *** erreur dans l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
||||
<< " cas du calcul du temps mini"
|
||||
<< " en retour, le nombre de composante"<< fnD_t_min->NbComposante()
|
||||
<< " est different de 1 "
|
||||
<< endl;
|
||||
Sortie(1);
|
||||
};
|
||||
};
|
||||
};
|
||||
// on regarde et on récupère s'il le faut la fct nD associée avec la résultante du torseur
|
||||
if (nom_fnD_t_max.length())
|
||||
{fnD_t_max = lesFonctionsnD.Trouve(nom_fnD_t_max);
|
||||
if (fnD_t_max != NULL)
|
||||
{// on vérifie qu'en retour on a un scalaire
|
||||
if (fnD_t_max->NbComposante() != 1)
|
||||
{cout << "\n *** erreur dans l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
||||
<< " cas du calcul du temps maxi"
|
||||
<< " en retour, le nombre de composante"<< fnD_t_max->NbComposante()
|
||||
<< " est different de 1 "
|
||||
<< endl;
|
||||
Sortie(1);
|
||||
};
|
||||
};
|
||||
};
|
||||
// puis on appelle la fonction membre identique
|
||||
retour = retour && Bloc_particulier::Mise_en_place_des_fonction_nD(lesFonctionsnD);
|
||||
|
||||
return retour;
|
||||
};
|
||||
/// @} // end of group
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
1305
Chargement/Charge.cc
Normal file
1305
Chargement/Charge.cc
Normal file
File diff suppressed because it is too large
Load diff
428
Chargement/Charge.h
Normal file
428
Chargement/Charge.h
Normal file
|
|
@ -0,0 +1,428 @@
|
|||
|
||||
// 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/>.
|
||||
|
||||
/************************************************************************
|
||||
* DATE: 23/01/97 *
|
||||
* $ *
|
||||
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
|
||||
* $ *
|
||||
* PROJET: Herezh++ *
|
||||
* $ *
|
||||
************************************************************************
|
||||
* BUT: Gestion des chargements. *
|
||||
* Chargement en temps : *
|
||||
* *
|
||||
* ^ *
|
||||
* 1 | t1-------- *
|
||||
* | / *
|
||||
* | / Type 1 = une rampe linéaire *
|
||||
* | / puis un plateau horizontal *
|
||||
* 0------------------> t *
|
||||
* *
|
||||
* *
|
||||
* ^ Type 2 = une rampe linéaire *
|
||||
* 1 | t1-----t2 un plateau puis arrêt *
|
||||
* | / | *
|
||||
* | / | *
|
||||
* | / | *
|
||||
* 0------------------> t *
|
||||
* *
|
||||
* ^ Type 3 = uniquement un plateau *
|
||||
* 1 |------------------- ..... *
|
||||
* | *
|
||||
* | *
|
||||
* | *
|
||||
* 0------------------> t *
|
||||
* *
|
||||
* Type 4 = utilisation d'une courbe 1D quelconque *
|
||||
* *
|
||||
* Type 5 utilisation d'un fichier de points qui *
|
||||
* impose la suite de temps de calcul, donc de pas de temps *
|
||||
* *
|
||||
* $ *
|
||||
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
|
||||
* VERIFICATION: *
|
||||
* *
|
||||
* ! date ! auteur ! but ! *
|
||||
* ------------------------------------------------------------ *
|
||||
* ! ! ! ! *
|
||||
* $ *
|
||||
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
|
||||
* MODIFICATIONS: *
|
||||
* ! date ! auteur ! but ! *
|
||||
* ------------------------------------------------------------ *
|
||||
* $ *
|
||||
************************************************************************/
|
||||
#ifndef CHARGE_H
|
||||
#define CHARGE_H
|
||||
|
||||
#include "LectBloc_T.h"
|
||||
#include "ParaGlob.h"
|
||||
#include "Bloc.h"
|
||||
#include <list>
|
||||
#include "ParaAlgoControle.h"
|
||||
#include "LesMaillages.h"
|
||||
#include "Mat_abstraite.h"
|
||||
#include "Assemblage.h"
|
||||
#include "Nb_assemb.h"
|
||||
#include "Courbe1D.h"
|
||||
#include "BlocCharge_T.h"
|
||||
#include "LesCourbes1D.h"
|
||||
#include "LesFonctions_nD.h"
|
||||
#include "BlocCharge.h"
|
||||
#include "Temps_CPU_HZpp.h"
|
||||
|
||||
|
||||
/** @defgroup Groupe_concernant_le_chargement
|
||||
*
|
||||
* BUT: groupe relatif aux chargements
|
||||
*
|
||||
*
|
||||
* \author Gérard Rio
|
||||
* \version 1.0
|
||||
* \date 23/01/97
|
||||
* \brief groupe relatif aux chargements
|
||||
*
|
||||
*/
|
||||
|
||||
/// @addtogroup Groupe_concernant_le_chargement
|
||||
/// @{
|
||||
///
|
||||
|
||||
|
||||
class Charge
|
||||
{
|
||||
public :
|
||||
// VARIABLES PUBLIQUES :
|
||||
// ---- class intermédiaires -----
|
||||
class PHydro : public BlocGeneEtVecMultType
|
||||
{ public : // surcharge de l'operator de lecture
|
||||
friend istream & operator >> (istream & entree, PHydro & coo)
|
||||
{ entree >> ((BlocGeneEtVecMultType&)(coo)); return entree;};
|
||||
// surcharge de l'operator d'ecriture
|
||||
friend ostream & operator << (ostream & sort, const PHydro & coo)
|
||||
{ sort << ((const BlocGeneEtVecMultType&)(coo)); return sort; };
|
||||
PHydro(); // constructeur par défaut
|
||||
PHydro (const PHydro & a) ; // constructeur par defaut
|
||||
~PHydro () ; // destructeur
|
||||
|
||||
// mise en place de l'association des courbes
|
||||
// en retour indique si l'association est ok
|
||||
bool Mise_en_place_des_courbes(LesCourbes1D& lesCourbes1D);
|
||||
const Coordonnee& Direction_N(); // récup de la direction N normée
|
||||
const Coordonnee& Point_M(); // récup du point de la surface libre
|
||||
protected :
|
||||
Tableau <Courbe1D*> N; // courbes permettant de piloter éventuellement la normale
|
||||
Tableau <Courbe1D*> M; // courbes permettant de piloter éventuellement le point de la surface neutre
|
||||
bool normer; // dans le cas de vecteur N constant, indique si le vecteur a été normé ou pas
|
||||
};
|
||||
class PHydrodyna : public BlocGen
|
||||
{ public : // surcharge de l'operator de lecture
|
||||
friend istream & operator >> (istream & entree, PHydrodyna & coo)
|
||||
{ entree >> ((BlocGen&)(coo)); return entree;};
|
||||
// surcharge de l'operator d'ecriture
|
||||
friend ostream & operator << (ostream & sort, const PHydrodyna & coo)
|
||||
{ sort << ((const BlocGen&)(coo)); return sort; };
|
||||
PHydrodyna () : BlocGen(5,1),frot_fluid(NULL),coef_aero_n(NULL),coef_aero_t(NULL) {};
|
||||
// mise en place de l'association des courbes
|
||||
// en retour indique si l'association est ok
|
||||
bool Mise_en_place_des_courbes(LesCourbes1D& lesCourbes1D);
|
||||
Courbe1D* Frot_fluid() const { return frot_fluid;};
|
||||
Courbe1D* Coef_aero_n() const { return coef_aero_n;};
|
||||
Courbe1D* Coef_aero_t() const { return coef_aero_t;};
|
||||
protected :
|
||||
Courbe1D* frot_fluid; // courbe de frottement fluide
|
||||
Courbe1D* coef_aero_n; // courbe pour l'effort de traînée
|
||||
Courbe1D* coef_aero_t; // courbe pour l'effort de portance
|
||||
};
|
||||
|
||||
|
||||
// ---- fin class intermédiaires -----
|
||||
|
||||
// CONSTRUCTEURS :
|
||||
Charge () ; // constructeur par defaut
|
||||
// DESTRUCTEUR :
|
||||
~Charge () ;
|
||||
|
||||
// METHODES PUBLIQUES :
|
||||
|
||||
// affichage des differents chargements
|
||||
void Affiche() const ; // affiche la totalite
|
||||
void Affiche1() const ; // affiche que la premiere lecture
|
||||
void Affiche2() const ; // affiche que la seconde lecture
|
||||
|
||||
// lecture des differents chargements actions exterieurs imposees
|
||||
void Lecture1(UtilLecture & entreePrinc,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
|
||||
,LesFonctions_nD& lesFonctionsnD);
|
||||
|
||||
// lecture du type d'application du chargements
|
||||
void Lecture2(UtilLecture & entreePrinc,LesCourbes1D& lesCourbes1D
|
||||
,LesFonctions_nD& lesFonctionsnD);
|
||||
|
||||
// initialisation du chargement
|
||||
// on verifie egalement la bonne adequation des references
|
||||
void Initialise(LesMaillages * lesMail,LesReferences* lesRef,ParaAlgoControle& pa
|
||||
,const LesCourbes1D& lesCourbes1D,const LesFonctions_nD& lesFonctionsnD);
|
||||
// dans le cas où on utilise plusieurs algorithmes, il faut pouvoir changer
|
||||
// de paramètres de contrôle
|
||||
void ChangeParaAlgoControle(ParaAlgoControle& pa)
|
||||
{paAlgo = & pa;};
|
||||
|
||||
// avancement de la charge
|
||||
// il peut y avoir plusieurs type d'avancement
|
||||
// en fonction des donnees ( transparent pour l'utilisateur)
|
||||
// mais aussi en fonction des parametres
|
||||
// incrémentation d'un compteur, permet de limiter le nombre d'appel
|
||||
// retourne false par défaut, mais si le pas de temps a été modifié
|
||||
// retourne true !!, car par exemple de la fin du chargement, d'où une modif du pas
|
||||
// pour obtenir exactement la fin
|
||||
bool Avance(); // premier version
|
||||
|
||||
// retour de la charge au cas précédent, c'est à dire
|
||||
// avant le dernier ordre d'avancement
|
||||
// valeur par défaut de "exacte "
|
||||
// si exacte n'est pas présent ou faux: le compteur d'appel de Avance(), n'est pas décrémenté
|
||||
// exacte=true: le compteur d'appel est décrémenté, en fait on revient exactement au départ
|
||||
// ce qui permet d'utiliser plusieurs fois Avance() dans un même pas de temps
|
||||
// en comptabilisant par exemple qu'une seule fois un appel de Avance(), cas d'une intégration
|
||||
// temporelle par exemple
|
||||
void Precedant(bool exacte=false);
|
||||
|
||||
// diminution de l'incrément de charge dans le cas par exemple d'une non convergence
|
||||
// ramène true si la diminution est effective, sinon false
|
||||
bool Diminue_inc_charge(double diminue);
|
||||
// augmentation de l'incrément de charge dans le cas de bonne convergence
|
||||
// ramène true si l'augmentation est effective, sinon false
|
||||
bool Augmente_inc_charge(double augmente);
|
||||
|
||||
// declaration de la fin en fonction du type de chargement
|
||||
// retour:
|
||||
// retour:
|
||||
// 0 : la fin n'est pas valide, on continue
|
||||
// 1 : temps fin dépassé
|
||||
// 2 : compteur_increment dépassé
|
||||
// 3 : compteur_essai_increment dépassé
|
||||
// NB: c'est d'abort le temps fin qui est testé: qui donc conduit à un arrêt normal
|
||||
// puis ensuite le compteur d'incréments
|
||||
// puis le nombre d'essai maxi, puis enfin le cas normal
|
||||
// si affichage est true, affichage d'un message
|
||||
int Fin(const int & icharge,bool affichage = true);
|
||||
|
||||
// retourne l'increment du coef multiplicateur de charge, courant
|
||||
inline double MultCharge()
|
||||
{ return multi;};
|
||||
|
||||
// retourne le coef multiplicateur de charge, courant
|
||||
inline double IntensiteCharge()
|
||||
{ return coeff;};
|
||||
|
||||
// retourne le temps courant ou en est le calcul
|
||||
inline double Temps_courant () {return paAlgo->Variables_de_temps().TempsCourant();};
|
||||
// incrément de temps courant
|
||||
inline double Increment_de_Temps() {return paAlgo->Variables_de_temps().IncreTempsCourant();};
|
||||
|
||||
// la manière dont on vise le temps fin
|
||||
// = 0 par défaut pour les schéma implicite: indique
|
||||
// que l'on doit viser le temps fin de manière stricte (pas le dépasser)
|
||||
// = 1 : on doit juste le dépasser -> a priori c'est le fonctionnement par défaut des
|
||||
// algo explicites, compte tenu qu'il n'y a pas de prise en compte précise
|
||||
// de la variation du pas de temps
|
||||
// mise à jour avec la méthode :
|
||||
void Change_temps_fin_non_stricte(int methode)
|
||||
{temps_fin_non_stricte = methode;};
|
||||
|
||||
// retourne le temps cumulés relatif à tous les chargements
|
||||
const Temps_CPU_HZpp& Temps_cpu_chargement() const {return temps_cpu_chargement;};
|
||||
|
||||
// mise en place du chargement impose sur le second membre global
|
||||
// cas explicite
|
||||
// la variable relative à la classe assemblage est passé en argument ce qui permet d'utiliser
|
||||
// éventuellement plusieurs type d'assemblage
|
||||
// retour false si problème de calcul
|
||||
bool ChargeSecondMembre_Ex_mecaSolid
|
||||
(Assemblage & assemb,LesMaillages * lesMail,LesReferences* lesRef,Vecteur& vecglob
|
||||
,const ParaAlgoControle & pa,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD);
|
||||
|
||||
// cas implicite avec également modification de la raideur quand le chargement dépend
|
||||
// de la géométrie, en fonction des paramètres de pa
|
||||
// la variable relative à la classe assemblage est passé en argument ce qui permet d'utiliser
|
||||
// éventuellement plusieurs type d'assemblage
|
||||
// de plus il faut prévoir un pointeur d'assemblage pour séparer le cas d'assemblage symétrique ou non
|
||||
// d'où la variable pointeur de fonction membre d'assemblage
|
||||
// retour false si problème de calcul
|
||||
bool ChargeSMembreRaideur_Im_mecaSolid(Assemblage & assemb,LesMaillages * lesMail,LesReferences* lesRef
|
||||
,Vecteur& vecglob, Mat_abstraite& matglob
|
||||
,void (Assemblage::* assembMat) // le pointeur de fonction
|
||||
(Mat_abstraite & matglob,const Mat_abstraite & matloc,
|
||||
const DdlElement& tab_ddl,const Tableau<Noeud *>&tab_noeud)
|
||||
,const ParaAlgoControle & pa
|
||||
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD);
|
||||
|
||||
// lecture de donnée en fonction d'un indicateur : int type
|
||||
// pour l'instant ne fait rien
|
||||
void LectureDonneesExternes(UtilLecture& ,LesReferences& ,const int,const string& ) {};
|
||||
|
||||
// affichage et definition interactive des commandes
|
||||
void Info_commande_LesCharges1(UtilLecture & entreePrinc);
|
||||
|
||||
// affichage et definition interactive des commandes
|
||||
void Info_commande_LesCharges2(UtilLecture & entreePrinc);
|
||||
|
||||
//----- lecture écriture dans base info -----
|
||||
// cas donne le niveau de la récupération
|
||||
// = 1 : on récupère tout
|
||||
// = 2 : on récupère uniquement les données variables (supposées comme telles)
|
||||
void Lecture_base_info(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
|
||||
,LesFonctions_nD& lesFonctionsnD);
|
||||
// cas donne le niveau de sauvegarde
|
||||
// = 1 : on sauvegarde tout
|
||||
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
|
||||
void Ecriture_base_info(ofstream& sort,const int cas);
|
||||
|
||||
private :
|
||||
// VARIABLES PROTEGEES :
|
||||
// les forces sont les entitees duales des degres de liberte
|
||||
// par exemple, force ponctuelle est duale de Xi ou Ui ou Vi
|
||||
|
||||
// densite de force volumique dans le repère absolu
|
||||
Tableau < BlocCharge< BlocDdlLim<BlocForces> > > tabFvol;
|
||||
// densite de force surfacique dans le repère absolu
|
||||
Tableau < BlocCharge< BlocDdlLim<BlocForces> > > tabFsurfac;
|
||||
// pression uniformement reparti, appliquee normalement a la surface
|
||||
Tableau < BlocCharge< BlocDdlLim<BlocIntensite> > > tabPresUnif;
|
||||
// force ponctuelle sur un noeud
|
||||
Tableau < BlocCharge< BlocDdlLim<BlocForces> > > tabPonctuel;
|
||||
// pression unidirectionnelle type pression des fluides
|
||||
Tableau < BlocCharge< BlocDdlLim<BlocForces> > > PresUniDir;
|
||||
// pression hydrostatique
|
||||
Tableau < BlocCharge< BlocDdlLim<PHydro> > > PresHydro;
|
||||
// pression hydrodynamique
|
||||
Tableau < BlocCharge< BlocDdlLim<PHydrodyna> > > coefHydroDyna;
|
||||
// densite de force lineique dans le repère absolu
|
||||
Tableau < BlocCharge< BlocDdlLim<BlocForces> > > tabFlineique;
|
||||
// densite de force lineique suiveuse, c'est-à-dire qui suit le repère
|
||||
// locale (possible uniquement pour des éléments 2D)
|
||||
Tableau < BlocCharge< BlocDdlLim<BlocForces> > > tabFlineiqueSuiv;
|
||||
// torseur d'effort via une répartition de charges ponctuelles
|
||||
Tableau < BlocCharge< BlocDdlLim<PTorseurPonct> > > tabTorseurPonct;
|
||||
Tableau < Tableau < Coordonnee > > tab_P; // tableau de travail pour tabTorseurPonct
|
||||
Tableau < Tableau < Coordonnee > > t_force; // idem
|
||||
|
||||
// ---- type d'application du chargement -----
|
||||
string nomtypeCharge; // mot cle du type de chargement
|
||||
Tableau<double> tabType; // les parametres
|
||||
Courbe1D* f_charge; // courbe de chargement éventuelle
|
||||
bool interne_f_charge; // indique si oui ou non la courbe interne
|
||||
int ancien_num_pt_type5, num_pt_courant_type5; // variables de travaille pour le type 5
|
||||
|
||||
// les paramètres globaux
|
||||
ParaAlgoControle* paAlgo;
|
||||
// le parametre global d'avancement de la charge
|
||||
// double temps;
|
||||
// compteur d'increment
|
||||
int compteur_essai_increment;
|
||||
// multi = l'increment courant de multiplication de la charge
|
||||
// coeff = niveau actuel de la charge
|
||||
double multi,coeff;
|
||||
// la sauvegarde des paramètres d'un pas sur l'autre
|
||||
double temps_sauve;
|
||||
double multi_sauve,coeff_sauve;
|
||||
|
||||
// la manière dont on vise le temps fin
|
||||
int temps_fin_non_stricte; // = 0 par défaut pour les schéma implicite: indique
|
||||
// que l'on doit viser le temps fin de manière stricte (pas le dépasser)
|
||||
// = 1 : on doit juste le dépasser -> a priori c'est le fonctionnement par défaut des
|
||||
// algo explicites, compte tenu qu'il n'y a pas de prise en compte précise
|
||||
// de la variation du pas de temps
|
||||
// mise à jour avec la méthode : Change_temps_fin_non_stricte(int methode)
|
||||
|
||||
Temps_CPU_HZpp temps_cpu_chargement; // le temps cpu du à tous les chargements
|
||||
|
||||
// les autres parametres relatif au temps
|
||||
//-// double deltatmaxi; // increment de temps maxi
|
||||
//-// double prectemps; // precision sur le temps final
|
||||
//-// double deltat; // increment de temps
|
||||
//-// double tempsfin; // temps de fin de calcul
|
||||
//-// int maxincre ; // maximum d'increment de temps
|
||||
//-// double multiplicateur; // multiplicateur de la charge
|
||||
|
||||
// pointeurs des fonctions en cours
|
||||
void (Charge::*PtDebut) (void);
|
||||
bool (Charge::*PtAvance) (void);
|
||||
void (Charge::*PtPrecedent) (void);
|
||||
int (Charge::*PtFin) (const int & icharge,bool affichage); // affichage indique si oui ou non on
|
||||
// on veut un affichage signifiant que l'on est à la fin du chargement
|
||||
|
||||
// METHODES PROTEGEES :
|
||||
// declaration des initialisations en fonction du type de chargement
|
||||
void Debut1();
|
||||
void Debut2();
|
||||
void Debut3();
|
||||
void Debut4();
|
||||
void Debut5();
|
||||
void Debut6();
|
||||
void Debut7();
|
||||
// declaration de l'avancement en fonction du type de chargement
|
||||
bool Avance1();
|
||||
bool Avance2();
|
||||
bool Avance3();
|
||||
bool Avance4();
|
||||
bool Avance5();
|
||||
bool Avance6();
|
||||
bool Avance7();
|
||||
// declaration du retour à l'incrément précédent en fonction du type de chargement
|
||||
void Precedent1();
|
||||
void Precedent2();
|
||||
void Precedent3();
|
||||
void Precedent4();
|
||||
void Precedent5();
|
||||
void Precedent6();
|
||||
void Precedent7();
|
||||
// declaration de la fin en fonction du type de chargement
|
||||
// 0 : la fin n'est pas valide, on continue
|
||||
// 1 : temps fin dépassé
|
||||
// 2 : compteur_increment dépassé
|
||||
// 3 : compteur_essai_increment dépassé
|
||||
// NB: c'est d'abort le temps fin qui est testé: qui donc conduit à un arrêt normal
|
||||
// puis ensuite le compteur d'incréments
|
||||
// puis le nombre d'essai maxi, puis enfin le cas normal
|
||||
// si affichage est true, affichage d'un message
|
||||
int Fin1(const int & icharge,bool affichage);
|
||||
int Fin2(const int & icharge,bool affichage);
|
||||
int Fin3(const int & icharge,bool affichage);
|
||||
int Fin4(const int & icharge,bool affichage);
|
||||
int Fin5(const int & icharge,bool affichage);
|
||||
int Fin6(const int & icharge,bool affichage);
|
||||
int Fin7(const int & icharge,bool affichage);
|
||||
|
||||
|
||||
};
|
||||
/// @} // end of group
|
||||
|
||||
#endif
|
||||
2145
Chargement/Charge2.cc
Normal file
2145
Chargement/Charge2.cc
Normal file
File diff suppressed because it is too large
Load diff
1381
Chargement/Charge3.cc
Normal file
1381
Chargement/Charge3.cc
Normal file
File diff suppressed because it is too large
Load diff
117
Chargement/VariablesTemps.cc
Normal file
117
Chargement/VariablesTemps.cc
Normal file
|
|
@ -0,0 +1,117 @@
|
|||
|
||||
// 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 "VariablesTemps.h"
|
||||
#include "Sortie.h"
|
||||
#include <iomanip>
|
||||
#include "ParaGlob.h"
|
||||
using namespace std;
|
||||
|
||||
|
||||
// CONSTRUCTEURS :
|
||||
// par défauts
|
||||
VariablesTemps::VariablesTemps() :
|
||||
temps(0.),deltat(0.),deltatmaxi(0.),deltatmini(0.),tempsfin(0.),prectemps(0.)
|
||||
{ };
|
||||
|
||||
// constructeur de copies
|
||||
VariablesTemps::VariablesTemps(const VariablesTemps& t) :
|
||||
temps(t.temps),deltat(t.deltat),deltatmaxi(t.deltatmaxi),deltatmini(t.deltatmini)
|
||||
,tempsfin(t.tempsfin),prectemps(t.prectemps)
|
||||
{ };
|
||||
|
||||
// affichage des parametres liés au temps
|
||||
void VariablesTemps::Affiche() const
|
||||
{ cout << "temps courant = " << deltatmaxi << '\n';
|
||||
cout << "increment de temps maxi = " << deltatmaxi << '\n';
|
||||
cout << "increment de temps mini = " << deltatmini << '\n';
|
||||
cout << "precision sur le temps final = " << prectemps << '\n';
|
||||
cout << "increment de temps = " << deltat << '\n';
|
||||
cout << "temps de fin de calcul = " << tempsfin << '\n';
|
||||
};
|
||||
|
||||
//----- lecture écriture dans base info -----
|
||||
// cas donne le niveau de la récupération
|
||||
// = 1 : on récupère tout
|
||||
// = 2 : on récupère uniquement les données variables (supposées comme telles)
|
||||
// = 3 : on met à jour uniquement les données variables (supposées comme telles)
|
||||
// dans ce cas il y a modification des grandeurs, mais pas redimentionnement
|
||||
void VariablesTemps::Lecture_base_info_temps(ifstream& entr,const int cas)
|
||||
{switch (cas)
|
||||
{ case 1 : // ------- on récupère tout -------------------------
|
||||
{ cout << "== lecture des variables temps \n";
|
||||
string toto; entr >> toto ; // lecture en tête
|
||||
entr >> toto >> temps >> toto >> deltat
|
||||
>> toto >> deltatmaxi >> toto >> deltatmini >> toto >> tempsfin
|
||||
>> toto >> prectemps;
|
||||
break;
|
||||
}
|
||||
case 2 : case 3: // ----------- on récupère uniquement se qui varie --------------------
|
||||
{ string toto;
|
||||
// entr >> toto >> temps >> toto >> deltat;
|
||||
// si on lit le deltat on ne peut plus prendre en compte la modif éventuelle du .info !
|
||||
entr >> toto >> temps ;
|
||||
break;
|
||||
}
|
||||
default :
|
||||
{cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
|
||||
cout << "VariablesTemps::Lecture_base_info(ifstream& entr,const int cas)"
|
||||
<< " cas= " << cas << endl;
|
||||
Sortie(1);
|
||||
}
|
||||
};
|
||||
}; // cas donne le niveau de sauvegarde
|
||||
// = 1 : on sauvegarde tout
|
||||
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
|
||||
void VariablesTemps::Ecriture_base_info_temps(ofstream& sort,const int cas) const
|
||||
{switch (cas)
|
||||
{ case 1 : // ------- on sauvegarde tout -------------------------
|
||||
{ sort << " ****info_temps " ;
|
||||
sort << " temps_courant " << setprecision(ParaGlob::NbdigdoCA()) << temps
|
||||
<< " increment_temps " << setprecision(ParaGlob::NbdigdoCA()) << deltat
|
||||
<< " increment_maxi " << setprecision(ParaGlob::NbdigdoCA()) << deltatmaxi
|
||||
<< " increment_mini " << setprecision(ParaGlob::NbdigdoCA()) << deltatmini
|
||||
<< " temps_fin " << setprecision(ParaGlob::NbdigdoCA()) << tempsfin
|
||||
<< " precision_temps " << setprecision(ParaGlob::NbdigdoCA()) << prectemps << "\n";
|
||||
break;
|
||||
}
|
||||
case 2 : // ----------- sauvegarde uniquement de se qui varie --------------------
|
||||
{ sort << "\n temps_courant " << setprecision(ParaGlob::NbdigdoCA()) << temps ;
|
||||
// << " increment_temps " << setprecision(ParaGlob::NbdigdoCA()) << deltat;
|
||||
break;
|
||||
}
|
||||
default :
|
||||
{ cout << "\nErreur : valeur incorrecte du type de sauvegarde !\n";
|
||||
cout << "VariablesTemps::Ecriture_base_info(ofstream& sort,const int cas)"
|
||||
<< " cas= " << cas << endl;
|
||||
Sortie(1);
|
||||
}
|
||||
};
|
||||
};
|
||||
141
Chargement/VariablesTemps.h
Normal file
141
Chargement/VariablesTemps.h
Normal file
|
|
@ -0,0 +1,141 @@
|
|||
|
||||
// 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/>.
|
||||
|
||||
/************************************************************************
|
||||
* DATE: 23/05/2003 *
|
||||
* $ *
|
||||
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
|
||||
* $ *
|
||||
* PROJET: Herezh++ *
|
||||
* $ *
|
||||
************************************************************************
|
||||
* BUT: Cette classe est dédiée au passage d'informations protégées *
|
||||
* à d'autre classes. Cependant, la gestion des datas est *
|
||||
* effectuée directement par la classe ParaAlgoControle. *
|
||||
* $ *
|
||||
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
|
||||
* VERIFICATION: *
|
||||
* *
|
||||
* ! date ! auteur ! but ! *
|
||||
* ------------------------------------------------------------ *
|
||||
* ! ! ! ! *
|
||||
* $ *
|
||||
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
|
||||
* MODIFICATIONS: *
|
||||
* ! date ! auteur ! but ! *
|
||||
* ------------------------------------------------------------ *
|
||||
* $ *
|
||||
************************************************************************/
|
||||
#ifndef VARIABLES_TEMPS_H
|
||||
#define VARIABLES_TEMPS_H
|
||||
|
||||
#include <fstream>
|
||||
//#include "Debug.h"
|
||||
|
||||
#ifndef ENLINUX_STREAM
|
||||
#include <sstream> // pour le flot en memoire centrale
|
||||
#else
|
||||
#include <strstream> // pour le flot en memoire centrale
|
||||
#endif
|
||||
#include <string.h>
|
||||
#include <string>
|
||||
#include "Sortie.h"
|
||||
|
||||
|
||||
class ParaAlgoControle;
|
||||
|
||||
/// @addtogroup Groupe_concernant_le_chargement
|
||||
/// @{
|
||||
///
|
||||
|
||||
class VariablesTemps
|
||||
{
|
||||
public :
|
||||
friend class ParaAlgoControle;
|
||||
friend class Loi_comp_abstraite;
|
||||
// CONSTRUCTEURS :
|
||||
// par défauts
|
||||
VariablesTemps();
|
||||
|
||||
// constructeur de copies :
|
||||
VariablesTemps(const VariablesTemps& t);
|
||||
|
||||
// DESTRUCTEUR :
|
||||
~VariablesTemps() {};
|
||||
|
||||
// METHODES PUBLIQUES :
|
||||
// ramène le temps courant
|
||||
const double & TempsCourant() const {return temps;};
|
||||
// ramène l'incrément du temps en cours
|
||||
const double & IncreTempsCourant() const { return deltat;};
|
||||
// ramène l'incrément du temps maxi
|
||||
const double & IncreTempsMaxi() const { return deltatmaxi;};
|
||||
// ramène l'incrément du temps mini
|
||||
const double & IncreTempsMini() const { return deltatmini;};
|
||||
// ramène le temps fin
|
||||
const double & Tempsfin() const {return tempsfin;};
|
||||
// affichage des parametres liés au temps
|
||||
void Affiche() const ;
|
||||
// mise à jour des paramètres bornes
|
||||
void Mise_a_jour_bornes(const VariablesTemps& t)
|
||||
{deltatmaxi = t.deltatmaxi;
|
||||
deltatmini = t.deltatmini;
|
||||
tempsfin = t.tempsfin;
|
||||
prectemps = t.prectemps;
|
||||
};
|
||||
|
||||
//----- lecture écriture dans base info -----
|
||||
// cas donne le niveau de la récupération
|
||||
// = 1 : on récupère tout
|
||||
// = 2 : on récupère uniquement les données variables (supposées comme telles)
|
||||
// = 3 : on met à jour uniquement les données variables (supposées comme telles)
|
||||
// dans ce cas il y a modification des grandeurs, mais pas redimentionnement
|
||||
void Lecture_base_info_temps(ifstream& ent,const int cas);
|
||||
// cas donne le niveau de sauvegarde
|
||||
// = 1 : on sauvegarde tout
|
||||
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
|
||||
void Ecriture_base_info_temps(ofstream& sort,const int cas) const ;
|
||||
|
||||
protected :
|
||||
// VARIABLES PROTEGEES :
|
||||
double temps; // le temps global
|
||||
// la sauvegarde des paramètres d'un pas sur l'autre
|
||||
double deltat; // increment de temps
|
||||
// les bornes
|
||||
double deltatmaxi; // increment de temps maxi
|
||||
double deltatmini; // increment de temps mini
|
||||
double tempsfin; // temps de fin de calcul
|
||||
double prectemps; // precision sur le temps final
|
||||
|
||||
// METHODES PROTEGEES :
|
||||
|
||||
};
|
||||
/// @} // end of group
|
||||
|
||||
#endif
|
||||
Loading…
Reference in a new issue