// FICHIER : MooneyRivlin1D.cc
// CLASSE : MooneyRivlin1D


// 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 <iostream>
using namespace std;  //introduces namespace std
#include <math.h>
#include <stdlib.h>
#include "Sortie.h"
#include "TypeConsTens.h"
#include "CharUtil.h"


#include "MooneyRivlin1D.h"
#include "MathUtil.h"

MooneyRivlin1D::MooneyRivlin1D () :  // Constructeur par defaut
  Loi_comp_abstraite(MOONEY_RIVLIN_1D,CAT_MECANIQUE,1),C10(0.),C01(0.)
  ,C10_temperature(NULL),C01_temperature(NULL)
   { };
	

// Constructeur de copie
MooneyRivlin1D::MooneyRivlin1D (const MooneyRivlin1D& loi) :
	Loi_comp_abstraite(loi)
   ,C10(loi.C10),C01(loi.C01)
   ,C10_temperature(loi.C10_temperature),C01_temperature(loi.C01_temperature)
	 {// on regarde s'il s'agit d'une courbe locale ou d'une courbe globale
	  if (C10_temperature->NomCourbe() == "_") C10_temperature = Courbe1D::New_Courbe1D(*(loi.C10_temperature));
      if (C01_temperature->NomCourbe() == "_") C01_temperature = Courbe1D::New_Courbe1D(*(loi.C01_temperature));;
	  };

MooneyRivlin1D::~MooneyRivlin1D ()
// Destructeur 
{ if (C10_temperature != NULL)
      if (C10_temperature->NomCourbe() == "_") delete C10_temperature;
  if (C01_temperature != NULL)
      if (C01_temperature->NomCourbe() == "_") delete C01_temperature;
  };

