rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Util/Courbes/Fonction_nD.cc

1956 lines
86 KiB
C++
Raw Normal View History

ajout des fichiers .h et .cc des répertoire Util et TypeBase
2021-09-07 09:51:43 +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.
//
// 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 "Fonction_nD.h"
#include <stdarg.h> /* va_list, va_start, va_copy, va_arg, va_end */
#include "Enum_ddl.h"
#include "NevezTenseur.h"
#include "TypeQuelconqueParticulier.h"
// les différentes fonctions existantes
#include "F_nD_courbe1D.h"
#include "Fonc_scal_combinees_nD.h"
#include "Fonction_expression_litterale_nD.h"
#include "Fonction_externe_nD.h"
#include "MotCle.h"
// CONSTRUCTEURS :
// par défaut
Fonction_nD::Fonction_nD(string nom, EnumFonction_nD typ)
: nom_variables(),t_inter_double()
,enu_variables_globale(),nom_ref(nom),typeFonction(typ)
,nom_variables_globales()
,tab_enu_etendu(),tab_enu_quelconque()
,equivalence_nom_enu_etendu_et_enu_quelconque(false)
,index_enu_etendu(),index_enu_quelconque()
,x_x_i(),x_glob(),xinter(NULL)
,depend_M(0),depend_Mt(0),depend_M0(0),depend_temps(0),permet_affichage(0)
//------ grandeurs évoluées -------
,type_des_variables(),val_ddl_enum(),li_enu_etendu_scalaire()
,coor_ddl_enum(),num_dans_coor(),premier_famille_Coord()
,tens_ddl_enum(),ind_tens(),premier_famille_tenseur(),absolue(false)
,li_equi_Quel_evolue(),tab_equi_Coor(),tab_equi_tens()
,posi_ddl_enum(),tailles_tab()
{ // Contruction des index pour les grandeurs évoluées, ainsi que les conteneurs
// non car au début il n'y a rien comme variable !!
// Fonction_nD::Construction_index_conteneurs_evoluees();
};
// constructeur avec plus d'info
// dans le cas ou les variables sont associées à des types quelconques, par défaut on considère qu'il
// s'agit de conteneur d'un scalaire simple. Dans le cas contraire il faut utiliser
// Preparation_Grandeur_quelconque( pour spécifier les tailles réelles
Fonction_nD::Fonction_nD(const Tableau <string >& var, string nom, EnumFonction_nD typ )
: nom_variables(var),t_inter_double(var.Taille())
,enu_variables_globale(),nom_ref(nom),typeFonction(typ)
,nom_variables_globales()
,tab_enu_etendu(),tab_enu_quelconque()
,equivalence_nom_enu_etendu_et_enu_quelconque(false)
,index_enu_etendu(),index_enu_quelconque()
,x_x_i(),x_glob(),xinter(NULL)
,depend_M(0),depend_Mt(0),depend_M0(0),depend_temps(0),permet_affichage(0)
//------ grandeurs évoluées -------
,type_des_variables(),val_ddl_enum(),li_enu_etendu_scalaire()
,coor_ddl_enum(),num_dans_coor(),premier_famille_Coord()
,tens_ddl_enum(),ind_tens(),premier_famille_tenseur(),absolue(false)
,li_equi_Quel_evolue(),tab_equi_Coor(),tab_equi_tens()
,posi_ddl_enum(),tailles_tab()
{// comme on a le tableau de variables, on tente une équivalence éventuelle
// Fonction_nD::Construction_enu_etendu_et_quelconque();
// Contruction des index pour les grandeurs évoluées, ainsi que les conteneurs
Fonction_nD::Construction_index_conteneurs_evoluees();
};
// def de tous les paramètres: utile pour être appelé par les classes dérivées
Fonction_nD::Fonction_nD
( string nom_ref_ // nom de ref de la fonction
,Tableau <string >& nom_variables_non_globales // les variables non globales
,Tableau <Enum_GrandeurGlobale >& enu_variables_globale_ // enu globaux
,Tableau <string >& nom_variables_globales_ // idem sous forme de strings
,EnumFonction_nD typ ) // le type de fonction
: nom_variables(nom_variables_non_globales),t_inter_double(nom_variables_non_globales.Taille())
,enu_variables_globale(enu_variables_globale_),nom_ref(nom_ref_),typeFonction(typ)
,nom_variables_globales(nom_variables_globales_)
,tab_enu_etendu(),tab_enu_quelconque()
,equivalence_nom_enu_etendu_et_enu_quelconque(false)
,index_enu_etendu(),index_enu_quelconque()
,x_x_i(),x_glob(),xinter(NULL)
,depend_M(0),depend_Mt(0),depend_M0(0),depend_temps(0),permet_affichage(0)
//------ grandeurs évoluées -------
,type_des_variables(),val_ddl_enum(),li_enu_etendu_scalaire()
,coor_ddl_enum(),num_dans_coor(),premier_famille_Coord()
,tens_ddl_enum(),ind_tens(),premier_famille_tenseur(),absolue(false)
,li_equi_Quel_evolue(),tab_equi_Coor(),tab_equi_tens()
,posi_ddl_enum(),tailles_tab()
{// comme on a le tableau de variables, on tente une équivalence éventuelle
// Fonction_nD::Construction_enu_etendu_et_quelconque();
// Contruction des index pour les grandeurs évoluées, ainsi que les conteneurs
Fonction_nD::Construction_index_conteneurs_evoluees();
};
// de copie
Fonction_nD::Fonction_nD(const Fonction_nD& Co) :
nom_variables(Co.nom_variables),t_inter_double(Co.t_inter_double)
,enu_variables_globale(Co.enu_variables_globale)
,nom_variables_globales(Co.nom_variables_globales)
,nom_ref(Co.nom_ref),typeFonction(Co.typeFonction)
,tab_enu_etendu(Co.tab_enu_etendu),tab_enu_quelconque(Co.tab_enu_quelconque)
,equivalence_nom_enu_etendu_et_enu_quelconque(Co.equivalence_nom_enu_etendu_et_enu_quelconque)
,index_enu_etendu(Co.index_enu_etendu),index_enu_quelconque(Co.index_enu_quelconque)
,x_x_i(Co.x_x_i),x_glob(Co.x_glob),xinter(NULL)
,depend_M(Co.depend_M),depend_Mt(Co.depend_Mt),depend_M0(Co.depend_M0)
,depend_temps(Co.depend_temps)
//------ grandeurs évoluées -------
,type_des_variables(Co.type_des_variables),val_ddl_enum(Co.val_ddl_enum)
,li_enu_etendu_scalaire() // reconstruit avec les index
,coor_ddl_enum(Co.coor_ddl_enum),num_dans_coor(Co.num_dans_coor)
,premier_famille_Coord(Co.premier_famille_Coord)
,tens_ddl_enum(Co.tens_ddl_enum),ind_tens(Co.ind_tens)
,premier_famille_tenseur(Co.premier_famille_tenseur)
,absolue(Co.absolue)
,li_equi_Quel_evolue(),tab_equi_Coor(),tab_equi_tens() // est reconstruit ensuite
,posi_ddl_enum(Co.posi_ddl_enum),tailles_tab(Co.tailles_tab)
,permet_affichage(Co.permet_affichage)
{if (Co.xinter != NULL)
xinter = new Tableau <double >(*(Co.xinter));
// comme on a le tableau de variables, on tente une équivalence éventuelle
// Fonction_nD::Construction_enu_etendu_et_quelconque();
// Contruction des index pour les grandeurs évoluées, ainsi que les conteneurs
Fonction_nD::Construction_index_conteneurs_evoluees();
};
// DESTRUCTEUR :
Fonction_nD::~Fonction_nD()
{if (xinter != NULL)
delete xinter;
if (tens_ddl_enum.Taille() != 0)
{int taille = tens_ddl_enum.Taille();
for (int i=1; i<= taille; i++)
if (tens_ddl_enum(i) != NULL)
delete tens_ddl_enum(i);
};
};
// METHODES PUBLIQUES :
// ---------- non virtuelle ---------
//// complète les tableaux internes en fonction de la taille des conteneurs
//// associés aux types quelconques éventuelles
//// *** doit -être appelée s'il y a des grandeurs quelconque dont les conteneurs
//// sont associés à plusieurs scalaires
//void Fonction_nD::Preparation_Grandeur_quelconque(const Tableau <TypeQuelconque >& tqi)
// {// on parcourt la liste des enumérés de grandeurs quelconque
// int tail = tab_enu_quelconque.Taille();
// if (tqi.Taille() != tail)
// { cout << "\n *** pb dans Fonction_nD::Preparation_Grandeur_quelconque( "
// << " le tableau en parametre " << tqi.Taille()
// << " n'a pas la meme taille que le nombre de grandeur quelconque enregistrees "
// << tail
// << " on ne peut pas continuer " <<endl;
// Sortie(1);
// };
// // --- l'objectif est de dimensionner correctement le tableau de passage de réelles
// // x_x_i
// int nb_scalaire_type_quelconque = 0; // init
// for (int i=1;i<= tail; i++)
// {nb_scalaire_type_quelconque += tqi(i).NbMaxiNumeroOrdre();
// #ifdef MISE_AU_POINT
// if ((tqi)(i).EnuTypeQuelconque() != tab_enu_quelconque(i))
// { cout << "\n *** pb dans la preparation de l'utilisation de type quelconque "
// << " au niveau des parametres d'appel "
// << " la grandeur quelconque "<< i<< "correspondante a "
// << NomTypeQuelconque((tqi)(i).EnuTypeQuelconque())
// << " est differente de celle deja enregistree "
// << NomTypeQuelconque(tab_enu_quelconque(i))
// << " ce n'est pas normal !! , on arrete le calcul "
// << "\n Fonction_nD::Preparation_Grandeur_quelconque(..."<<endl;
// Sortie(1);
// };
// #endif
// };
// // on dimensionne le tableau de passage
// // chaque ddl est associé à un seul scalaire
// x_x_i.Change_taille(nb_scalaire_type_quelconque+tab_enu_etendu.Taille());
// };
// calcul équivalent, mais pour des paramètres de type ddl enum étendu et/ou type quelconque
// pour que l'appel à cette méthode soit correcte, il faut que la dimension de t_enu + celle de tqi
// soit identique à celle du tableau Nom_variables() : en fait t_enu et tqi doivent représenter les variables
Tableau <double> & Fonction_nD::Valeur_FnD(Tableau <Ddl_etendu> * t_enu,Tableau <const TypeQuelconque * > * t_qi
,Tableau <int> * t_num_ordre)
{// on se sert des tableaux d'adressage indirect pour remplir le tableau de passage
// tab_enu_etendu(i) correspond à nom_variables(index_enu_etendu(i))
// tab_enu_quelconque(i) correspond à nom_variables(index_enu_quelconque(i))
// un tableau intermédiaire qui sert pour Valeur(Tableau <Ddl_etendu> ...
// Tableau <double > x_x_i;
#ifdef MISE_AU_POINT
// on vérifie qu'il y a bien équivalence entre les variables
if (!equivalence_nom_enu_etendu_et_enu_quelconque)
{ cout << "\n *** pb dans les parametres de passage pour l'appel de la fonction nD "
<< " les variables de passage ne sont pas tous des ddl etendue ou des grandeurs "
<< " quelconque scalaire "
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Valeur(Tableau <Ddl_etendu>..."<<endl;
Sortie(1);
};
#endif
try
{int tail_tab_enu_etendu = tab_enu_etendu.Taille();
if (t_enu != NULL)
{Tableau <Ddl_etendu>& tenu = *t_enu; // pour simplifier l'appel
for (int i= 1; i<= tail_tab_enu_etendu;i++)
{x_x_i(index_enu_etendu(i)) = tenu(i).Valeur();
};
};
int tail_tab_enu_quelc = tab_enu_quelconque.Taille();
if (t_qi != NULL)
{Tableau <const TypeQuelconque * >& tqi = *t_qi; // pour simplifier l'appel
for (int i= 1; i<= tail_tab_enu_quelc;i++)
{ x_x_i(index_enu_quelconque(i)) = tqi(i)->GrandeurNumOrdre(1);
#ifdef MISE_AU_POINT
int nb_scalaire_type_quelconque = tqi(i)->NbMaxiNumeroOrdre();
if (nb_scalaire_type_quelconque != 1)
{ cout << "\n *** pb dans le nombre de parametre de passage pour l'appel de la fonction nD "
<< " au niveau des parametres d'appel "
<< " la grandeur quelconque "<< i<< "correspondante a "
<< (tqi)(i)->EnuTypeQuelconque().NomPlein()
<< " n'est pas une grandeur scalaire "
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Valeur(Tableau <Ddl_etendu>..."<<endl;
Sortie(1);
};
#endif
};
};
// on peut maintenant appeler la fonction de base
// avec que des scalaires
#ifdef MISE_AU_POINT
if (permet_affichage > 4)
{cout << "\n retour fonction: "<<nom_ref<<" : ";
Tableau <double> & inter = Valeur_FnD_interne(&x_x_i);
int nb_val = inter.Taille();
for (int i=1;i<=nb_val;i++)
cout << " val("<<i<<")= "<<inter(i);
if (permet_affichage > 5)
{cout << "\n parametres d'appel: ";
int nb_var = x_x_i.Taille();
for (int j=1;j<=nb_var;j++)
{ cout << " para("<<j<<")= "<< x_x_i(j);}
};
return inter;
}
else
#endif
return Valeur_FnD_interne(&x_x_i);
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch(...)
{ cout << "\n ** erreur \n Valeur_FnD(..."<<endl;
this->Affiche();Sortie(1);
};
};
// ramène un pointeur sur la fonction correspondant au type de fonction passé en paramètre
Fonction_nD* Fonction_nD::New_Fonction_nD(string& nom,EnumFonction_nD typeFonction)
{ // définition du pointeur de retour
Fonction_nD* fonction;
// choix en fonction du typeCourbe
switch (typeFonction)
{
case FONCTION_EXPRESSION_LITTERALE_nD :
fonction= new Fonction_expression_litterale_nD(nom); break;
case FONCTION_COURBE1D : fonction= new F_nD_courbe1D(nom); break;
case FONC_SCAL_COMBINEES_ND : fonction= new Fonc_scal_combinees_nD(nom); break;
case FONCTION_EXTERNE_ND : fonction= new Fonction_externe_nD(nom); break;
default :
{ cout << "\nErreur : valeur incorrecte du type de Fonction_nD : "
<< typeFonction << "\n";
cout << "\n New_Fonction_nD(EnumFonction_nD typeFonction) \n";
Sortie(1);
}
};
return fonction;
};
// ramène un pointeur sur une courbe copie de celle passée en paramètre
// IMPORTANT : il y a création d'une courbe (utilisation d'un new)
Fonction_nD* Fonction_nD::New_Fonction_nD(const Fonction_nD& Co)
{ // définition du pointeur de retour
Fonction_nD* fonction;
// choix en fonction du typeFonction
switch (Co.Type_Fonction())
{
case FONCTION_EXPRESSION_LITTERALE_nD : fonction= new Fonction_expression_litterale_nD( Co); break;
case FONCTION_COURBE1D : fonction= new F_nD_courbe1D(Co); break;
case FONC_SCAL_COMBINEES_ND : fonction= new Fonc_scal_combinees_nD(Co); break;
case FONCTION_EXTERNE_ND : fonction= new Fonction_externe_nD(Co); break;
default :
{ cout << "\nErreur : valeur incorrecte du type de Fonction_nD : "
<< Co.Type_Fonction() << "\n";
cout << "\n New_Fonction_nD(const Fonction_nD& Co) \n";
Sortie(1);
}
};
return fonction;
};
// ramène la liste des identificateurs de courbes actuellement disponibles
list <EnumFonction_nD> Fonction_nD::Liste_Fonction_disponible()
{ // définition de la liste de retour
list <EnumFonction_nD> list_ret;
// remplissage de la liste
list_ret.push_back(FONCTION_EXPRESSION_LITTERALE_nD);
list_ret.push_back(FONCTION_COURBE1D);
list_ret.push_back(FONC_SCAL_COMBINEES_ND);
list_ret.push_back(FONCTION_EXTERNE_ND);
// retour de la liste
return list_ret;
};
// mise à jour des variables globales: en fonction de l'apparition de nouvelles variables
// globales en cours de calcul
// méthode interne: qui est utilisé par les fonctions dérivées pour la méthode:
// Mise_a_jour_variables_globales
// retourne false si rien n'a changé
bool Fonction_nD::Mise_a_jour_variables_globales_interne()
{// on passe en revue les variables normales et on regarde s'il s'agit de nouvelles variables globales
int taille = nom_variables.Taille();
list <string> li_variable; // liste de travail
list <string> li_globale; // ""
bool a_changer = false; // a priori rien ne change
// maintenant on parcours les variables
for (int i=1;i<=taille;i++)
{if (ParaGlob::param->GrandeurGlobal(nom_variables(i)) != NULL)
// il s'agit d'une variable globale
{// on n'ajoute que si elle n'est pas déjà présente
std::list <string>::iterator it
= find (li_globale.begin(), li_globale.end(),nom_variables(i));
if (it == li_globale.end())
{li_globale.push_back(nom_variables(i));
};
// quelque soit le cas il faut valider
a_changer=true;
}
else // sinon c'est toujours une variable
li_variable.push_back(nom_variables(i));
};
// on met à jour les tableaux
if (a_changer)
{// on ajoute maintenant les variables globales déjà existantes
int taille_globale = nom_variables_globales.Taille(); // Init_from_list
for (int j=1;j<= taille_globale;j++)
{// on n'ajoute que si elle n'est pas déjà présente
list <string>::iterator it
= find (li_globale.begin(), li_globale.end(),nom_variables_globales(j));
if (it == li_globale.end())
{li_globale.push_back(nom_variables_globales(j));}
};
// on met à jour les tableaux
nom_variables.Init_from_list(li_variable);
t_inter_double.Change_taille(nom_variables.Taille());
// pour les variables globales on considère les points suivants:
// leur nombre ne peut pas décroitre
// l'ordre n'a pas vraiment d'importance
// int taille_ajout = li_globale.size();
int taille_finale = li_globale.size();
if (taille_finale < nom_variables_globales.Taille())
{cout << "\n erreur changement de taille des variables globales "
<< "\n Fonction_nD::Mise_a_jour_variables_globales_interne() "
<< endl;
Sortie(1);
};
nom_variables_globales.Init_from_list(li_globale);
// int taille_ini = nom_variables_globales.Taille();
// nom_variables_globales.Change_taille(taille_ini+taille_ajout);
// nom_variables_globales.Change_taille(taille_finale);
// list <string>::iterator il,ilfin=li_globale.end();
// int ip = 1; //taille_ini+1;
// for (il = li_globale.begin();il != ilfin; il++,ip++)
// nom_variables_globales(ip) = (*il);
// nom_variables_globales.Init_from_list(li_globale);
};
// on met à jour le tableau d'échange interne : x_glob
int nb_tot_glob = enu_variables_globale.Taille() + nom_variables_globales.Taille();
x_glob.Change_taille(nb_tot_glob);
// Contruction des index pour les grandeurs évoluées, ainsi que les conteneurs
Fonction_nD::Construction_index_conteneurs_evoluees();
return a_changer;
};
// Tableau <string > nom_variables; //variables de la fonction, vu de l'extérieur
//
// Tableau <Enum_GrandeurGlobale > enu_variables_globale; //tableau des énumérés
// // de variables globales
// // éventuellement vide s'il ne sert pas
// Tableau <string > nom_variables_globales; //tableau des énumérés
// 2) retourne une liste de nom correspondant aux noms de courbes dont dépend *this
list <string>& Fonction_nD::ListDependanceCourbes(list <string>& lico) const
{ // par défaut, ne dépend pas de fonctions, donc on ramène une liste vide
// ce sera surchargé dans les classes qui elles éventuellement dépendent de quelque chose
if (lico.size() != 0)
lico.clear();
return lico;
};
// 3) retourne une liste de nom correspondant aux noms de fonctions dont dépend *this
list <string>& Fonction_nD::ListDependanceFonctions(list <string>& lico) const
{ // par défaut, ne dépend pas de fonctions, donc on ramène une liste vide
// ce sera surchargé dans les classes qui elles éventuellement dépendent de quelque chose
if (lico.size() != 0)
lico.clear();
return lico;
};
// ---------- METHODES PROTEGEES :-------------------
// ramène true si les variables de la classe mère sont complèté
bool Fonction_nD::Complet_var() const
{ bool ret = true;
if (typeFonction == AUCUNE_FONCTION_nD) ret = false;
if (nom_ref == "") ret = false;
return ret;
};
// définit le paramètre depend_M en fonction des nom_variables
// 3 indicateurs permettant de connaître rapidement si
// la fonction dépend de la position d'un point M à tdt, t et t=0
// 0 : la fonction ne dépend pas de la position d'un point M
// non nul : la fonction dépend de la position d'un point M
// dans ce cas, une au moins un des nom_variables
// a un nom de la même famille que le ddl X1
// et depend_M = nombre de composantes demandés (ne sert pas vraiment)
// si = -1 : cela signifie que la fonction dépend "que" de M
void Fonction_nD::Definition_depend_M()
{// on parcours les noms des variables
int taille = nom_variables.Taille();
depend_M=0; // init a priori
depend_Mt=0; // idem à t
depend_M0 = 0; // idem à 0
Ddl_enum_etendu d_X1_t = Ddl_enum_etendu(X1,"X1_t");
Ddl_enum_etendu d_X1_t0 = Ddl_enum_etendu(X1,"X1_t0");
if (permet_affichage > 6)
cout << "\n == >>> Fonction_nD::Definition_depend_M ( fct= " << nom_ref << ") ";
list<string> var_X_deja_enreg; // une liste de travail
list<string> var_independante; // une liste de travail
for (int i=1; i<= taille; i++)
{// on ne traite que si la variable n'a pas déjà été traité
if (find(var_independante.begin(),var_independante.end(),nom_variables(i)) == var_independante.end())
{var_independante.push_back(nom_variables(i));
if (ExisteEnum_ddl(nom_variables(i))) // on regarde s'il s'agit d'un ddl patenté
{if (permet_affichage > 7)
cout << "\n cas d'un ddl de base: nom_variables("<<i<<") = "<<nom_variables(i);
if ( Meme_famille(Id_nom_ddl(nom_variables(i)),X1))
// si c'est de la famille d'X1 c'est ok, on regarde s'il ne s'agit pas d'une variable
// déjà consultée, car nom_variables peut contenir plusieurs fois la même variable
{if (find(var_X_deja_enreg.begin(),var_X_deja_enreg.end(),nom_variables(i)) == var_X_deja_enreg.end())
{depend_M += 1; // ok et la variable n'a pas été encore enregistrée
if (permet_affichage > 7)
cout << " depend_M += 1 ";
var_X_deja_enreg.push_back(nom_variables(i));
};
};
}
// sinon on regarde s'il s'agit d'un ddl étendu relatif à t = 0 ou t
else if (Ddl_enum_etendu::VerifExistence(nom_variables(i)))
{ if (permet_affichage > 7)
cout << "\n cas d'un ddl etendu relatif a t=0 ou t : nom_variables("<<i<<") = "<<nom_variables(i);
// on a un ddl enum
Ddl_enum_etendu dd_et = Ddl_enum_etendu::RecupDdl_enum_etendu(nom_variables(i));
if ( Ddl_enum_etendu::PremierDdlEnumEtenduFamille(dd_et) == d_X1_t)
// si c'est de la famille d'X1_t c'est ok, on regarde s'il ne s'agit pas d'une variable
// déjà consultée, car nom_variables peut contenir plusieurs fois la même variable
{if (find(var_X_deja_enreg.begin(),var_X_deja_enreg.end(),nom_variables(i)) == var_X_deja_enreg.end())
{depend_Mt += 1;
if (permet_affichage > 7)
cout << " depend_Mt += 1 ";
var_X_deja_enreg.push_back(nom_variables(i)); // on peut utiliser la même liste de travail
}
};
if ( Ddl_enum_etendu::PremierDdlEnumEtenduFamille(dd_et) == d_X1_t0)
// si c'est de la famille d'X1_t0 c'est ok, on regarde s'il ne s'agit pas d'une variable
// déjà consultée, car nom_variables peut contenir plusieurs fois la même variable
{if (find(var_X_deja_enreg.begin(),var_X_deja_enreg.end(),nom_variables(i)) == var_X_deja_enreg.end())
{depend_M0 += 1;
if (permet_affichage > 7)
cout << " depend_M0 += 1 ";
var_X_deja_enreg.push_back(nom_variables(i)); // on peut utiliser la même liste de travail
}
};
};
}
};
// le nombre de variables indépendantes, car nom_variables peut contenir plusieurs fois la même variable
int nb_var_inde = var_independante.size();
if (permet_affichage > 6)
cout << "\n nb de variables independantes : "<< nb_var_inde << " ";
// maintenant si depend_M est > à la dimension => il n'y a pas qu'une dépendance à M
// if ((depend_M <= ParaGlob::Dimension()) && (depend_M > 0))
if ((depend_M <= taille) && (depend_M > 0))
{// on vérifie que l'on n'a pas utilisé plus de composantes que la dimension
if (depend_M <= ParaGlob::Dimension())
{if (depend_M == nb_var_inde)
depend_M = -1; // cas d'une dépendance stricte à M
}
else
{ cout << "\n **** erreur le nombre de composante de dependance a M_tdt "<<taille
<< " est plus grand que la dimension " << ParaGlob::Dimension()
<< " de l'espace !! "
<< "\n Fonction_nD::Definition_depend_M() "
<< endl;
Sortie(1);
};
};
if ((depend_Mt <= taille) && (depend_Mt > 0))
{// on vérifie que l'on n'a pas utilisé plus de composantes que la dimension
if (depend_Mt <= ParaGlob::Dimension())
{if (depend_Mt == nb_var_inde)
depend_Mt = -1;// cas d'une dépendance stricte à Mt
}
else
{ cout << "\n **** erreur le nombre de composante de dependance a M_t"<<taille
<< " est plus grand que la dimension " << ParaGlob::Dimension()
<< " de l'espace !! "
<< "\n Fonction_nD::Definition_depend_M() "
<< endl;
Sortie(1);
};
};
if ((depend_M0 <= taille) && (depend_M0 > 0))
{// on vérifie que l'on n'a pas utilisé plus de composantes que la dimension
if (depend_M0 <= ParaGlob::Dimension())
{if (depend_M0 == nb_var_inde)
depend_M0 = -1; // cas d'une dépendance stricte à M0
}
else
{ cout << "\n **** erreur le nombre de composante de dependance a M_t=0 : "<<taille
<< " est plus grand que la dimension " << ParaGlob::Dimension()
<< " de l'espace !! "
<< "\n Fonction_nD::Definition_depend_M() "
<< endl;
Sortie(1);
};
};
if (permet_affichage > 6)
{cout << "\n == >>> Fonction_nD::Definition_depend_M : valeur des indicateurs finaux "
<< "\n pour memoire: = 0 -> la fct ne depend pas de la position "
<< " = -1 : la fct depend que de la position "
<< " > 0 : la fct depend de la position mais pas seulement "
<< "\n depend_M = " << depend_M << ",depend_Mt = " << depend_Mt
<< ", depend_M0 = " << depend_M0 << " ";
};
};
// définit le paramètre depend_temps en fonction des nom_variables
void Fonction_nD::Definition_depend_temps()
{// on parcours les identifiants globaux
int taille = enu_variables_globale.Taille();
depend_temps=false; // init a priori
// le temps est une grandeurs globales
for (int i=1; i<= taille; i++)
if (enu_variables_globale(i) == TEMPS_COURANT) // on regarde s'il s'agit d'un ddl patenté
{depend_temps = true;
break;
};
};
//// construction à partir des noms de variables, des tableaux tab_enu_etendu et
//// tab_enu_quelconque
//void Fonction_nD::Construction_enu_etendu_et_quelconque()
// {// on parcours les noms des variables
// int taille = nom_variables.Taille();
// // a priori on considère qu'il y a équivalence
// equivalence_nom_enu_etendu_et_enu_quelconque = true;
// list <Ddl_enum_etendu> li_inter_enu; // une liste intermédiaire de travail
// list <int> li_index_enu;
// list <EnumTypeQuelconque> li_inter_tyQ; // idem
// list <int> li_index_quelc;
//
// // un conteneur de service: un réel par ddl
// Ddl_enum_etendu ddl_de_service;
// // par contre pour les grandeurs quelconques, on peut avoir plusieurs
// // réels par grandeur quelconque
//
//
// for (int i=1; i<= taille; i++)
// {if (ddl_de_service.VerifExistence(nom_variables(i)))
// {li_inter_enu.push_back(Ddl_enum_etendu(nom_variables(i)));
// li_index_enu.push_back(i);
// }
// else if (Existe_typeQuelconque(nom_variables(i)))
// {li_inter_tyQ.push_back(Id_nomTypeQuelconque(nom_variables(i)));
// li_index_quelc.push_back(i);
// }
// else equivalence_nom_enu_etendu_et_enu_quelconque = false ;
// };
// // maintenant on peut définir les tableaux
// int tail_enu_ddl = li_inter_enu.size();
// { tab_enu_etendu.Change_taille(tail_enu_ddl);
// index_enu_etendu.Change_taille(tail_enu_ddl);
// int i_enu=1; // un compteur pour le tableau
// list <Ddl_enum_etendu>::iterator il,ilfin=li_inter_enu.end();
// list <int>::iterator i_int=li_index_enu.begin();
// for (il=li_inter_enu.begin();il!=ilfin;il++,i_enu++,i_int++)
// {tab_enu_etendu(i_enu)=(*il);
// index_enu_etendu(i_enu)=(*i_int);
// };
// };
// int tail_enuquel = li_inter_tyQ.size();
// { tab_enu_quelconque.Change_taille(tail_enuquel);
// index_enu_quelconque.Change_taille(tail_enuquel);
// int i_enu=1; // un compteur pour le tableau
// list <EnumTypeQuelconque>::iterator il,ilfin=li_inter_tyQ.end();
// list <int>::iterator i_int=li_index_quelc.begin();
// for (il=li_inter_tyQ.begin();il!=ilfin;il++,i_enu++,i_int++)
// {tab_enu_quelconque(i_enu)=(*il);
// index_enu_quelconque(i_enu) = (*i_int);
// #ifdef MISE_AU_POINT
// EnumTypeQuelconque inter = (*il);
// if (NombreElementFoncDim(Type_de_grandeur_associee(inter)) != 1)
// { cout << "\n *** pb de dimensions d'argument non coherentes !! "
// << " la grandeur quelconque "<< NomTypeQuelconque(inter)
// << ", n'est pas un scalaire simple "
// << "\n Fonction_nD::Construction_enu_etendu_et_quelconque(..."<<endl;
// Sortie(1);
// };
// #endif
// };
// };
// // on met à jour le tableau de transfert
// // ici par défaut chaque type quelconque est associé à un conteneur scalaire
// // si ce n'est pas le cas, on considère que l'utilisateur utilisera la méthode
// // Preparation_Grandeur_quelconque( pour mettre les bonnes dimensions
// x_x_i.Change_taille(tail_enu_ddl+tail_enuquel);
// };
// Contruction des index pour les grandeurs évoluées, ainsi que les conteneurs
void Fonction_nD::Construction_index_conteneurs_evoluees()
{// on parcours les noms des variables
int taille = nom_variables.Taille();
t_inter_double.Change_taille(taille);
// on dimensionne le tableau des types de variables
type_des_variables.Change_taille(taille);
// on nettoie les listes
li_enu_etendu_scalaire.clear();
// on part avec l'idée que toutes les grandeurs seront reconnues localement
equivalence_nom_enu_etendu_et_enu_quelconque = true;
// def de listes intermédiaires
list <int> li_inter_posi_ddl_enum; // liste des positions
// --- cas des tenseurs
list <TenseurBB* > li_inter_tens_ddl_enum; // pour les tenseurs
// list <Deuxentiers_enu > li_ind_tens; // pour les indices dans les tenseurs
List_io <Ddl_enum_etendu> li_premier_famille_tenseur; // pour savoir si c'est déjà enregistré
// --- cas des coordonnées
list <Coordonnee > li_coor_ddl_enum;
// list <int > li_num_dans_coor;
List_io <Ddl_enum_etendu> li_premier_famille_Coord; // pour savoir si c'est déjà enregistré
// --- init de la liste équivalente de grandeurs quelconques évoluées
li_equi_Quel_evolue.clear(); // on remet à 0
// on défini des conteneurs ad hoc
int dim = ParaGlob::Dimension(); // la dimension globale
// ... cas des Coordonnees
Coordonnee v_rep(dim); // un vecteur de travail
Grandeur_coordonnee grand5(v_rep); // def d'une grandeur courante coordonnée
// ... cas des tenseurs
TenseurBB* tens = NevezTenseurBB(dim); // un tenseur typique
// maintenant on définit une grandeur typique de type tenseurBB
Grandeur_TenseurBB gtBB(*tens);
list < int > li_position; // liste de la position des variables dans les tableaux
// on parcours les noms de variables
list <Ddl_enum_etendu> li_inter_enu; // une liste intermédiaire de travail
list <int> li_index_enu;
list <EnumTypeQuelconque> li_inter_tyQ; // idem
list <int> li_index_quelc;
// un conteneur de service: un réel par ddl
Ddl_enum_etendu ddl_de_service;
list <double> list_inter_val_ddl_enum; // inter qui donnera ensuite: val_ddl_enum
// par contre pour les grandeurs quelconques, on peut avoir plusieurs
// réels par grandeur quelconque
int indice_enu_ddl = 0; // init
int indice_t_quelconque = 0; // init
for (int i=1; i<= taille; i++) // on balaie les noms de variable
{// on sépare tout d'abord entre ddl_enum_etendu et type quelconque
if (ddl_de_service.VerifExistence(nom_variables(i)))
{ddl_de_service = Ddl_enum_etendu(nom_variables(i));
li_inter_enu.push_back(ddl_de_service);
li_index_enu.push_back(i);
// def de la position du ddl dans le tableau final des ddl (créé à la fin)
indice_enu_ddl++;li_inter_posi_ddl_enum.push_back(indice_enu_ddl);
// récup du type de grandeur auquel apartient l'énumération
// l'idée est de passer en revue le type de grandeur
EnumTypeGrandeur enu_type_grandeur = ddl_de_service.TypeDeGrandeur();
switch (enu_type_grandeur)
{case SCALAIRE : case SCALAIRE_ENTIER : case SCALAIRE_DOUBLE :
{// dans le cas d'un scalaire on a directement une équivalence à Ddl_enum_etendu
// quelque soit le scalaire, on le stocke en double
list_inter_val_ddl_enum.push_back(0.); // on ajoute une valeur 0. arbitraire
li_enu_etendu_scalaire.push_back(ddl_de_service);
type_des_variables(i)=1;
break;
}
case TENSEUR : case TENSEUR_NON_SYM : case TENSEURBB : case TENSEURHH :
case TENSEURBH : case TENSEURHB : case TENSEUR_NON_SYM_BB :
case TENSEUR_NON_SYM_HH :
{ // on considère que c'est toujours un tenseur en absolu et par défaut c'est un tenseur BB
type_des_variables(i)=3;
// maintenant il faut savoir si on a déjà enregistré un tenseur qui contiend la composante
if (!(Ddl_enum_etendu::Existe_dans_la_liste(li_premier_famille_tenseur,Ddl_enum_etendu::PremierDdlEnumEtenduFamille(ddl_de_service))))
// s'il n'existe pas on rajoute le premier de la famille
{ TenseurBB * pt_tens= NevezTenseurBB(dim);
li_inter_tens_ddl_enum.push_back(pt_tens);
li_premier_famille_tenseur.push_back
(Ddl_enum_etendu::PremierDdlEnumEtenduFamille(ddl_de_service));
// on s'occupe de la grandeur quelconque équivalente
EnumTypeQuelconque enuQ = Ddl_enum_etendu::Equivalent_en_grandeur_quelconque(ddl_de_service);
TypeQuelconque typQ6(enuQ,ddl_de_service.Enum(),gtBB);
li_equi_Quel_evolue.push_back(typQ6);
};
// // maintenant il faut récupérer la position = l'indice, de l'enu dans le tenseur
// Deuxentiers_enu deux = IJind(ddl_de_service.Enum(),dim);
// li_ind_tens.push_back(deux);
break;
}
case COORDONNEE : case COORDONNEEB : case COORDONNEEH :
{// on considère que c'est toujours un type coordonnée en absolu et par défaut c'est un Coordonnee
type_des_variables(i)=2;
// maintenant il faut savoir si on a déjà enregistré un Coordonnee qui contiend la composante
if (!(Ddl_enum_etendu::Existe_dans_la_liste(li_premier_famille_Coord,Ddl_enum_etendu::PremierDdlEnumEtenduFamille(ddl_de_service))))
// s'il n'existe pas on rajoute le premier de la famille
{ Coordonnee pt_coor(dim);
li_coor_ddl_enum.push_back(pt_coor);
li_premier_famille_Coord.push_back(Ddl_enum_etendu::PremierDdlEnumEtenduFamille(ddl_de_service));
// on s'occupe de la grandeur quelconque équivalente
EnumTypeQuelconque enuQ = Ddl_enum_etendu::Equivalent_en_grandeur_quelconque(ddl_de_service);
TypeQuelconque typQ6(enuQ,ddl_de_service.Enum(),grand5);
li_equi_Quel_evolue.push_back(typQ6);
};
// // maintenant il faut récupérer la position = l'indice, de l'enu dans Coordonnee
// int indice_coor = Indice_coor(ddl_de_service.Enum(),dim);
// li_num_dans_coor.push_back(indice_coor);
break;
}
default : // pour l'instant les autres cas, par exemple Vecteur, ne sont pas pris en compte
cout << "\nErreur : la grandeur " << nom_variables(i)
<< " n'est pas pris en compte pour les fonctions nD !\n";
cout << "\n Fonction_nD::Construction_index_conteneurs_evoluees(.. \n";
Sortie(1);
}; // fin du switch
} // fin du cas où c'est un ddl_enum_etendu
else if (Existe_typeQuelconque(nom_variables(i)))
{li_inter_tyQ.push_back(Id_nomTypeQuelconque(nom_variables(i)));
li_index_quelc.push_back(i);
type_des_variables(i)=4;
}
else
{// il y a des variables qui ne rentrent pas dans le cadre dd enu étendu et grandeur quelconque
// on ne pourra pas utiliser l'appel via des grandeurs évoluées: on le sauvegarde
// pour signaler des erreurs mais cela peut changer ensuite
// par exemple via la transformation de variables locales en variables globales qui sont
// dynamiquement créés, du coup on laisse l'algo
equivalence_nom_enu_etendu_et_enu_quelconque = false ;
type_des_variables(i)=0;
};
};
// on poursuit même s'il n'y a pas équivalence parfaite
// de manière a remplacer la méthode : Construction_enu_etendu_et_quelconque()
// cependant s'il y a une équivalence parfaite
// on ne pourra pas utiliser l'appel évolué
// donc certains indexes ne seront pas utilisables
// if (equivalence_nom_enu_etendu_et_enu_quelconque)
{// maintenant on va construire les tableaux qui sont équivalent aux listes
tailles_tab.Change_taille(4);
tailles_tab(1)=list_inter_val_ddl_enum.size();
tailles_tab(2)=li_coor_ddl_enum.size();
tailles_tab(3)=li_inter_tens_ddl_enum.size();
tailles_tab(4)=li_inter_tyQ.size();
// .... pour les ddl étendue
// le tableau global de ddl étendu
tab_enu_etendu.Init_from_list(li_inter_enu);
posi_ddl_enum.Init_from_list(li_inter_posi_ddl_enum);
val_ddl_enum.Init_from_list(list_inter_val_ddl_enum);
coor_ddl_enum.Init_from_list(li_coor_ddl_enum);
premier_famille_Coord.Init_from_list(li_premier_famille_Coord);
// num_dans_coor.Init_from_list(li_num_dans_coor);
num_dans_coor.Change_taille(tab_enu_etendu.Taille());
tens_ddl_enum.Init_from_list(li_inter_tens_ddl_enum);
premier_famille_tenseur.Init_from_list(li_premier_famille_tenseur);
// ind_tens.Init_from_list(li_ind_tens);
ind_tens.Change_taille(tab_enu_etendu.Taille());
index_enu_etendu.Init_from_list(li_index_enu);
// .... pour les grandeurs quelconques
// le tableau global de grandeurs quelconque
tab_enu_quelconque.Init_from_list(li_inter_tyQ);
index_enu_quelconque.Init_from_list(li_index_quelc);
// il faut maintenant revoir le tableau posi_ddl_enum dans le cas
// ou un tenseur et/ou un Coordonnee contient plusieurs Ddl_enum_etendu
// on fait systématiquement le test
// if (tab_enu_etendu.Taille() > (tailles_tab(1)+tailles_tab(2)+tailles_tab(3)))
{// on utilise les premiers de famille dont l'indice est le même que les
// tableau de tenseur et de Coordonnee
int nb_enu = tab_enu_etendu.Taille();
for (int i=1;i<=nb_enu;i++)
{// récup du type de grandeur auquel apartient l'énumération
// l'idée est de passer en revue le type de grandeur
Ddl_enum_etendu & ddenumetendu = tab_enu_etendu(i); // pour simplifier
EnumTypeGrandeur enu_type_grandeur = ddenumetendu.TypeDeGrandeur();
//TypeGrandeur(ddenumetendu.Enum());
switch (enu_type_grandeur)
{case TENSEUR : case TENSEUR_NON_SYM : case TENSEURBB : case TENSEURHH :
case TENSEURBH : case TENSEURHB : case TENSEUR_NON_SYM_BB :
case TENSEUR_NON_SYM_HH :
{ // on récupère la position dans le tableau de tenseur
int position = premier_famille_tenseur.Contient
(Ddl_enum_etendu::PremierDdlEnumEtenduFamille(ddenumetendu));
posi_ddl_enum(i)=position;
// maintenant il faut récupérer la position = l'indice, de l'enu dans le tenseur
Deuxentiers_enu deux = IJind(ddl_de_service.Enum(),dim);
ind_tens(i) = deux;
break;
}
case COORDONNEE : case COORDONNEEB : case COORDONNEEH :
{ // on récupère la position dans le tableau de Coordonnee
int position = premier_famille_Coord.Contient
(Ddl_enum_etendu::PremierDdlEnumEtenduFamille(ddenumetendu));
posi_ddl_enum(i)=position;
// maintenant il faut récupérer la position = l'indice, de l'enu dans Coordonnee
int indice_coor = Indice_coor(ddenumetendu.Enum(),dim);
num_dans_coor(i) = indice_coor;
break;
}
default : break;// sinon c'est des scalaires
}; // fin du switch
};
}; // fin du if (tab_enu_etendu.Taille() > (tailles_tab(1)+tailles_tab(2)+tailles_tab(3)))
////------- debug
//cout << "\n\n debug Fonction_nD::Construction_index_conteneurs_evoluees() : FCT= " << nom_ref
// << "\n les variables: "<< nom_variables
// << "\n li_equi_Quel_evolue= " << li_equi_Quel_evolue
// << " num_dans_coor= "<<num_dans_coor;
////------- fin debug
// .... pour les grandeurs quelconques équivalentes aux grandeurs
// évoluées non scalaires
// l'ordre d'apparition dans la liste est le même que celui dans les tableaux
// donc on parcours deux fois la liste des grandeurs, une fois pour les coordonnées et
// une fois pour les tenseurs
int nb_etendu = tab_enu_etendu.Taille();
int nb_coor = coor_ddl_enum.Taille();
tab_equi_Coor.Change_taille(nb_coor);
int nb_tenseur = tens_ddl_enum.Taille();
tab_equi_tens.Change_taille(nb_tenseur);
List_io <TypeQuelconque >::iterator iqc,iqc_fin=li_equi_Quel_evolue.end();
// cout << "\n posi_ddl_enum= " << posi_ddl_enum << endl;
for (int i=1;i<=nb_etendu;i++)
if ((type_des_variables(index_enu_etendu(i)) == 2)
|| (type_des_variables(index_enu_etendu(i)) == 3))
{EnumTypeQuelconque enuQ =
Ddl_enum_etendu::Equivalent_en_grandeur_quelconque(tab_enu_etendu(i));
TypeQuelconque tq(enuQ);
// on cherche dans la liste enregistrée
List_io <TypeQuelconque >::iterator result1 =
std::find(li_equi_Quel_evolue.begin(),li_equi_Quel_evolue.end(), tq);
if (result1 == li_equi_Quel_evolue.end())
{cout << "\n *** erreur d'adressage dans "
<< "Fonction_nD::Construction_index_conteneurs_evoluees()";
this->Affiche();
Sortie(1);
};
if (type_des_variables(index_enu_etendu(i)) == 2) // cas de coordonnées
tab_equi_Coor(posi_ddl_enum(i))=result1;
else if (type_des_variables(index_enu_etendu(i)) == 3) // cas des tenseurs
tab_equi_tens(posi_ddl_enum(i))=result1;
};
delete tens; // car on n'en a plus besoin
// on met à jour le tableau de transfert
// ici par défaut chaque type quelconque est associé à un conteneur scalaire
// si ce n'est pas le cas, on considère que l'utilisateur utilisera la méthode
// Preparation_Grandeur_quelconque( pour mettre les bonnes dimensions
x_x_i.Change_taille(tab_enu_etendu.Taille()+tab_enu_quelconque.Taille());
}; // fin du cas où il y a une équivalence parfaite
};
// Passage des infos variables évoluées en tableau de réels
// I/O : di
Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
,const Tableau <double >* val_ddl_enum
,const Tableau <Coordonnee> * coor_ddl_enum
,const Tableau <TenseurBB* >* tens_ddl_enum
,const Tableau <const TypeQuelconque * >* tqi
,const Tableau <int> * t_num_ordre)
{
#ifdef MISE_AU_POINT
if (di.Taille() != (tab_enu_etendu.Taille() + tab_enu_quelconque.Taille()))
{ cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
<< " tab_enu_etendu.Taille()= " << tab_enu_etendu.Taille()
<< " tab_enu_quelconque.Taille()= "<< tab_enu_quelconque.Taille()
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Vers_tab_double(..."<<endl;
Sortie(1);
};
if (tailles_tab(1) != 0) // cas où il existe des scalaires
{if (val_ddl_enum == NULL)
{ cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
<< " val_ddl_enum pointe sur NULL "
<< " et il est prevu d'avoir des scalaires purs !"
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Vers_tab_double(..."<<endl;
Sortie(1);
}
else
{if (val_ddl_enum->Taille() != tailles_tab(1))
{ cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
<< " taille val_ddl_enum = " << val_ddl_enum->Taille()
<< " est different du nombre prevu !" << tailles_tab(1)
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Vers_tab_double(..."<<endl;
Sortie(1);
};
};
};
if (tailles_tab(2) != 0)
{if (coor_ddl_enum == NULL)
{ cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
<< " coor_ddl_enum pointe sur NULL "
<< " et il est prevu d'avoir des coordonnees !"
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Vers_tab_double(..."<<endl;
Sortie(1);
};
};
if (tailles_tab(3) != 0)
{if (tens_ddl_enum == NULL)
{ cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
<< " tens_ddl_enum pointe sur NULL "
<< " et il est prevu d'avoir des tenseurs !"
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Vers_tab_double(..."<<endl;
Sortie(1);
};
};
if (tailles_tab(4) != 0)
{if (tqi == NULL)
{ cout << "\n *** pb dans le transfert des grandeurs quelconques vers scalaires "
<< " tqi pointe sur NULL "
<< " et il est prevu d'avoir des grandeurs quelconques !"
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Vers_tab_double(..."<<endl;
Sortie(1);
}
else if (t_num_ordre != NULL)
{if (t_num_ordre->Taille() != tqi->Taille())
{ cout << "\n *** pb dans le transfert des grandeurs quelconques vers scalaires "
<< " taille tqi = " << tqi->Taille()
<< " est different du nombre de numero d'ordre prevu !" << t_num_ordre->Taille()
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Vers_tab_double(..."<<endl;
Sortie(1);
};
};
};
#endif
// on va boucler sur les arguments:
// on utilise les index, pour un adressage indirect, pour le tableau de retour "et"
// la grandeur, normalement, cela devrait être ok
// 1) sur les enum
int nb_enu = index_enu_etendu.Taille();
for (int ienu=1;ienu <= nb_enu; ienu++)
{int num_variable = index_enu_etendu(ienu); // le numéro de nom_variable
switch (type_des_variables(num_variable))
{ case 1: // scalaire
{di(num_variable) = val_ddl_enum->operator()(posi_ddl_enum(ienu));
break;}
case 2: // Coordonnee
{int j = posi_ddl_enum(ienu);
di(num_variable) = (*coor_ddl_enum)(j)(num_dans_coor(ienu));
break;}
case 3: // tenseur
{int j = posi_ddl_enum(ienu);
int k = ind_tens(ienu).i; int l = ind_tens(ienu).j;
di(num_variable) = (*(*tens_ddl_enum)(j))(k,l);
break;}
default:
break;
};
}; // fin de la boucle sur les enum
// 2) sur les grandeurs quelconques
int nb_quelc = index_enu_quelconque.Taille();
for (int ieq = 1; ieq <= nb_quelc; ieq++)
{ int num_variable = index_enu_quelconque(ieq);
int nb_ordre = 1; // init par défaut
if (t_num_ordre != NULL)
nb_ordre = (*t_num_ordre)(ieq);
di(num_variable) = (*tqi)(ieq)->GrandeurNumOrdre(nb_ordre);
}; // fin de la boucle sur les enu quelconques
// retour
return di;
};
// idem, mais via les listes
// val_ddl_enum(k) correspond à li_evolue_scalaire de rang i
Tableau <double > & Fonction_nD::Vers_tab_double(Tableau <double > & di
,const Tableau <double >* val_ddl_enum
,List_io <Ddl_enum_etendu>* li_evolue_scalaire
,List_io <TypeQuelconque >* li_evoluee_non_scalaire
,const Tableau <const TypeQuelconque * >* tqi
,const Tableau <int> * t_num_ordre)
{
#ifdef MISE_AU_POINT
// on vérifie qu'il s'agit bien des mêmes listes
if ((&li_enu_etendu_scalaire) != li_evolue_scalaire)
{ cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
<< " la liste des enum etendu scalaires n'est pas celle fournie par la fonction"
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Vers_tab_double(..."<<endl;
Sortie(1);
};
if ((&li_equi_Quel_evolue) != li_evoluee_non_scalaire)
{ cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
<< " la liste des grandeurs evoluees non scalaire n'est pas celle fournie par la fonction"
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Vers_tab_double(..."<<endl;
Sortie(1);
};
if (li_enu_etendu_scalaire.size() != 0)
{if (val_ddl_enum==NULL)
{ cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
<< " val_ddl_enum pointe sur NULL "
<< " et il est prevu d'avoir "<< li_enu_etendu_scalaire.size() << " grandeurs scalaires !"
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Vers_tab_double(..."<<endl;
Sortie(1);
};
if (val_ddl_enum->Taille() != li_enu_etendu_scalaire.size())
{ cout << "\n *** pb dans le transfert des grandeurs evoluees vers scalaires "
<< " val_ddl_enum est de taille " << val_ddl_enum->Taille()
<< " alors qu'il est prevu d'avoir "<< li_enu_etendu_scalaire.size() << " grandeurs scalaires !"
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Vers_tab_double(..."<<endl;
Sortie(1);
};
};
if (tailles_tab(4) != 0)
{if (tqi == NULL)
{ cout << "\n *** pb dans le transfert des grandeurs quelconques vers scalaires "
<< " tqi pointe sur NULL "
<< " et il est prevu d'avoir des grandeurs quelconques !"
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Vers_tab_double(..."<<endl;
Sortie(1);
}
else if (t_num_ordre != NULL)
{if (t_num_ordre->Taille() != tqi->Taille())
{ cout << "\n *** pb dans le transfert des grandeurs quelconques vers scalaires "
<< " taille tqi = " << tqi->Taille()
<< " est different du nombre de numero d'ordre prevu !" << t_num_ordre->Taille()
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n Fonction_nD::Vers_tab_double(..."<<endl;
Sortie(1);
};
};
};
#endif
// on va boucler sur les arguments:
List_io <Ddl_enum_etendu>::iterator i_scal = li_enu_etendu_scalaire.begin();
List_io <TypeQuelconque >::iterator i_evol = li_equi_Quel_evolue.begin();
int indice_scal=1; // init : indice dans le tableau val_ddl_enum
////------- debug
//cout << "\n\n debug Fonction_nD::Vers_tab_double( : FCT= " << nom_ref
// << "\n les variables: "<< nom_variables
// << "\n li_equi_Quel_evolue= " << li_equi_Quel_evolue
// << " num_dans_coor= "<<num_dans_coor;
////------- fin debug
// 1) sur les enum
int nb_enu = index_enu_etendu.Taille();
// qui a la même taille que tab_enu_etendu, et dans le même ordre
for (int ienu=1;ienu <= nb_enu; ienu++)
{int num_variable = index_enu_etendu(ienu); // le numéro de nom_variable
switch (type_des_variables(num_variable))
{ case 1: // scalaire
{di(num_variable) = (*val_ddl_enum)(posi_ddl_enum(ienu));
break;}
case 2: // Coordonnee
{int j = posi_ddl_enum(ienu);
// pour simplifier l'écriture
List_io<TypeQuelconque >::iterator& il = tab_equi_Coor(j);
Grandeur_coordonnee& coo = *((Grandeur_coordonnee*) (*il).Grandeur_pointee());
Coordonnee& coord = *(coo.ConteneurCoordonnee());
di(num_variable) = coord(num_dans_coor(ienu));
////------- debug
//cout << "\n num_variable= "<<num_variable
// << " di (num_variable)= "<<di(num_variable)
// << " num_dans_coor("<<ienu<<")= "<<num_dans_coor(ienu)
// << "\n coord= "<<coord ;
////------- fin debug
i_evol++;
break;}
case 3: // tenseur
{int j = posi_ddl_enum(ienu);
int k = ind_tens(ienu).i; int l = ind_tens(ienu).j;
// pour simplifier l'écriture
List_io<TypeQuelconque >::iterator& il = tab_equi_tens(j);
Grandeur_TenseurBB& ten = *((Grandeur_TenseurBB*) (*il).Grandeur_pointee());
TenseurBB& tensBB = ten.RefConteneurTenseur();
di(num_variable) = tensBB(k,l);
i_evol++;
break;}
default:
break;
};
}; // fin de la boucle sur les enum
// 2) sur les grandeurs quelconques
int nb_quelc = index_enu_quelconque.Taille();
for (int ieq = 1; ieq <= nb_quelc; ieq++)
{ int num_variable = index_enu_quelconque(ieq);
int nb_ordre = 1; // init par défaut
if (t_num_ordre != NULL)
nb_ordre = (*t_num_ordre)(ieq);
di(num_variable) = (*tqi)(ieq)->GrandeurNumOrdre(nb_ordre);
}; // fin de la boucle sur les enu quelconques
////------ debug
//cout << "\n debug Fonction_nD::Vers_tab_double( ";
//cout << di << endl;
//
////------ fin debug
// retour
return di;
};
// appel de la fonction sous forme d'une méthode avec un nombre non limité
// de paramètres: en fait utilise Valeur
// c'est une méthode avec retour uniquement en scalaire, sinon -> erreur
// calcul des valeurs de la fonction
double Fonction_nD::Val_avec_nbArgVariable(double x,...)
{
// un certain nombre de variables utilisée pour gérer
// http://www.cplusplus.com/reference/cstdarg/va_copy/
// cf. variadic function
int count = 0;
double val = x;
va_list vl,vl_count;
va_start(vl,x);
// on va remplir le tableau xinter, pour faire un appel classique
int nb_var = this->NbVariable();
if (xinter == NULL)
xinter = new Tableau <double >(nb_var);
if (nb_var != 0)
{(*xinter)(count+1)=val;
/* count number of arguments: */
va_copy(vl_count,vl);
while (val != 0)
{if (count < nb_var) // cas normal
{val=va_arg(vl_count,double);
++count;
(*xinter)(count+1)=val;
}
else // sinon il y a plus d'argument que prévu, on génère une erreur
{ cout << "\n *** erreur dans l'appel de la fonction " << nom_ref
<< " le nombre d'argument est superieur a "<< nb_var
<< " ce qui n'est pas prevu dans la definition de la fonction "
<< "\n Fonction_nD::Val_avec_nbArgVariable( ";
if (ParaGlob::NiveauImpression() > 1)
this->Affiche();
cout << endl;
Sortie(1);
};
};
va_end(vl_count);
};
// maintenant on peut utiliser la méthode classique
Tableau <double> & ret = this->Valeur_FnD_interne(xinter);
return ret(1);
};
// méthode utilisée par les classes dérivées, pour transférer les infos qui sont
// gérées au niveau de Fonction_nD
Fonction_nD& Fonction_nD::Transfert_info(const Fonction_nD& elt)
{ // on reprend toutes les données gérées par Fonction_nD
typeFonction = elt.typeFonction;
nom_ref = elt.nom_ref;
nom_variables = elt.nom_variables;
t_inter_double = elt.t_inter_double;
enu_variables_globale = elt.enu_variables_globale;
nom_variables_globales = elt.nom_variables_globales;
tab_enu_etendu = elt.tab_enu_etendu;
type_des_variables = elt.type_des_variables;
val_ddl_enum = elt.val_ddl_enum;
li_enu_etendu_scalaire = elt.li_enu_etendu_scalaire;
coor_ddl_enum = elt.coor_ddl_enum;
num_dans_coor = elt.num_dans_coor;
tens_ddl_enum = elt.tens_ddl_enum;
premier_famille_tenseur = elt.premier_famille_tenseur;
ind_tens = elt.ind_tens;
posi_ddl_enum = elt.posi_ddl_enum;
tailles_tab = elt.tailles_tab;
tab_enu_quelconque = elt.tab_enu_quelconque;
equivalence_nom_enu_etendu_et_enu_quelconque = elt.equivalence_nom_enu_etendu_et_enu_quelconque;
index_enu_etendu = elt.index_enu_etendu;
index_enu_quelconque = elt.index_enu_quelconque;
// les listes pour les appels via les listes
li_enu_etendu_scalaire = elt.li_enu_etendu_scalaire;
li_equi_Quel_evolue = elt.li_equi_Quel_evolue;
tab_equi_Coor = elt.tab_equi_Coor;
tab_equi_tens = elt.tab_equi_tens;
x_x_i = elt.x_x_i;
x_glob = elt.x_glob;
depend_M = elt.depend_M;
depend_Mt = elt.depend_Mt;
depend_M0 = elt.depend_M0;
depend_temps = elt.depend_temps;
};
// affichage des données internes, utilisée par les fonctions dérivées
// niveau donne le degré d'affichage
void Fonction_nD::Affiche_interne(int niveau) const
{ if (niveau > 0)
{ cout << "\n type_de_fonction: "<< Nom_Fonction_nD(typeFonction)
<< " nom_ref= " << nom_ref
<< "\n les_variables_lues: " << nom_variables ;
if (niveau > 1)
{ // les énumérés globaux éventuels
int taille_enu_variables_globale= enu_variables_globale.Taille();
if (taille_enu_variables_globale != 0)
{ cout << "\n enumeres_globaux:_taille " << enu_variables_globale.Taille();
for (int i=1;i<= taille_enu_variables_globale;i++)
cout << " " << Nom_GrandeurGlobale(enu_variables_globale(i));
};
// les noms de variables globales éventuelles
int taille_nom_variables_globales= nom_variables_globales.Taille();
if (taille_nom_variables_globales != 0)
{ cout << "\n noms_variables_globales:_taille " << nom_variables_globales.Taille();
for (int i=1;i<= taille_nom_variables_globales;i++)
cout << " " << nom_variables_globales(i);
};
// enu étendu équivalent aux variables non globales
int taille_tab_enu_etendu= tab_enu_etendu.Taille();
if (taille_tab_enu_etendu != 0)
{ cout << "\n enum_etendu_locaux:_taille " << tab_enu_etendu.Taille();
for (int i=1;i<= taille_tab_enu_etendu;i++)
{cout << " " << tab_enu_etendu(i).Nom_plein();
int j = posi_ddl_enum(i);
switch (type_des_variables(i))
{case 1: cout << " type scalaire: valeur actuelle= "
<< val_ddl_enum(j) ;
break;
case 2: cout << " type coordonnees: valeur actuelle= "
<< coor_ddl_enum(j)(num_dans_coor(j));
break;
case 3: cout << " type tenseur: valeur actuelle= "
<< (*tens_ddl_enum(j))(ind_tens(j).i,ind_tens(j).j) ;
break;
default: cout << "\n type non reconnue= " << type_des_variables(i)
<< "\n Fonction_nD::Affiche_interne( ";
Sortie(1);
};
};
// bilan des variables évoluées
cout << "\n il y a: "
<< tailles_tab(1) << " scalaire(s) "
<< tailles_tab(2) << " coordonnee(s) "
<< tailles_tab(3) << " composante(s) de tenseur "
<< endl;
};
// grandeurs quelconques équivalentes aux variables non globales
int taille_tab_enu_quelconque= tab_enu_quelconque.Taille();
if (taille_tab_enu_quelconque != 0)
{ cout << "\n enum_quelconque:_taille " << tab_enu_quelconque.Taille()
<< "\n liste: ";
for (int i=1;i<= taille_tab_enu_quelconque;i++)
cout << NomTypeQuelconque(tab_enu_quelconque(i)) << ", ";
};
};
// autres infos
cout << "\n il y a " << this->NbComposante() << " valeur(s) en retour de la fonction ";
if (depend_temps || depend_M || depend_Mt ||depend_M0 )
{ cout << "\n ";
if (depend_temps)
cout << " la fonction depend du temps, ";
if (depend_M || depend_Mt ||depend_M0 )
cout << " la fonction depend du point M : ";
if (depend_M)
cout << " courant, ";
if (depend_Mt)
cout << " a t, ";
if (depend_M0)
cout << " a 0, ";
};
};
};
//------ méthodes appelée par les classes dérivées ----
// relatives aux données gérées par Fonction_nD
// 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 Fonction_nD::Lect_base_info(ifstream& ent,const int cas)
{
if (cas == 1)
{ string toto; string nom;
// lecture des arguments
ent >> nom >> nom_variables;
t_inter_double.Change_taille(nom_variables.Taille());
// les énumérés des variables globales
ent >> nom;
int nb_enu=0;
ent >> nom >> nb_enu;
enu_variables_globale.Change_taille(nb_enu);
for (int i=1;i<= nb_enu;i++)
{ ent >> nom;
enu_variables_globale(i) = Id_nom_GrandeurGlobale(nom);
};
// les nom des variables globales indicées en string
ent >> nom;
int nb_nom=0;
ent >> nom >> nb_nom;
nom_variables_globales.Change_taille(nb_nom);
for (int i=1;i<= nb_nom;i++)
{ ent >> nom;
nom_variables_globales(i) = nom;
};
// enu étendu équivalent aux variables non globales
ent >> nom >> tab_enu_etendu;
// grandeurs quelconques équivalentes aux variables non globales
int taille_tab_enu_quelconque; // init
ent >> nom >> taille_tab_enu_quelconque >> toto;
tab_enu_quelconque.Change_taille(taille_tab_enu_quelconque);
for (int i=1;i<= taille_tab_enu_quelconque;i++)
{ent >> nom;
tab_enu_quelconque(i) = Id_nomTypeQuelconque(nom);
};
// bilan des variables évoluées (on lit pour passer les infos
// dans le .BI, mais cela va être recalculé au moment de la fabrication
// des index
tailles_tab.Change_taille(4);
ent >> nom
>> tailles_tab(1) >> nom
>> tailles_tab(2) >> nom
>> tailles_tab(3) >> nom
>> tailles_tab(4) >> nom;
ent >> nom >> permet_affichage ;
// Contruction des index pour les grandeurs évoluées, ainsi que les conteneurs
Fonction_nD::Construction_index_conteneurs_evoluees();
};
};
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void Fonction_nD::Ecrit_base_info(ofstream& sort,const int cas)
{
if (cas == 1)
{ // les variables
sort << " \n arguments= " << nom_variables
<< " \n variables_globales_en_enumere= " ;
int nb_enu = enu_variables_globale.Taille();
sort << "taille " << nb_enu << " ";
for (int i=1;i<= nb_enu;i++)
sort << Nom_GrandeurGlobale(enu_variables_globale(i)) << " ";
sort << " \n variables_globales_en_string= " ;
int nb_str = nom_variables_globales.Taille();
sort << "taille " << nb_str << " ";
for (int i=1;i<= nb_str;i++)
sort << nom_variables_globales(i) << " ";
// enu étendu équivalent aux variables non globales
int taille_tab_enu_etendu= tab_enu_etendu.Taille();
sort << "\n enum_etendu_locaux: " << tab_enu_etendu;
// grandeurs quelconques équivalentes aux variables non globales
int taille_tab_enu_quelconque= tab_enu_quelconque.Taille();
sort << "\n enum_quelconque:_taille " << tab_enu_quelconque.Taille()
<< "\n liste: ";
for (int i=1;i<= taille_tab_enu_quelconque;i++)
sort << NomTypeQuelconque(tab_enu_quelconque(i)) << " ";
// bilan des variables évoluées
sort << "\n bilan_var_evolue_il_y_a: "
<< tailles_tab(1) << " scalaire(s) "
<< tailles_tab(2) << " coordonnee(s) "
<< tailles_tab(3) << " composante(s)_de_tenseur "
<< tailles_tab(4) << " grandeur_quelconque "
;
sort << "\n permet_affichage_ "<<permet_affichage << " ";
};
};
// sortie du schemaXML: en fonction de enu
void Fonction_nD::SchemXML_Fonctions_nD(ofstream& sort,const Enum_IO_XML enu)
{
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;
}
};
};
// lecture d'une ou plusieurs variables
// peut-être appelée plusieurs fois,
// stockage des infos dans Fonction_nD
void Fonction_nD::Lecture_variables(string& nom_lu,UtilLecture * entreePrinc)
{
// on lit tant que l'on ne rencontre pas une ligne contenant
// une info ne correspondant pas à des variables // ou un nouveau mot clé global auquel cas il y a pb !!
MotCle motCle; // ref aux mots cle
// on utilise des listes pour éviter les doublons
list <Enum_GrandeurGlobale > list_enu_variables_glob; // enum glob
// on transvase le tableau dans la liste
enu_variables_globale.Init_list(list_enu_variables_glob);
// idem pour les noms globaux
list < string> list_de_variables_nom_globales; // string glob
nom_variables_globales.Init_list(list_de_variables_nom_globales);
// puis les variables qui ne sont pas globales
list < string> list_de_variables; // liste
nom_variables.Init_list(list_de_variables);
bool lecture_effective = false; // init
while (( (strstr(entreePrinc->tablcar,"un_argument=")==0)
&& (strstr(entreePrinc->tablcar,"deb_list_var_")==0)
)
|| (nom_lu == "un_argument=")
|| (nom_lu == "deb_list_var_")
)
{
// 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 definition d'une courbe avec expression litterale : on n'a pas trouve de mot cle relatif a une variable"
<< " et par contre la ligne courante contient un mot cle global "
<< " *** a priori il y a une erreur de mise en donnees ! " ;
entreePrinc->MessageBuffer("** erreur des parametres d'une fonction nD **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// lecture d'un mot clé éventuellement
if (( (nom_lu != "un_argument=")
&& (nom_lu != "deb_list_var_")
)
|| lecture_effective
)
*(entreePrinc->entree) >> nom_lu;
// sinon cela veut dire que nom_lu a déjà été lu et repéré
// relatif à une variable
// ou que l'on vient de terminer une lecture de variabl
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
{ // on lit sans tenir compte des < éventuelles
entreePrinc->NouvelleDonneeSansInf();
*(entreePrinc->entree) >>nom_lu;
}
#else
else if ((entreePrinc->entree)->eof())
// la lecture est bonne mais on a atteind la fin de la ligne
{ if(nom_lu != "fin_parametres_fonction_expression_litterale_")
// on lit sans tenir compte des < éventuelles
{entreePrinc->NouvelleDonneeSansInf();
*(entreePrinc->entree) >> nom_lu;
};
}
#endif
else // cas d'une erreur de lecture
{ cout << "\n erreur de lecture inconnue ";
entreePrinc->MessageBuffer("** erreur2 des parametres d'une courbe expression litterale**");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
};
// cas de la lecture d'une variable
if(nom_lu == "un_argument=")
{*(entreePrinc->entree) >> nom_lu;
// on regarde s'il s'agit d'une variable globale correspondant à un énuméré global
if (EstUneGrandeurGlobale(nom_lu))
{ list_enu_variables_glob.push_back(Id_nom_GrandeurGlobale (nom_lu));}
// idem mais sous forme d'un string
else if (ParaGlob::param->GrandeurGlobal(nom_lu) != NULL)
{ list_de_variables_nom_globales.push_back(nom_lu);}
else // sinon ce n'est pas une grandeur globale
{list_de_variables.push_back(nom_lu);};
// on signale que la lecture a été effective
lecture_effective = true;
}
else if(nom_lu == "deb_list_var_") // lecture d'une liste d'argument
{// on va lire juqu'au mot clé fin_list_var_
int nb_boucle = 0; // indicateur pour éviter une boucle infinie
do
{*(entreePrinc->entree) >> nom_lu;
if (nom_lu == "fin_list_var_")
break;
// on regarde s'il s'agit d'une variable globale
if (EstUneGrandeurGlobale(nom_lu))
{ list_enu_variables_glob.push_back(Id_nom_GrandeurGlobale (nom_lu));}
// idem mais sous forme d'un string
else if (ParaGlob::param->GrandeurGlobal(nom_lu) != NULL)
{ list_de_variables_nom_globales.push_back(nom_lu);}
else // sinon ce n'est pas une grandeur globale
{list_de_variables.push_back(nom_lu);};
nb_boucle++;
} while (nb_boucle < 200);
if (nb_boucle > 199)
{ cout << "\n erreur de lecture au niveau d'une liste de variable "
<< " deb_list_var_ nom1 nom2 ... fin_list_var_";
entreePrinc->MessageBuffer("** erreur lecture parametre d'une d'une fonction nD ** **");
throw (UtilLecture::ErrNouvelleDonnee(-1));
Sortie(1);
}
else // sinon c'est ok
// on signale que la lecture a été effective
lecture_effective = true;
}
; // sinon rien, ce n'est plus une variable, on va donc sortir
// du while à la suite
}; // fin du while
// nom_lu contient la dernière information lue qui ne correspond pas à une variable
//--- maintenant on va gérer les variables lues
// on supprime les doublons dans les variables globales
list_enu_variables_glob.sort();
list_enu_variables_glob.unique();
list_de_variables_nom_globales.sort();
list_de_variables_nom_globales.unique();
// on remet à jour le tableau des énumérés globaux
enu_variables_globale.Init_from_list(list_enu_variables_glob);
// idem pour les noms de reférence globaux
nom_variables_globales.Init_from_list(list_de_variables_nom_globales);
// puis pour les variables qui ne sont pas globales
nom_variables.Init_from_list(list_de_variables);
// on met à jour les tableaux internes de passage de valeurs
x_x_i.Change_taille(nom_variables.Taille());
x_glob.Change_taille(enu_variables_globale.Taille()+nom_variables_globales.Taille());
};
// affichage des variables de la fonction, dépend du niveau d'impression
void Fonction_nD::Affichage_variables() const
{
if (permet_affichage > 5)
{ cout << "\n ---- Fonction_nD " << nom_ref ;
cout << " \n arguments_specifiques= " << nom_variables
<< " \n variables_globales_en_enumere= " ;
int nb_enu = enu_variables_globale.Taille();
cout << "taille " << nb_enu << " ";
for (int i=1;i<= nb_enu;i++)
cout << Nom_GrandeurGlobale(enu_variables_globale(i)) << " ";
cout << " \n variables_globales_en_string= " ;
int nb_str = nom_variables_globales.Taille();
cout << "taille " << nb_str << " ";
for (int i=1;i<= nb_str;i++)
cout << nom_variables_globales(i) << " ";
};
};
// récupération des valeurs des variables globales et stockage dans le tableau
// interne x_glob
void Fonction_nD::Recup_Grandeurs_globales()
{ // --- on parcours les variables globales:
// 1) les énumérés
int index_glob=1;
int tail_enu = enu_variables_globale.Taille();
if (tail_enu>0)
{
// en debug on vérifie que les grandeurs globales sont présentent
#ifdef MISE_AU_POINT
try
{ int taille = enu_variables_globale.Taille();
for (int i=1;i<= taille;i++)
{// on récupère le pointeur correspondant à la grandeur
const void* pointe = (ParaGlob::param->GrandeurGlobal(enu_variables_globale(i)));
if (pointe == NULL)
{ cout << "\n *** pb dans l'appel de la fonction " << nom_ref << " !! "
<< " la variable globale "<< Nom_GrandeurGlobale(enu_variables_globale(i))
<< ", n'est pas disponible, on ne peut pas continuer "
<< "\n Fonction_nD::Recup_Grandeurs_globales(..."<<endl;
// on génère une interruption ce qui permettra de dépiler les appels
this->Affiche();ErrCalculFct_nD toto;throw (toto);
Sortie(1);
};
};
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch(...)
{ cout << "\n ** erreur dans l'appel de la fonction "
<< nom_ref ;
cout << " verifier la presence des grandeurs globales voulues "
<< "\n Fonction_nD::Recup_Grandeurs_globales(..."<<endl;
// on génère une interruption ce qui permettra de dépiler les appels
this->Affiche();ErrCalculFct_nD toto;throw (toto);
Sortie(1);
};
#endif
for (int i=1;i<= tail_enu;i++,index_glob++)
{// on récupère le pointeur correspondant à la grandeur
const void* pointe = (ParaGlob::param->GrandeurGlobal(enu_variables_globale(i)));
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
switch(gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie())
{ case TYPE_SIMPLE:
{ switch(gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere())
{case PARTICULIER_SCALAIRE_ENTIER:
{Grandeur_scalaire_entier& gr
= *((Grandeur_scalaire_entier*) gr_quelc->Grandeur_pointee()); // pour simplifier
x_glob(index_glob) = *(gr.ConteneurEntier());
break;
}
case PARTICULIER_SCALAIRE_DOUBLE:
{Grandeur_scalaire_double& gr
= *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
x_glob(index_glob) = *(gr.ConteneurDouble());
break;
}
case PARTICULIER_DDL_ETENDU:
{Grandeur_Ddl_etendu& gr
= *((Grandeur_Ddl_etendu*) gr_quelc->Grandeur_pointee()); // pour simplifier
x_glob(index_glob) = (gr.GrandeurNumOrdre(1));
break;
}
case PARTICULIER_SCALAIRE_DOUBLE_NOMMER_INDICER:
{Grandeur_Double_Nommer_indicer& gr
= *((Grandeur_Double_Nommer_indicer*) gr_quelc->Grandeur_pointee()); // pour simplifier
x_glob(index_glob) = *(gr.ConteneurDouble());
break;
}
default:
{ cout << "\n *** pb dans dans l'appel de la fonction "<< nom_ref
<< " la variable globale "<< Nom_GrandeurGlobale(enu_variables_globale(i))
<< ", n'est pas prise en compte actuellement , on ne peut pas continuer "
<< "\n Fonction_nD::Recup_Grandeurs_globales(..."
<<endl;
// on génère une interruption ce qui permettra de dépiler les appels
this->Affiche();ErrCalculFct_nD toto;throw (toto);
Sortie(1);
};
}
break;
}
default:
{ cout << "\n *** pb dans dans l'appel de la fonction "<< nom_ref
<< " la variable globale "<< Nom_GrandeurGlobale(enu_variables_globale(i))
<< ", n'est pas prise en compte actuellement , on ne peut pas continuer "
<< "\n Fonction_nD::Recup_Grandeurs_globales(..."
<<endl;
// on génère une interruption ce qui permettra de dépiler les appels
this->Affiche();ErrCalculFct_nD toto;throw (toto);
Sortie(1);
};
};
if (permet_affichage > 5)
{cout << "\n " << Nom_GrandeurGlobale(enu_variables_globale(i))
<< " " << x_glob(index_glob);
};
};
};
// 2) idem pour les globaux en nom c-a-d typées sous forme de string
int tail_nom = nom_variables_globales.Taille();
if (tail_nom>0)
{
// en debug on vérifie que les grandeurs globales sont présentent
#ifdef MISE_AU_POINT
try
{ for (int i=1;i<= tail_nom;i++)
{// on récupère le pointeur correspondant à la grandeur
const void* pointe = (ParaGlob::param->GrandeurGlobal(nom_variables_globales(i)));
if (pointe == NULL)
{ cout << "\n *** pb dans Fonction_expression_litterale_nD " << nom_ref << " !! "
<< " la variable globale "<< nom_variables_globales(i)
<< ", n'est pas disponible, on ne peut pas continuer "
<< "\n Fonction_nD::Recup_Grandeurs_globales(..."<<endl;
// on génère une interruption ce qui permettra de dépiler les appels
this->Affiche();ErrCalculFct_nD toto;throw (toto);
Sortie(1);
};
};
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch(...)
{ cout << "\n ** erreur dans l'appel de la fonction "
<< nom_ref ;
cout << " verifier la presence des grandeurs globales voulues "
<< "\n Fonction_nD::Recup_Grandeurs_globales(..."<<endl;
// on génère une interruption ce qui permettra de dépiler les appels
this->Affiche();ErrCalculFct_nD toto;throw (toto);
Sortie(1);
};
#endif
// on parcours les variables globales
int taille = nom_variables_globales.Taille();
for (int i=1;i<= taille;i++,index_glob++)
{// on récupère le pointeur correspondant à la grandeur
const void* pointe = (ParaGlob::param->GrandeurGlobal(nom_variables_globales(i)));
TypeQuelconque* gr_quelc = (TypeQuelconque*) (pointe);
switch(gr_quelc->Grandeur_pointee()->Type_structure_grandeurAssocie())
{ case TYPE_SIMPLE:
{ switch(gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere())
{case PARTICULIER_SCALAIRE_ENTIER:
{Grandeur_scalaire_entier& gr
= *((Grandeur_scalaire_entier*) gr_quelc->Grandeur_pointee()); // pour simplifier
x_glob(index_glob) = *(gr.ConteneurEntier());
break;
}
case PARTICULIER_SCALAIRE_DOUBLE:
{Grandeur_scalaire_double& gr
= *((Grandeur_scalaire_double*) gr_quelc->Grandeur_pointee()); // pour simplifier
x_glob(index_glob) = *(gr.ConteneurDouble());
break;
}
case PARTICULIER_DDL_ETENDU:
{Grandeur_Ddl_etendu& gr
= *((Grandeur_Ddl_etendu*) gr_quelc->Grandeur_pointee()); // pour simplifier
x_glob(index_glob) = (gr.GrandeurNumOrdre(1));
break;
}
case PARTICULIER_SCALAIRE_DOUBLE_NOMMER_INDICER:
{Grandeur_Double_Nommer_indicer& gr
= *((Grandeur_Double_Nommer_indicer*) gr_quelc->Grandeur_pointee()); // pour simplifier
x_glob(index_glob) = *(gr.ConteneurDouble());
break;
}
case PARTICULIER_VECTEUR_NOMMER:
{Grandeur_Vecteur_Nommer& gr
= *((Grandeur_Vecteur_Nommer*) gr_quelc->Grandeur_pointee()); // pour simplifier
x_glob(index_glob) = (gr.GrandeurNumOrdre(1));
#ifdef MISE_AU_POINT
// on vérifie qu'une seule grandeur est stockée
if (gr.NbMaxiNumeroOrdre() > 1)
{ cout << "\n *** pb dans dans l'appel de la fonction "<< nom_ref
<< " la variable globale "<< nom_variables_globales(i)
<< ", correspond a un vecteur a plusieur composantes, ce n'est pas pris en "
<< " compte pour l'intant, on ne peut pas continuer "
<< "\n Fonction_nD::Recup_Grandeurs_globales(..."
<<endl;
// on génère une interruption ce qui permettra de dépiler les appels
this->Affiche();ErrCalculFct_nD toto;throw (toto);
Sortie(1);
};
#endif
break;
}
default:
{ cout << "\n *** pb dans dans l'appel de la fonction "<< nom_ref
<< " la variable globale "<< nom_variables_globales(i)
<< ", n'est pas prise en compte actuellement , on ne peut pas continuer "
<< "\n Fonction_nD::Recup_Grandeurs_globales(..."
<<endl;
// on génère une interruption ce qui permettra de dépiler les appels
this->Affiche();ErrCalculFct_nD toto;throw (toto);
Sortie(1);
};
}
break;
}
case TABLEAU_T: // valable uniquement pour les vecteur nommer
// dans ce cas on n'utilise pour l'instant que la première valeur
{ switch(gr_quelc->Grandeur_pointee()->Type_enumGrandeurParticuliere())
{ case PARTICULIER_VECTEUR_NOMMER:
{Grandeur_Vecteur_Nommer& gr
= *((Grandeur_Vecteur_Nommer*) gr_quelc->Grandeur_pointee()); // pour simplifier
x_glob(index_glob) = (gr.GrandeurNumOrdre(1));
#ifdef MISE_AU_POINT
// on vérifie qu'une seule grandeur est stockée
if (gr.NbMaxiNumeroOrdre() > 1)
{ cout << "\n *** pb dans dans l'appel de la fonction "<< nom_ref
<< " la variable globale "<< nom_variables_globales(i)
<< ", correspond a un vecteur a plusieur composantes, ce n'est pas pris en "
<< " compte pour l'intant, on ne peut pas continuer "
<< "\n grandeur= "<<gr<< " NbMaxiNumeroOrdre()= "<< gr.NbMaxiNumeroOrdre()
<< "\n Fonction_nD::Recup_Grandeurs_globales(..."
<<endl;
// on génère une interruption ce qui permettra de dépiler les appels
this->Affiche();ErrCalculFct_nD toto;throw (toto);
Sortie(1);
};
#endif
break;
}
default:
{ cout << "\n *** pb dans dans l'appel de la fonction "<< nom_ref
<< " la variable globale "<< nom_variables_globales(i)
<< ", n'est pas prise en compte actuellement , on ne peut pas continuer "
<< "\n Fonction_nD::Recup_Grandeurs_globales(..."
<<endl;
// on génère une interruption ce qui permettra de dépiler les appels
this->Affiche();ErrCalculFct_nD toto;throw (toto);
Sortie(1);
};
}
break;
}
default:
{ cout << "\n *** pb dans dans l'appel de la fonction "<< nom_ref
<< " la variable globale "<< nom_variables_globales(i)
<< ", n'est pas prise en compte actuellement , on ne peut pas continuer "
<< "\n Fonction_nD::Recup_Grandeurs_globales(..."
<<endl;
// on génère une interruption ce qui permettra de dépiler les appels
this->Affiche();ErrCalculFct_nD toto;throw (toto);
Sortie(1);
};
};
if (permet_affichage > 5)
{cout << "\n " << nom_variables_globales(i)
<< " " << x_glob(index_glob);
};
};
};
};
Reference in a new issue Copy permalink