// 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:        06/03/2013                                          *
 *                                                                $     *
 *     AUTEUR:      G RIO   (mailto:gerardrio56@free.fr)                *
 *                                                                $     *
 *     PROJET:      Herezh++                                            *
 *                                                                $     *
 ************************************************************************
 *     BUT: Classe pour stocker l'ensemble des informations concernant  *
 *          les chargements externes sur l'élément                      *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *                                                                      *
 *     VERIFICATION:                                                    *
 *                                                                      *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *     !        !            !                                    !     *
 *                                                                $     *
 *     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
 *     MODIFICATIONS:                                                   *
 *     !  date  !   auteur   !       but                          !     *
 *     ------------------------------------------------------------     *
 *                                                                $     *
 ************************************************************************/
#ifndef LESCHARGEEXTSURELEMENT_H
#define LESCHARGEEXTSURELEMENT_H


# include <iostream>
using namespace std;  //introduces namespace std
#include <stdlib.h>
#include "Tableau_T.h"
#include "ParaGlob.h"
#include "Coordonnee.h"

/// @addtogroup Groupe_concernant_le_chargement
///  @{
///

       class Pression_appliquee
         { public: double press;Coordonnee P;
           Pression_appliquee(): press(0),P(ParaGlob::Dimension()) {};
           Pression_appliquee(const Pression_appliquee & a):
             press(a.press),P(a.P) {};
           Pression_appliquee& operator= (const Pression_appliquee& a)
            {press=a.press;P=a.P;return (*this);};
           void Zero() {press=0.;P.Zero();};
           // surcharge de l'operator de lecture
           friend  istream & operator >> (istream & ent, Pression_appliquee & a)
            { string nom; ent >> nom >> a.press >> nom >> a.P; return ent;
            };
           // surcharge de l'operator d'ecriture
           friend  ostream & operator << (ostream & sort , const Pression_appliquee & a)
           { sort << " Press " << a.press << " "<< " P " << a.P << " "; return sort;};
          };
/// @}  // end of group


       /// @addtogroup Groupe_concernant_le_chargement
       ///  @{
       ///

       class Force_hydroDyna
         { public: Coordonnee F_n,F_t,T;//trainée, portance, visqueux
           Force_hydroDyna(): F_n(ParaGlob::Dimension()),F_t(ParaGlob::Dimension()),T(ParaGlob::Dimension()) {};
           Force_hydroDyna(const Force_hydroDyna & a):
             F_n(a.F_n),F_t(a.F_t),T(a.T) {};
           Force_hydroDyna& operator= (const Force_hydroDyna& a)
            {F_n=a.F_n;F_t=a.F_t;T=a.T;return (*this);};
           void Zero() {F_n.Zero();F_t.Zero();T.Zero();};
           // surcharge de l'operator de lecture
           friend  istream & operator >> (istream & ent, Force_hydroDyna & a)
            { string nom; ent >> nom >> a.F_n >> nom >> a.F_t >> nom >> a.T ; return ent;
              // on ne fait pas a.F_n=a.F_t; ceci pour garder une valeur à t différentes éventuellement
            };
           // surcharge de l'operator d'ecriture
           friend  ostream & operator << (ostream & sort , const Force_hydroDyna & a)
           { sort << " F_n " << a.F_n << " F_t "<< a.F_t << " T "<< a.T << " "; return sort;};
          };
/// @}  // end of group


/// @addtogroup Groupe_concernant_le_chargement
///  @{
///


class  LesChargeExtSurElement

{   // surcharge de l'operator de lecture
    friend istream & operator >> (istream &, LesChargeExtSurElement &);
    // surcharge de l'operator d'ecriture
    friend ostream & operator << (ostream &, const LesChargeExtSurElement &);

  public :
  // CONSTRUCTEURS :
    // contructeur par défaut
    LesChargeExtSurElement();
    // contructeur fonction du nombre de points d'intégration et de la dimension de tenseurs
    LesChargeExtSurElement(int nbpti, int dimtens);
    // contructeur de copie
    LesChargeExtSurElement(const LesChargeExtSurElement& lespti);
    
    // DESTRUCTEUR :
    ~LesChargeExtSurElement();
    