// Lecture des donnees de la classe sur fichier
void MooneyRivlin1D::LectureDonneesParticulieres 
                (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D
                                             ,LesFonctions_nD& lesFonctionsnD)
  { string toto,nom; 
    // ---- lecture du coefficient C01 -----
    *(entreePrinc->entree) >> nom;   
    if(nom != "C01=")
         { cout << "\n erreur en lecture du parametre C01, on attendait la chaine C01= et on a lu: " << nom;
           cout << "\n MooneyRivlin1D::LectureDonneesParticulieres  "
                << "(UtilLecture * entreePrinc) " << endl ;
           entreePrinc->MessageBuffer("**erreur1 MooneyRivlin::LectureDonneesParticulieres (...**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);          
          };
    // on regarde si le coefficient  est thermo dépendante
    if(strstr(entreePrinc->tablcar,"C01_thermo_dependant_")!=0)
     { thermo_dependant=true;
       *(entreePrinc->entree) >> nom;
       if (nom != "C01_thermo_dependant_") 
         { cout << "\n erreur en lecture de la thermodependance de C01, on aurait du lire le mot cle C01_thermo_dependant_"
                << " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
           entreePrinc->MessageBuffer("**erreur2 MooneyRivlin::LectureDonneesParticulieres (...**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          }
       // lecture de la loi d'évolution en fonction de la température
       *(entreePrinc->entree) >>  nom;    
       // on regarde si la courbe existe, si oui on récupère la référence 
       if (lesCourbes1D.Existe(nom)) 
         { C01_temperature = lesCourbes1D.Trouve(nom);
          }
       else
        { // sinon il faut la lire maintenant
          string non_courbe("_");   
          C01_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
          // lecture de la courbe
          C01_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
         } 
       // prepa du flot de lecture
       entreePrinc->NouvelleDonnee(); 
      }
    else
     { // lecture de C01 
       *(entreePrinc->entree) >> C01 ;
      };
    // ---- puis lecture du coefficient C10 ----
    *(entreePrinc->entree) >> nom;   
    if(nom != "C10=")
         { cout << "\n erreur en lecture du parametre C10, on attendait la chaine C10= et on a lu: " << nom;
           cout << "\n MooneyRivlin1D::LectureDonneesParticulieres  "
                << "(UtilLecture * entreePrinc) " << endl ;
           entreePrinc->MessageBuffer("**erreur3 MooneyRivlin::LectureDonneesParticulieres (...**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);          
          };
    // on regarde si le coefficient  est thermo dépendante
    if(strstr(entreePrinc->tablcar,"C10_thermo_dependant_")!=0)
     { thermo_dependant=true;
       *(entreePrinc->entree) >> nom;
       if (nom != "C10_thermo_dependant_") 
         { cout << "\n erreur en lecture de la thermodependance de C10, on aurait du lire le mot cle C10_thermo_dependant_"
                << " suivi du nom d'une courbe de charge ou de la courbe elle meme ";
           entreePrinc->MessageBuffer("**erreur4 MooneyRivlin::LectureDonneesParticulieres (...**");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);     
          }
       // lecture de la loi d'évolution en fonction de la température
       *(entreePrinc->entree) >>  nom;    
       // on regarde si la courbe existe, si oui on récupère la référence 
       if (lesCourbes1D.Existe(nom)) 
         { C10_temperature = lesCourbes1D.Trouve(nom);
          }
       else
        { // sinon il faut la lire maintenant
          string non_courbe("_");   
          C10_temperature = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
          // lecture de la courbe
          C10_temperature->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
         } 
       // prepa du flot de lecture
       entreePrinc->NouvelleDonnee(); 
      }
    else
     { // lecture de C10 
       *(entreePrinc->entree) >> C10 ;
      };
   
    // ---- appel au niveau de la classe mère ----
    Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
                 (*entreePrinc,lesFonctionsnD);

   };
// affichage de la loi
void MooneyRivlin1D::Affiche()  const 
  { cout << " \n loi de comportement hyper elastique 1D de type mooney rivlin \n";
    if ( C01_temperature != NULL) { cout << " C01 thermo dependant " 
                                        << " courbe C01=f(T): " << C01_temperature->NomCourbe() <<" ";}
    else                          { cout << " C01= " << C01 ;} 
    if ( C10_temperature != NULL) { cout << " C10 thermo dependant " 
                                        << " courbe C10=f(T): " << C10_temperature->NomCourbe() <<" ";}
    else                          { cout << " C10= " << C10 << " ";} 
    // appel de la classe mère
    Loi_comp_abstraite::Affiche_don_classe_abstraite();
  };
            
// affichage et definition interactive des commandes particulières à chaques lois
void MooneyRivlin1D::Info_commande_LoisDeComp(UtilLecture& entreePrinc)
 {  ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
	   cout << "\n definition standart (rep o) ou exemples exhaustifs (rep n'importe quoi) ? ";
	   string rep = "_";
    // procédure de lecture avec prise en charge d'un retour chariot
    rep = lect_return_defaut(true,"o");

    sort << "\n# ----------------------------------------------------------------------------------"
         << "\n# |......  loi de comportement hyper elastique 1D de type mooney rivlin .......    |"
         << "\n# |                   .. deux coefficients C01 et C10  ..                          |"
         << "\n# ----------------------------------------------------------------------------------"
         << "\n\n#           exemple de definition de loi"
         << "\n   C01= 0.0167    C10= 0.145 "
         << "\n#   .. fin de la definition de la loi money rivlin \n" << endl;
	   if ((rep != "o") && (rep != "O" ) && (rep != "0") )
      { sort << "\n#-----------------------------------"
         << "\n#  il est possible de definir des parametres thermo-dependants (1 ou 2 parametres)"
         << "\n#  par exemple pour les deux parametres on ecrit: "
         << "\n#-----------------------------------"
         << "\n#  C01= C01_thermo_dependant_ courbe1 "
         << "\n#  C10= C10_thermo_dependant_  courbe4 "
         << "\n#-----------------------------------"
         << "\n#  noter qu'apres la definition de chaque courbe, on change de ligne, d'une maniere inverse "
         << "\n#  si la valeur du parametre est fixe, on poursuit sur la meme ligne. "
         << "\n#  par exemple supposons C01 fixe, C10, on ecrit: "
         << "\n#-----------------------------------"
         << "\n#  C01= 2.   C10= C10_thermo_dependant_ courbe4 "
         << "\n#-----------------------------------"
         << endl;
       };
    // appel de la classe mère
    Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc);     
  };  		  	  

// test si la loi est complete
int MooneyRivlin1D::TestComplet()
    { int ret = LoiAbstraiteGeneral::TestComplet();

      if ((C01_temperature == NULL) && (C01 == 0.))
       { cout << " \n le coefficient C01 n'est pas defini pour la loi " 
              << Nom_comp(id_comp)
              << '\n' << endl;
         ret = 0;
       };                
      if ((C10_temperature == NULL) && (C10 == 0.))
       { cout << " \n le coefficient C10 n'est pas defini pour la loi " 
              << Nom_comp(id_comp)
              << '\n' << endl;
         ret = 0;
       };                

       return ret; 
    }; 

	   //----- lecture écriture de restart -----
	   // 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 MooneyRivlin1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
                                             ,LesFonctions_nD& lesFonctionsnD)
  { string nom;bool test; 
	if (cas == 1) 
	 { // les coefficients
	 
	   // C01
	   ent >> nom >> test;
       // vérification
       #ifdef MISE_AU_POINT
         if (nom != "CO1") 
           { cout << "\n erreur en lecture du parametres C01 de la loi de mooney rivlin 1D"
                  << " on devait lire C01= avant le premier parametre "
                  << " et on a lue: " << nom << " "  
                  << "\n MooneyRivlin1D::Lecture_base_info_loi(..."  
                  << endl;
             Sortie(1);                  
            }
       #endif
	   if (!test)
	     { ent >> C01;
	       if (C01_temperature != NULL) {if (C01_temperature->NomCourbe() == "_") 
	          delete C01_temperature; C01_temperature = NULL;};
	      }
	    else
	     { ent >> nom; C01_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,C01_temperature); };
	   // C10
	   ent >> nom >> test;
       // vérification
       #ifdef MISE_AU_POINT
         if (nom != "C10") 
           { cout << "\n erreur en lecture du parametres C10 de la loi de mooney rivlin 1D"
                  << " on devait lire C10= avant le second parametre "
                  << " et on a lue: " << nom << " "  
                  << "\n MooneyRivlin1D::Lecture_base_info_loi(..."  
                  << endl;
             Sortie(1);                  
            }
       #endif
	   if (!test)
	     { ent >> C10;
	       if (C10_temperature != NULL) {if (C10_temperature->NomCourbe() == "_") 
	          delete C10_temperature; C10_temperature = NULL;};
	      }
	    else
	     { ent >> nom; C10_temperature = lesCourbes1D.Lecture_pour_base_info(ent,cas,C10_temperature); };
	  }
	 // appel de la classe mère
	 Loi_comp_abstraite::Lecture_don_base_info(ent,cas,lesRef,lesCourbes1D,lesFonctionsnD);
   };
       // cas donne le niveau de sauvegarde
       // = 1 : on sauvegarde tout
       // = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void MooneyRivlin1D::Ecriture_base_info_loi(ofstream& sort,const int cas)
  { if (cas == 1) 
     { // les coefficients
	   sort << "\n  C01= ";             
       if (C01_temperature == NULL)
         { sort << false << " " << C01 << " ";}
       else 
         { sort << true << " fonction_C01_temperature ";
           LesCourbes1D::Ecriture_pour_base_info(sort,cas,C01_temperature);
          };     
	   sort << "  C10= ";             
       if (C10_temperature == NULL)
         { sort << false << " " << C10 << " ";}
       else 
         { sort << true << " fonction_C10_temperature ";
           LesCourbes1D::Ecriture_pour_base_info(sort,cas,C10_temperature);
          };
      }
	// appel de la classe mère
    Loi_comp_abstraite::Ecriture_don_base_info(sort,cas);  
   }; 
     

 // ========== codage des METHODES VIRTUELLES  protegees:================
        // calcul des contraintes a t+dt
