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

//#include "Debug.h"
# include "DeformationSfe1.h"
#include "ParaGlob.h"

// ----------------------------------------------------------------------------------------------
//     conteneurs pour le stockage de variables spécifiques à un point de calcul
//      cas des éléments SFe1		 
// ----------------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------------
// //   implantation concernant la  classe conteneur spécifique à chaque point ou la déformation 
// //   est calculée

	// constructeur par défaut -> à ne pas utiliser -> message d'erreur
DeformationSfe1::SaveDefResulSfe1::SaveDefResulSfe1()
  { cout << "\n **** erreur d'utilisation de constructeur "
         << "\n DeformationSfe1::SaveDefResulSfe1::SaveDefResulSfe1()";
    Sortie(1);     
   };

    // le constructeur recevable
DeformationSfe1::SaveDefResulSfe1::SaveDefResulSfe1(const Met_abstraite& meta):
    Deformation::SaveDefResul(meta)
    ,meti_a_00(meta.Dim_vec_base(),meta.Nbvec_des_bases())
    ,meti_a_t(meta.Dim_vec_base(),meta.Nbvec_des_bases())
    ,meti_a_tdt(meta.Dim_vec_base(),meta.Nbvec_des_bases())
       {enu_type=SAVEDEFRESUL_SFE1;};
   // le constructeur de copie    
DeformationSfe1::SaveDefResulSfe1::SaveDefResulSfe1(const SaveDefResulSfe1& a):
   Deformation::SaveDefResul(a)
   ,meti_a_00(a.meti_a_00),meti_a_t(a.meti_a_t),meti_a_tdt(a.meti_a_tdt)
       {};    
   // destructeur
DeformationSfe1::SaveDefResulSfe1::~SaveDefResulSfe1() {}; 
   // surcharge de l'opérateur d'affectation
Deformation::SaveDefResul& DeformationSfe1::SaveDefResulSfe1::operator= 
                                       (const Deformation::SaveDefResul& aa)
  {// on vérifie le type exacte
   #ifdef MISE_AU_POINT
   if (aa.Type_stocke() != enu_type)
	   {cout << "\nErreur en affectation etre un stockage " 
	         << Nom_type_stockage_def(enu_type) << " et " << Nom_type_stockage_def(aa.Type_stocke()); 
		cout << "\n  DeformationSfe1::SaveDefResulSfe1::operator=  " << endl;
		Sortie(1);
	   };
   #endif
   // les variables de la classe mère
   this->Deformation::SaveDefResul::operator= (aa);
   // puis les variables propres
   DeformationSfe1::SaveDefResulSfe1& a = *((DeformationSfe1::SaveDefResulSfe1*) &aa);
   meti_a_00 = a.meti_a_00; meti_a_t = a.meti_a_t; meti_a_tdt = a.meti_a_tdt; 
   return *this;
   };
     
   // affichage des infos
void DeformationSfe1::SaveDefResulSfe1::Affiche()
  {// les variables de la classe mère
   this->Deformation::SaveDefResul::Affiche();
   // puis les variables propres
   cout << "\n meti_a_00: " ; meti_a_00.Affiche(); cout << " meti_a_t: "; meti_a_t.Affiche();
   cout << " meti_a_tdt ";meti_a_tdt.Affiche(); cout <<" ";
 };
   	
   // idem sur un ofstream
