203 lines
9.2 KiB
C++
203 lines
9.2 KiB
C++
|
|
// 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);
|
|
};
|
|
|
|
|