void MooneyRivlin1D::Calcul_SigmaHH (TenseurHH& ,TenseurBB& ,DdlElement & tab_ddl,
             TenseurBB & ,TenseurHH & ,BaseB& ,BaseH& ,TenseurBB&  epsBB_,
             TenseurBB& , TenseurBB&  ,
		  	 TenseurHH & gijHH_,Tableau <TenseurBB *>& d_gijBB_,double& ,double& ,TenseurHH & sigHH_
		  	,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double&  module_cisaillement
		  	,const Met_abstraite::Expli_t_tdt&  )
 {   
   #ifdef MISE_AU_POINT	 	 
	 if (epsBB_.Dimension() != 1)
	    { cout << "\nErreur : la dimension devrait etre 1 !\n";
		  cout << " MooneyRivlin1D::Calcul_SigmaHH\n";
		  Sortie(1);
		};
	 if (tab_ddl.NbDdl() != d_gijBB_.Taille())
	    { cout << "\nErreur : le nb de ddl est != de la taille de d_gijBB_  !\n";
		  cout << " MooneyRivlin1D::Calcul_SigmaHH\n";
		  Sortie(1);
		};
		
    #endif
    const Tenseur1BB & epsBB = *((Tenseur1BB*) &epsBB_); // passage en dim 1
    const Tenseur1HH & gijHH = *((Tenseur1HH*) &gijHH_); //   "      "  "  "
    Tenseur1HH & sigHH = *((Tenseur1HH*) &sigHH_);  //   "      "  "  "

    Tenseur1BH  epsBH =  epsBB * gijHH;
    Tenseur1BH  sigBH;
    
    // cas de la thermo dépendance, on calcul les grandeurs
    if (C01_temperature != NULL) C01 = C01_temperature->Valeur(*temperature);
    if (C10_temperature != NULL) C10 = C10_temperature->Valeur(*temperature);

    double unMoins2eps = 1. - 2.*epsBH(1,1);
    double racine_unMoins2eps = sqrt(unMoins2eps);
    sigBH.Coor(1,1)  =  2. * C10 * (1./unMoins2eps - racine_unMoins2eps)
                   + 2. * C01 * (1./racine_unMoins2eps-unMoins2eps);
    // la contrainte en deux fois contravariante   
    sigHH = gijHH * sigBH;   
 };
        
        // calcul des contraintes a t+dt et de ses variations  