  // METHODES PUBLIQUES :
	   // Surcharge de l'operateur = 
    LesChargeExtSurElement& operator= ( const LesChargeExtSurElement& lespti);
 
    // initialisation à 0 de tous les conteneurs existants
    void Zero();
 
    // fonction d'accès
    // les pressions éventuellement exercées sur les faces de l'élément
    // lesPressionsExternes(i)(j) : pression au points d'intégration de surface j, pour la face i
    Tableau <Tableau <Pression_appliquee> >* LesPressionsExternes() {return lesPressionsExternes;};
    void LesPressionsExternes_Change_taille(int n);
    // les forces volumiques qui s'exercent éventuellement sur l'élément
    // force_volume(i) = la force de volume au pti I
    Tableau < Coordonnee >* Force_volume() {return force_volume;};
    void Force_volume_Change_taille(int n);
    // les densité d’effort dont la direction reste fixe éventuellement exercées sur les faces de l'élément
    // lesEffortsDirFixe(i)(j) : effort au points d'intégration de surface j, pour la face i
    Tableau <Tableau <Coordonnee> >* LesEffortsDirFixe() {return lesEffortsDirFixe;};
    void LesEffortsDirFixe_Change_taille(int n);
    // les densités éventuelles d’effort de surface dont la direction suit la face face de l'élément
    // lesPressDir(i)(j) : effort au points d'intégration de surface j, pour la face i
    Tableau <Tableau <Coordonnee> >* LesPressDir(){return lesPressDir;};
    void LesPressDir_Change_taille(int n);
    // les densités éventuelles d’effort de surface d'origine hydrodynamique
    // lesHydroDyna(i)(j) : effort au points d'intégration de surface j, pour la face i
    Tableau <Tableau <Force_hydroDyna> >* LesHydroDyna(){return lesHydroDyna;};
    void LesHydroDyna_Change_taille(int n);
    // charge linéique
    // lesLineique(i)(j) : effort au points d'intégration de surface j, pour la face i
    Tableau <Tableau <Coordonnee> >* LesLineique(){return lesLineique;};
    void LesLineique_Change_taille(int n);
    // charge linéique suiveuse
    // lesLineiqueSuiveuse(i)(j) : effort au points d'intégration de surface j, pour la face i
    Tableau <Tableau <Coordonnee> >* LesLineiqueSuiveuse(){return lesLineiqueSuiveuse;};
    void LesLineiqueSuiveuse_Change_taille(int 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)
	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);
    
  protected:
    // données protégées
       // les deux premières sont historiques et l'enregistrement est sans doute sur-abondant
       // pour l'instant on laisse tel quel, ensuite on pourra faire : Force_de_volume -> Coordonnée idem pour pression appliquée

       // les pressions éventuellement exercées sur les faces de l'élément
       // lesPressionsExternes(i)(j) : pression au points d'intégration de surface j, pour la face i
       Tableau <Tableau <Pression_appliquee> >* lesPressionsExternes;
       // les forces volumiques qui s'exercent éventuellement sur l'élément
       // force_volume(i) = la force de volume au pti I
       Tableau < Coordonnee >* force_volume;
       // les densité d’effort dont la direction reste fixe éventuellement exercées sur les faces de l'élément
       // lesEffortsDirFixe(i)(j) : effort au points d'intégration de surface j, pour la face i
       Tableau <Tableau <Coordonnee> >* lesEffortsDirFixe;
       // les densités éventuelles d’effort de surface dont la direction suit la face face de l'élément
       // lesPressDir(i)(j) : effort au points d'intégration de surface j, pour la face i
       Tableau <Tableau <Coordonnee> >* lesPressDir;
       // les densités éventuelles d’effort de surface d'origine hydrodynamique
       // lesHydroDyna(i)(j) : effort au points d'intégration de surface j, pour la face i
       Tableau <Tableau <Force_hydroDyna> >* lesHydroDyna;
       // charge linéique
       // lesLineique(i)(j) : effort au points d'intégration de surface j, pour la face i
       Tableau <Tableau <Coordonnee> >* lesLineique;
       // charge linéique suiveuse
       // lesLineiqueSuiveuse(i)(j) : effort au points d'intégration de surface j, pour la face i
       Tableau <Tableau <Coordonnee> >* lesLineiqueSuiveuse;

 };
 /// @}  // end of group

#endif