
// 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-2022 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  