void MooneyRivlin1D::Calcul_DsigmaHH_tdt (TenseurHH& ,TenseurBB& ,DdlElement & tab_ddl
            ,BaseB& ,TenseurBB & ,TenseurHH & ,
            BaseB& ,Tableau <BaseB> & ,BaseH& ,Tableau <BaseH> & ,
            TenseurBB & epsBB_tdt,Tableau <TenseurBB *>& d_epsBB,TenseurBB & ,
		    TenseurBB & ,TenseurHH & gijHH_tdt,
		    Tableau <TenseurBB *>& d_gijBB_tdt,
		  	Tableau <TenseurHH *>& d_gijHH_tdt,double& , double& ,
		  	Vecteur& ,TenseurHH& sigHH_tdt,Tableau <TenseurHH *>& d_sigHH
		  	,EnergieMeca & energ,const EnergieMeca & energ_t,double& module_compressibilite,double&  module_cisaillement
		  	,const Met_abstraite::Impli& )
 {
   #ifdef MISE_AU_POINT	 	 
    if (epsBB_tdt.Dimension() != 1)
       { cout << "\nErreur : la dimension devrait etre 1 !\n";
      cout << " MooneyRivlin1D::Calcul_DsigmaHH_tdt\n";
      Sortie(1);
    };
    if (tab_ddl.NbDdl() != d_gijBB_tdt.Taille())
       { cout << "\nErreur : le nb de ddl est != de la taille de d_gijBB_tdt  !\n";
      cout << " MooneyRivlin1D::Calcul_SDsigmaHH_tdt\n";
      Sortie(1);
    };
   #endif
    const Tenseur1BB & epsBB = *((Tenseur1BB*) &epsBB_tdt); // passage en dim 1
    const Tenseur1HH & gijHH = *((Tenseur1HH*) &gijHH_tdt); //   "      "  "  "
    Tenseur1HH & sigHH = *((Tenseur1HH*) &sigHH_tdt);  //   "      "  "  "
    
    // cas de la thermo dépendance, on calcul les grandeurs
    if (C01_temperature != NULL) C01 = C01_temperature->Valeur(*temperature);
    if (C10_temperature != NULL) C10 = C10_temperature->Valeur(*temperature);

    Tenseur1BH  epsBH =  epsBB * gijHH;
    Tenseur1BH  sigBH;
    double unMoins2eps = 1. - 2.*epsBH(1,1);
    double unSurUnMoins2eps = 1./unMoins2eps;
    double racine_unMoins2eps = sqrt(unMoins2eps);
    double unSurRacine_unMoins2eps = 1./racine_unMoins2eps;
    sigBH.Coor(1,1)  =  2. * C10 * (unSurUnMoins2eps - racine_unMoins2eps)
                   + 2. * C01 * (unSurRacine_unMoins2eps-unMoins2eps);
    // la contrainte en deux fois contravariante   
    sigHH = gijHH * sigBH;   

    int nbddl = d_gijBB_tdt.Taille();
    double coef = 2. * C10 * (2.* unSurUnMoins2eps * unSurUnMoins2eps + unSurRacine_unMoins2eps)
                  + 2. * C01 * (unSurUnMoins2eps * unSurRacine_unMoins2eps + 2.);
    for (int i = 1; i<= nbddl; i++)
     { // on fait de faire uniquement une égalité d'adresse et de ne pas utiliser
       // le constructeur d'ou la profusion d'* et de ()
       Tenseur1HH & dsigHH = *((Tenseur1HH*) (d_sigHH(i)));  // passage en dim 1
       const Tenseur1BB & dgijBB =  *((Tenseur1BB*)(d_gijBB_tdt(i)));  // passage en dim 1
       const Tenseur1HH & dgijHH = *((Tenseur1HH*)(d_gijHH_tdt(i))) ; // pour simplifier l'ecriture
       const Tenseur1BB & depsBB = *((Tenseur1BB *) (d_epsBB(i))); //    "
       Tenseur1BH  depsBH =  depsBB * gijHH_tdt + epsBB_tdt * dgijHH;
       dsigHH = dgijHH * sigBH
               + (gijHH * depsBH) * coef;
     };
     
 };