// FICHIER : Iso_elas_SE1D.cp
// CLASSE : Iso_elas_SE1D


// 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-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 <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 "Iso_elas_SE1D.h"
#include "MathUtil.h"

Iso_elas_SE1D::Iso_elas_SE1D () :  // Constructeur par defaut
  Loi_comp_abstraite(ISO_ELAS_SE1D,CAT_MECANIQUE,1),f_coefficient(NULL),symetrique(true)
  ,nu(0.)
   { };
	

// Constructeur de copie
Iso_elas_SE1D::Iso_elas_SE1D (const Iso_elas_SE1D& loi) :
	Loi_comp_abstraite(loi)
   ,f_coefficient(loi.f_coefficient),symetrique(loi.symetrique)
   ,nu(loi.nu)
	{if (f_coefficient != NULL)
	   if (f_coefficient->NomCourbe() == "_")
        {// comme il s'agit d'une courbe locale on la redéfinie (sinon pb lors du destructeur de loi)
         string non_courbe("_");   
         f_coefficient = Courbe1D::New_Courbe1D(*loi.f_coefficient);
        };
	};

Iso_elas_SE1D::~Iso_elas_SE1D ()
// Destructeur 
{ if (f_coefficient != NULL)
    if (f_coefficient->NomCourbe() == "_") delete f_coefficient;
};

// Lecture des donnees de la classe sur fichier
void Iso_elas_SE1D::LectureDonneesParticulieres 
                (UtilLecture * entreePrinc,LesCourbes1D& lesCourbes1D,LesFonctions_nD& lesFonctionsnD)
  { // on regarde tout d'abord si le comportement est symétrique
    string toto,nom;      
    if(strstr(entreePrinc->tablcar,"non_symetrique")!= NULL)
     { *(entreePrinc->entree) >> toto; symetrique = false;} else { symetrique = true; };
    // lecture de la courbe de coefficient multiplicatif
    if(strstr(entreePrinc->tablcar,"f_coefficient")== NULL)
         { cout << "\n erreur en lecture de la courbe de coefficient multiplicatif "
                << " on attendait la chaine : f_coefficient";
           cout << "\n Iso_elas_SE1D::LectureDonneesParticulieres  "
                << "(UtilLecture * entreePrinc) " << endl ;
           entreePrinc->MessageBuffer("   ");
           throw (UtilLecture::ErrNouvelleDonnee(-1));
           Sortie(1);          
          }
    *(entreePrinc->entree) >> toto >> nom; 
    // on regarde si la courbe existe, si oui on récupère la référence 
    if (lesCourbes1D.Existe(nom)) 
      { f_coefficient = lesCourbes1D.Trouve(nom);
        }
    else
     { // sinon il faut la lire maintenant   
       string non_courbe("_");   
       f_coefficient = Courbe1D::New_Courbe1D(non_courbe,Id_Nom_Courbe1D (nom.c_str()));
       // lecture de la courbe
       f_coefficient->LectDonnParticulieres_courbes (non_courbe,entreePrinc);
      } 
    // lecture d'un coefficient de Poisson éventuel
    if(strstr(entreePrinc->tablcar,"nu=")!= NULL)
     { *(entreePrinc->entree) >> toto >> nu; };

    // appel au niveau de la classe mère
    Loi_comp_abstraite::Lecture_type_deformation_et_niveau_commentaire
                 (*entreePrinc,lesFonctionsnD);

   };
// affichage de la loi
void Iso_elas_SE1D::Affiche()  const 
  { cout << " \n loi de comportement isoelastique non lineaire 1D de type contrainte = f(epsilon)" 
         << " \n fonction f() " ;
    f_coefficient->Affiche();
    cout << "\n nu= " <<  nu;
    // appel de la classe mère
    Loi_comp_abstraite::Affiche_don_classe_abstraite();
  };
            
