// 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) . // // 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 . // // For more information, please consult: . /************************************************************************ * DATE: 01/06/2016 * * $ * * AUTEUR: G RIO (mailto:gerardrio56@free.fr) * * $ * * PROJET: Herezh++ * * $ * ************************************************************************ * BUT:gestion des différentes fonctions multivariables enregistrées.* * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * * * VERIFICATION: * * * * ! date ! auteur ! but ! * * ------------------------------------------------------------ * * ! ! ! ! * * $ * * '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * * MODIFICATIONS: * * ! date ! auteur ! but ! * * ------------------------------------------------------------ * * $ * ************************************************************************/ #ifndef LESFONCTIONS_ND_H #define LESFONCTIONS_ND_H #include "Fonction_nD.h" #include #include "UtilLecture.h" #include "MotCle.h" #include #include "Enum_IO_XML.h" #include "LesCourbes1D.h" /// @addtogroup Les_fonctions_nD /// @{ /// /** * * \author Gérard Rio * \version 1.0 * \date 01/06/2016 * \brief gestion des différentes fonctions multivariables enregistrées. * */ class LesFonctions_nD { public : // CONSTRUCTEURS : // constructeur par défaut LesFonctions_nD (const LesCourbes1D* lesC1 = NULL ); // DESTRUCTEUR : ~LesFonctions_nD (); // METHODES PUBLIQUES : // changement du pointeur sur LesCourbes1D: prévu une seule fois // sinon cela veut dire que lesCourbes1D n'est pas un singleton !! // donc n'est possible que si lesCourbes1D n'a pas été attribué // ok également si c'est le même pointeur qui est déjà enregistré void Attribut_pointeur_lesCourbes1D(const LesCourbes1D * lesC); // lecture des Fonctions void Lecture(UtilLecture & entreePrinc); // affichage et definition interactive des commandes void Info_commande_lesFonctions_nD(UtilLecture & entreePrinc); // affichage des Fonctions void Affiche() const ; // test si la courbe de nom st1 existe reellement // retourne false si n'existe pas , true sinon bool Existe(const string & st1) const ; // retourne la courbe correspondant a une cle //const Fonction_nD * Trouve(const string & st1) const ; // vérification que tout est ok, pres à l'emploi // ramène true si ok, false sinon bool Complet(); // utilitaire pour lire une courbe, soit qui ne sera pas stocké par LesFonctions_nD // dans ce cas sont nom est "_", soit son nom correspond à une ref de nom de Fonctions existante // dans tous les cas on lit un nom et un type de courbe c-a-d un string et un EnumFonction_nD // ----- différents cas ------- // ptcourbe: soit == NULL, : on lit un nom, et on lit un type de courbe // 1) si celui-ci est "_", cela signifie que la courbe à lire // est interne à l'utilisateur, on crée une courbe, on lit la courbe // avec Lecture_base_info de la courbe et on ramène un pointeur sur la // nouvelle courbe // 2) si celui-ci est différent de "_", c'est une référence de courbe // on lit la référence et on ramène un pointeur sur la courbe de // LesFonctions_nD correspondant // // soit == une courbe existante: on lit un nom, et on regarde le nom actuel de la courbe pointée // par ptcourbe que l'on appelera nom_ref // 1) nom = "_" et nom_ref = "_" // 1-a les deux Fonctions sont du même type on relie les données avec Lecture_base_info // et on ramène ptcourbe // 1-b les deux Fonctions sont de type différent, on supprime la courbe pointée par // ptcourbe, on en crée une nouvelle adoc, et on ramène un pointeur dessus // 2) nom != "_" et nom_ref == "_" // la Fonctions pointé par ptcourbe est supprimé, et on associe le pointeur de retour // a la courbe correspondant à nom de LesFonctions_nD // 3) nom == "_" et nom_ref != "_" // on crée une nouvelle courbe adoc, on lie avec Lecture_base_info, et on ramène // un pointeur sur la courbe ainsi crée Fonction_nD * Lecture_pour_base_info(ifstream& ent,const int cas,Fonction_nD * ptcourbe); // écriture pour base info // c'est le pendant de Lecture_pour_base_info, de manière à être cohérent static void Ecriture_pour_base_info(ofstream& sort,const int cas,Fonction_nD * ptcourbe); //----- 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); // 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); // sortie du schemaXML: en fonction de enu void SchemaXML_lesFonctions_nD(ofstream& sort,const Enum_IO_XML enu) ; protected : // VARIABLES PROTEGEES : // list listeDeFonction_nD; // liste des Fonctions 1D // liste de Fonctions sous forme d'un arbre pour faciliter la recherche // map < string, Ref_Fonction_nD , std::less > listeDeFonction_nD; map < string, Fonction_nD * , std::less > listeDeFonction_nD; // un pointeur sur LesCourbes1D ce qui permet de définir des fonctions avec des courbes 1D // ici on considère que LesCourbes1D n'a qu'un membre sinon erreur: // l'instance est donc un singleton, mais on n'utilise pas une variable static pour éviter les // pb en multistreading const LesCourbes1D * lesCourbes1D; static MotCle motCle; // liste des mots clés // METHODES PROTEGEES : }; /// @} // end of group #endif