void DeformationSfe1::SaveDefResulSfe1::Affiche(ofstream& sort)			        
  {// les variables de la classe mère
   this->Deformation::SaveDefResul::Affiche(sort);
   // puis les variables propres
   sort << "\n meti_a_00: " << meti_a_00 << " meti_a_t " << meti_a_t 
        << " meti_a_tdt " << meti_a_tdt <<" ";
   };	

  //============= 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 DeformationSfe1::SaveDefResulSfe1::Lecture_base_info (ifstream& ent,const int cas)
   {// lecture de l'entête
    string nom; 
    // lecture des données
    // les variables de la classe mère
    this->Deformation::SaveDefResul::Lecture_base_info(ent,cas);
    // puis les variables propres
    switch (cas)
     { case 1 :
         ent >> nom;
         if (nom != "SaveDefResulSfe1:")
         { cout << "\n erreur de lecture d'entete de SaveDefResulSfe1, nom lue: " << nom
              << "\n DeformationSfe1::SaveDefResulSfe1::Lecture_base_info (...";
         Sortie(1);
         }
         ent >> nom >>  meti_a_00 >> nom >> meti_a_t ; break;
       case 2 :
// -- on test --       
//         ent >> nom;
//         if (nom != "SaveDefResulSfe1:")
//         { cout << "\n erreur de lecture d'entete de SaveDefResulSfe1, nom lue: " << nom
//              << "\n DeformationSfe1::SaveDefResulSfe1::Lecture_base_info (...";
//         Sortie(1);
//         }
//         ent >> nom >>  meti_a_t ; 
         break;
         
       default:
          cout << "\n cas non considere !!: cas= " << cas 
               << "\n   DeformationSfe1::SaveDefResulSfe1::Lecture_base_info (...";
          Sortie(1);
     };
   };
            // cas donne le niveau de sauvegarde
            // = 1 : on sauvegarde tout
            // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void DeformationSfe1::SaveDefResulSfe1::Ecriture_base_info(ofstream& sort,const int cas)
  {// on ne sauvegarde que ce qui est à 0 et à t, ce qui est à tdt est considéré une zone de travail
   // les variables de la classe mère
   this->Deformation::SaveDefResul::Ecriture_base_info(sort,cas);
   // puis les variables propres
    switch (cas)
     { case 1 :
         sort << " SaveDefResulSfe1: ";
         sort << " meti_a_00: " << meti_a_00 << " meti_a_t: " << meti_a_t << " ";
         break;
       case 2 :
// -- on test --       
//         sort << " SaveDefResulSfe1: ";
//         sort << " meti_a_t: " << meti_a_t << " ";
         break;
       default:
          cout << "\n cas non considere !!: cas= " << cas 
               << "\n   DeformationSfe1::SaveDefResulSfe1::Ecriture_base_info(...";
          Sortie(1);
     };
  };

// mise à jour des grandeurs meti_a_00
// *** non car dans le cas d'un restart ce n'est pas vrai !!!! //et init par recopie des grandeurs sur t
void DeformationSfe1::SaveDefResulSfe1::MiseAJourGrandeurs_a_0(const Met_abstraite * metrique)
  {   // tout d'abord les variables de la classe mère
      // là on sauvegarde les grandeurs au point courant (et non la facette), et qui sont sauvegardées
      // dans le SaveDefResul initiale et non le spécifique sfe1
      this->Deformation::SaveDefResul::MiseAJourGrandeurs_a_0(metrique);
      // puis les variables propres à la facette
	     // on récupère des infos dans un conteneur qui normalement dans le cas de la déformation
	     // est correctement alimenté pour les grandeurs qui nous intéressent
      //      // récup du conteneur Expli_t_tdtFac c'est-à-dire des infos de la FACETTE !!!
      Met_Sfe1* metSfe = (Met_Sfe1*) metrique;
      const Met_abstraite::Expli_t_tdt& ex = metSfe->Conteneur_Expli_tdtFac();
      // mise à jour des grandeurs à 0 
      *(meti_a_00.giB_) = *(ex.giB_0);*(meti_a_00.giH_) = *(ex.giH_0); 
      *(meti_a_00.gijBB_) = *(ex.gijBB_0);*(meti_a_00.gijHH_) = *(ex.gijHH_0);
      *(meti_a_00.jacobien_) = *(ex.jacobien_0);
	 };
// mise à jour des grandeurs meti_a_tdt
void DeformationSfe1::SaveDefResulSfe1::MiseAJourGrandeurs_a_tdt(const Met_abstraite * metrique,const TenseurBB& Deps_BB)
  { // tout d'abord les variables de la classe mère
    // là on sauvegarde les grandeurs au point courant (et non la facette), et qui sont sauvegardées
    // dans le SaveDefResul initiale et non le spécifique sfe1
    this->Deformation::SaveDefResul::MiseAJourGrandeurs_a_tdt(metrique,Deps_BB);
    // puis les variables propres
    // on récupère des infos dans un conteneur qui normalement dans le cas de la déformation
    // est correctement alimenté pour les grandeurs qui nous intéressent
    // récup du conteneur Expli_t_tdtFac c'est-à-dire des infos de la FACETTE !!!
    Met_Sfe1* metSfe = (Met_Sfe1*) metrique;

    const Met_abstraite::Expli_t_tdt& ex = metSfe->Conteneur_Expli_tdtFac();
    // mise à jour des grandeurs à tdt
    *(meti_a_tdt.giB_) = *(ex.giB_tdt);*(meti_a_tdt.giH_) = *(ex.giH_tdt);
    *(meti_a_tdt.gijBB_) = *(ex.gijBB_tdt);*(meti_a_tdt.gijHH_) = *(ex.gijHH_tdt);
    if (ex.gradVmoyBB_tdt != NULL) *(meti_a_tdt.gradVmoyBB_) = *(ex.gradVmoyBB_tdt);
    if (ex.gradVBB_tdt != NULL) *(meti_a_tdt.gradVBB_) = *(ex.gradVBB_tdt);
      *(meti_a_tdt.jacobien_) = *(ex.jacobien_tdt);
	 };