// affichage et definition interactive des commandes particulières à chaques lois
void Iso_elas_SE1D::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 isoelastique non lineaire 1D de type sigma = f(epsilon).......|"
         << "\n# |            .. definition de la courbe f() ..                                             |"
         << "\n# --------------------------------------------------------------------------------------------"
         << "\n       f_coefficient   courbe1    # exemple d'une courbe deja existante symetrique par rapport a 0";
    if ((rep != "o") && (rep != "O" ) && (rep != "0") )
      { sort
         << "\n\n#  non_symetrique   f_coefficient   courbe1    # exemple d'une courbe deja existante "
         << " non symetrique par rapport a 0 (la courbe doit etre defini en negative et positive) "
         << "\n\n#           exemple d'une courbe defini a la suite "
         << "\n   non_symetrique  f_coefficient COURBEPOLYLINEAIRE_1_D"
         << "\n         Debut_des_coordonnees_des_points"
         << "\n                 Coordonnee dim= 2 -0.03 -350. " 
         << "\n                 Coordonnee dim= 2 -0.02 -300. " 
         << "\n                 Coordonnee dim= 2 -0.01 -200. "
         << "\n                 Coordonnee dim= 2  0.    0. "
         << "\n                 Coordonnee dim= 2  0.05  200. "
         << "\n                 Coordonnee dim= 2  0.1   300. " 
         << "\n                 Coordonnee dim= 2  0.15  350. " 
         << "\n         Fin_des_coordonnees_des_points  " 
         << "\n#   .. fin de la definition de la courbe sigma = f(epsilon)..  \n"
         << "\n "
         << "\n par defaut la loi ne prend pas en compte les deformations transversales cependant "
         << "\n il est possible d'indiquer un coeff de Poisson non nul, pour cela on indique apres la fonction "
         << "\n nu= une valeur "
         << "\n "
         << "\n " 
         ;
       };
    sort << endl;
    // appel de la classe mère
    Loi_comp_abstraite::Info_commande_don_LoisDeComp(entreePrinc);     
  };  		  	  

// test si la loi est complete
int Iso_elas_SE1D::TestComplet()
    { int ret = LoiAbstraiteGeneral::TestComplet();
      if ( f_coefficient == NULL)
       { cout << " \n la fonction f(epsilon) n'est pas défini pour  la loi " 
              << Nom_comp(id_comp)
              << '\n';
         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 Iso_elas_SE1D::Lecture_base_info_loi(ifstream& ent,const int cas,LesReferences& lesRef,LesCourbes1D& lesCourbes1D
                                             ,LesFonctions_nD& lesFonctionsnD)
  { string toto; 
    if (cas == 1)
     { // la symétrie
       ent >> toto >> symetrique;	 
       // la courbe f(epsilon)
       ent >> toto;
       if (toto != "fonction_epsilon")
        { cout << "\n erreur en lecture de la fonction epsilon, on attendait fonction_epsilon et on a lue " << toto
               << "\n Iso_elas_SE1D::Lecture_base_info_loi(...";
          Sortie(1);
         }; 
       f_coefficient = lesCourbes1D.Lecture_pour_base_info(ent,cas,f_coefficient);
       ent >> nu;
      }
     // 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 Iso_elas_SE1D::Ecriture_base_info_loi(ofstream& sort,const int cas)
  { if (cas == 1) 
     { // la courbe f(epsilon)
       sort << " \n symetrie " << symetrique << " fonction_epsilon ";
       LesCourbes1D::Ecriture_pour_base_info(sort,cas,f_coefficient);
       sort << "\n nu= "<<nu << " ";
      }
	// 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 Iso_elas_SE1D::Calcul_SigmaHH (TenseurHH& ,TenseurBB& ,DdlElement & tab_ddl,
             TenseurBB & ,TenseurHH & ,BaseB& ,BaseH& ,TenseurBB&  epsBB_,
             TenseurBB& delta_epsBB_ , 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& ex )
 {   
   #ifdef MISE_AU_POINT	 	 
	 if (epsBB_.Dimension() != 1)
	    { cout << "\nErreur : la dimension devrait etre 1 !\n";
		  cout << " Iso_elas_SE1D::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 << " Iso_elas_SE1D::Calcul_SigmaHH\n";
		  Sortie(1);
		};
		
    #endif
    const Tenseur1BB & epsBB = *((Tenseur1BB*) &epsBB_); // passage en dim 1
    const Tenseur1BB & delta_epsBB = *((Tenseur1BB*) &delta_epsBB_); // passage en dim 1
    const Tenseur1HH & gijHH = *((Tenseur1HH*) &gijHH_); //   "      "  "  "
    Tenseur1HH & sigHH = *((Tenseur1HH*) &sigHH_);  //   "      "  "  "

    Tenseur1BH  epsBH =  epsBB * gijHH;
    Tenseur1BH  sigBH; 
    if (symetrique)
      { sigBH.Coor(1,1)  = f_coefficient->Valeur(Dabs(epsBH(1,1))); }
    else 
      { sigBH.Coor(1,1)  = f_coefficient->Valeur(epsBH(1,1)); }
    // la contrainte en deux fois contravariante   
    sigHH = gijHH * sigBH;
  
        // -- calcul des modules
    // on passe par la définition d'un pseudo module d'Young régularisé éventuellement
    double E;
    if (symetrique)
      { if (Dabs(epsBH(1,1)) > ConstMath::petit)
          {E= sigBH(1,1)/Dabs(epsBH(1,1));}
        else // sinon on calcule pour une petite def arbitraire
          {E= f_coefficient->Valeur(ConstMath::pasmalpetit)/(ConstMath::pasmalpetit);
          };
      }
    else
      { if (Dabs(epsBH(1,1)) > ConstMath::petit)
          {E= sigBH(1,1)/(epsBH(1,1));}
        else //  sinon on calcule pour une petite def arbitraire
          { double x = DSigne(epsBH(1,1))*ConstMath::pasmalpetit;
            E= f_coefficient->Valeur(x)/(x);
          };
      };
    // puis les formules classiques
    module_compressibilite = E/(3.*(1.-2.*nu));
    module_cisaillement = 0.5 * E/(2.*(1+nu));
  
    // traitement des énergies
    EnergieMeca deltat_ener; // init à 0. des énergies
    deltat_ener.ChangeEnergieElastique(0.5 * (sigHH && delta_epsBB));
    // mise à jour des énergies
    energ = deltat_ener+energ_t;
    
    LibereTenseur(); 
 };
        
        // calcul des contraintes a t+dt et de ses variations  
void Iso_elas_SE1D::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 & delta_epsBB_,
		    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 << " Iso_elas_SE1D::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 << " Iso_elas_SE1D::Calcul_SDsigmaHH_tdt\n";
		  Sortie(1);
		};
    #endif
    const Tenseur1BB & epsBB = *((Tenseur1BB*) &epsBB_tdt); // passage en dim 1
    const Tenseur1BB & delta_epsBB = *((Tenseur1BB*) &delta_epsBB_); // passage en dim 1
    const Tenseur1HH & gijHH = *((Tenseur1HH*) &gijHH_tdt); //   "      "  "  "
    Tenseur1HH & sigHH = *((Tenseur1HH*) &sigHH_tdt);  //   "      "  "  "
    
    Tenseur1BH  epsBH =  epsBB * gijHH;
//    Tenseur1BH  sigBH  = f(epsBH);
    Courbe1D::ValDer valder_ver; // valeur et dérivée
    if (symetrique)
      { valder_ver = f_coefficient->Valeur_Et_derivee(Dabs(epsBH(1,1)));}
    else
      { valder_ver = f_coefficient->Valeur_Et_derivee(epsBH(1,1));}
       
    Tenseur1BH  sigBH; sigBH.Coor(1,1)  = valder_ver.valeur;
    sigHH = gijHH * sigBH;

    int nbddl = d_gijBB_tdt.Taille();
    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) * valder_ver.derivee;
      };
  
        // -- calcul des modules
    // on passe par la définition d'un pseudo module d'Young régularisé éventuellement
    double E;
    if (symetrique)
      { if (Dabs(epsBH(1,1)) > ConstMath::petit)
          {E= sigBH(1,1)/Dabs(epsBH(1,1));}
        else // sinon on calcule pour une petite def arbitraire
          {valder_ver = f_coefficient->Valeur_Et_derivee(ConstMath::pasmalpetit);
           E= valder_ver.valeur/(ConstMath::pasmalpetit);
          };
      }
    else
      { if (Dabs(epsBH(1,1)) > ConstMath::petit)
          {E= sigBH(1,1)/(epsBH(1,1));}
        else //  sinon on calcule pour une petite def arbitraire
          {double x = DSigne(epsBH(1,1))*ConstMath::pasmalpetit;
           valder_ver = f_coefficient->Valeur_Et_derivee(x);
           E= valder_ver.valeur/(x);
          };
      };
    // puis les formules classiques
    module_compressibilite = E/(3.*(1.-2.*nu));
    module_cisaillement = 0.5 * E/(2.*(1+nu));
  
    // traitement des énergies
    EnergieMeca deltat_ener; // init à 0. des énergies
    deltat_ener.ChangeEnergieElastique(0.5 * (sigHH && delta_epsBB));
    // mise à jour des énergies
    energ = deltat_ener+energ_t;
    
    LibereTenseur(); 
 };