rio/Herezh_dev
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Herezh_dev/Elements/Mecanique/LesChargeExtSurElement.cc

540 lines
20 KiB
C++
Raw Permalink Normal View History

intégration du répertoire Mecanique: - contient les éléments finis, métriques associées, déformations ... intégration du réperoire Géométrie: - contient les géométries 1D 2D et 3D, les frontières des éléments géométriques
2021-09-27 12:42:13 +02:00
// 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.
//
mise à jour 7.010
2023-05-03 17:23:49 +02:00
// Copyright (C) 1997-2022 Université Bretagne Sud (France)
intégration du répertoire Mecanique: - contient les éléments finis, métriques associées, déformations ... intégration du réperoire Géométrie: - contient les géométries 1D 2D et 3D, les frontières des éléments géométriques
2021-09-27 12:42:13 +02:00
// 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 "LesChargeExtSurElement.h"
// contructeur par défaut
LesChargeExtSurElement::LesChargeExtSurElement():
lesPressionsExternes(NULL),force_volume(NULL),lesEffortsDirFixe(NULL),lesPressDir(NULL),lesHydroDyna(NULL)
,lesLineique(NULL),lesLineiqueSuiveuse(NULL)
{};
// contructeur de copie
LesChargeExtSurElement::LesChargeExtSurElement(const LesChargeExtSurElement& a):
lesPressionsExternes(a.lesPressionsExternes),force_volume(NULL),lesEffortsDirFixe(NULL),lesPressDir(NULL),lesHydroDyna(NULL)
,lesLineique(NULL),lesLineiqueSuiveuse(NULL)
{ // on relie les tableaux entre eux
//---- dimensionnement des charges externes éventuellement ----
// dimensionnement des forces de pression
if (a.lesPressionsExternes != NULL)
lesPressionsExternes = new Tableau <Tableau <Pression_appliquee> >(*a.lesPressionsExternes);
// dimensionnement des forces de volumes
if (a.force_volume != NULL)
force_volume = new Tableau < Coordonnee >(*a.force_volume);
// cas des densités d'effort de direction fixe
if (a.lesEffortsDirFixe != NULL)
lesEffortsDirFixe = new Tableau <Tableau <Coordonnee> >(*a.lesEffortsDirFixe);
// cas des densités d'effort suiveur
if (a.lesPressDir != NULL)
lesPressDir = new Tableau <Tableau <Coordonnee> >(*a.lesPressDir);
// cas des densités d'effort de type hydrodynamique
if (a.lesHydroDyna != NULL)
lesHydroDyna = new Tableau <Tableau <Force_hydroDyna> >(*a.lesHydroDyna);
// cas des charges linéiques
if (a.lesLineique != NULL)
lesLineique = new Tableau <Tableau <Coordonnee> >(*a.lesLineique);
// cas des linéiques suiveuses
if (a.lesLineiqueSuiveuse != NULL)
lesLineiqueSuiveuse = new Tableau <Tableau <Coordonnee> >(*a.lesLineiqueSuiveuse);
};
// DESTRUCTEUR :
// normalement il n'y a rien n'a faire car les pointeurs sont des copies
LesChargeExtSurElement::~LesChargeExtSurElement()
{
// suppression éventuelle des forces de pressions
if (lesPressionsExternes != NULL)
delete lesPressionsExternes;
// suppression éventuelle des forces de volumes
if (force_volume != NULL)
delete force_volume;
// cas des densités d'effort de direction fixe
if (lesEffortsDirFixe != NULL)
delete lesEffortsDirFixe ;
// cas des densités d'effort suiveur
if (lesPressDir != NULL)
delete lesPressDir ;
// cas des densités d'effort de type hydrodynamique
if (lesHydroDyna != NULL)
delete lesHydroDyna ;
// cas des charges linéiques
if (lesLineique != NULL)
delete lesLineique ;
// cas des linéiques suiveuses
if (lesLineiqueSuiveuse != NULL)
delete lesLineiqueSuiveuse ;
};
// Surcharge de l'operateur =
LesChargeExtSurElement& LesChargeExtSurElement::operator= ( const LesChargeExtSurElement& a)
{ // on relie les tableaux entre eux
//---- dimensionnement des charges externes éventuellement ----
// cas des pression
if (a.lesPressionsExternes != NULL)
{ if (lesPressionsExternes == NULL)
{lesPressionsExternes = new Tableau <Tableau <Pression_appliquee> >(*a.lesPressionsExternes);}
else // sinon le conteneur existe, il suffit de faire une affectation
{(*lesPressionsExternes) = (*a.lesPressionsExternes);};
}
else // sinon cela veut dire que a.lesPressionsExternes est un pointeur nul
{ if (lesPressionsExternes != NULL)
{delete lesPressionsExternes;};
lesPressionsExternes = NULL;
};
// dimensionnement des forces de volumes
if (a.force_volume != NULL)
{ if (force_volume == NULL)
{force_volume = new Tableau < Coordonnee >(*a.force_volume);}
else // sinon il suffit de faire une affectation
{(*force_volume) = (*a.force_volume);};
}
else // sinon cela veut dire que a.force_volume est un pointeur nul
{ if (force_volume != NULL)
{delete force_volume;};
force_volume = NULL;
};
// cas des densités d'effort de direction fixe
if (a.lesEffortsDirFixe != NULL)
{ if (lesEffortsDirFixe == NULL)
{lesEffortsDirFixe = new Tableau <Tableau <Coordonnee> >(*a.lesEffortsDirFixe);}
else // sinon le conteneur existe, il suffit de faire une affectation
{(*lesEffortsDirFixe) = (*a.lesEffortsDirFixe);};
}
else // sinon cela veut dire que a.lesEffortsDirFixe est un pointeur nul
{ if (lesEffortsDirFixe != NULL)
{delete lesEffortsDirFixe;};
lesEffortsDirFixe = NULL;
};
// cas des densités d'effort suiveur
if (a.lesPressDir != NULL)
{ if (lesPressDir == NULL)
{lesPressDir = new Tableau <Tableau <Coordonnee> >(*a.lesPressDir);}
else // sinon le conteneur existe, il suffit de faire une affectation
{(*lesPressDir) = (*a.lesPressDir);};
}
else // sinon cela veut dire que a.lesPressDir est un pointeur nul
{ if (lesPressDir != NULL)
{delete lesPressDir;};
lesPressDir = NULL;
};
// cas des densités d'effort de type hydrodynamique
if (a.lesHydroDyna != NULL)
{ if (lesHydroDyna == NULL)
{lesHydroDyna = new Tableau <Tableau <Force_hydroDyna> >(*a.lesHydroDyna);}
else // sinon le conteneur existe, il suffit de faire une affectation
{(*lesHydroDyna) = (*a.lesHydroDyna);};
}
else // sinon cela veut dire que a.lesHydroDyna est un pointeur nul
{ if (lesHydroDyna != NULL)
{delete lesHydroDyna;};
lesHydroDyna = NULL;
};
// cas des charges linéiques
if (a.lesLineique != NULL)
{ if (lesLineique == NULL)
{lesLineique = new Tableau <Tableau <Coordonnee> >(*a.lesLineique);}
else // sinon le conteneur existe, il suffit de faire une affectation
{(*lesLineique) = (*a.lesLineique);};
}
else // sinon cela veut dire que a.lesLineique est un pointeur nul
{ if (lesLineique != NULL)
{delete lesLineique;};
lesLineique = NULL;
};
// cas des charges linéiques suiveuses
if (a.lesLineiqueSuiveuse != NULL)
{ if (lesLineiqueSuiveuse == NULL)
{lesLineiqueSuiveuse = new Tableau <Tableau <Coordonnee> >(*a.lesLineiqueSuiveuse);}
else // sinon le conteneur existe, il suffit de faire une affectation
{(*lesLineiqueSuiveuse) = (*a.lesLineiqueSuiveuse);};
}
else // sinon cela veut dire que a.lesLineiqueSuiveuse est un pointeur nul
{ if (lesLineiqueSuiveuse != NULL)
{delete lesLineiqueSuiveuse;};
lesLineiqueSuiveuse = NULL;
};
return *this;
};
// initialisation à 0 de tous les conteneurs existants
void LesChargeExtSurElement::Zero()
{
// cas des forces de pression
if (lesPressionsExternes != NULL)
{int tail=lesPressionsExternes->Taille();
for (int i=1;i<=tail;i++)
{ int nta=(*lesPressionsExternes)(i).Taille();
Tableau <Pression_appliquee>& tab_inter= (*lesPressionsExternes)(i);
for (int j=1;j<=nta;j++)
tab_inter(j).Zero();
};
};
// cas des forces de volumes
if (force_volume != NULL)
{int tail = force_volume->Taille();
for (int i=1;i<=tail;i++)
(*force_volume)(i).Zero();
};
// cas des densités d'effort de direction fixe
if (lesEffortsDirFixe != NULL)
{int tail=lesEffortsDirFixe->Taille();
for (int i=1;i<=tail;i++)
{ int nta=(*lesEffortsDirFixe)(i).Taille();
Tableau <Coordonnee>& tab_inter= (*lesEffortsDirFixe)(i);
for (int j=1;j<=nta;j++)
tab_inter(j).Zero();
};
};
// cas des densités d'effort suiveur
if (lesPressDir != NULL)
{int tail=lesPressDir->Taille();
for (int i=1;i<=tail;i++)
{ int nta=(*lesPressDir)(i).Taille();
Tableau <Coordonnee>& tab_inter= (*lesPressDir)(i);
for (int j=1;j<=nta;j++)
tab_inter(j).Zero();
};
};
// cas des densités d'effort de type hydrodynamique
if (lesHydroDyna != NULL)
{int tail=lesHydroDyna->Taille();
for (int i=1;i<=tail;i++)
{ int nta=(*lesHydroDyna)(i).Taille();
Tableau <Force_hydroDyna>& tab_inter= (*lesHydroDyna)(i);
for (int j=1;j<=nta;j++)
tab_inter(j).Zero();
};
};
// cas des charges linéiques
if (lesLineique != NULL)
{int tail=lesLineique->Taille();
for (int i=1;i<=tail;i++)
{ int nta=(*lesLineique)(i).Taille();
Tableau <Coordonnee>& tab_inter= (*lesLineique)(i);
for (int j=1;j<=nta;j++)
tab_inter(j).Zero();
};
};
// cas des linéiques suiveuses
if (lesLineiqueSuiveuse != NULL)
{int tail=lesLineiqueSuiveuse->Taille();
for (int i=1;i<=tail;i++)
{ int nta=(*lesLineiqueSuiveuse)(i).Taille();
Tableau <Coordonnee>& tab_inter= (*lesLineiqueSuiveuse)(i);
for (int j=1;j<=nta;j++)
tab_inter(j).Zero();
};
};
};
// cas d'un changement de taille pour les pressions appliquées
void LesChargeExtSurElement::LesPressionsExternes_Change_taille(int n)
{if (lesPressionsExternes==NULL) {lesPressionsExternes = new Tableau <Tableau <Pression_appliquee> >(n);}
else if (lesPressionsExternes->Taille() == n) {return;} //cas le plus courant
else {lesPressionsExternes->Change_taille(n);};
};
// cas d'un changement de taille pour les forces volumiques
void LesChargeExtSurElement::Force_volume_Change_taille(int n)
{if (force_volume==NULL) {force_volume = new Tableau < Coordonnee >(n,Coordonnee(ParaGlob::Dimension()));}
else if (force_volume->Taille() == n) {return;} //cas le plus courant
else if (force_volume->Taille() > n)
{force_volume->Change_taille(n);} // si on réduit pas de pb
else if (force_volume->Taille() < n); // cas qui n'arrive pas souvent normalement
{force_volume->Change_taille(n,Coordonnee(ParaGlob::Dimension()));} // tout est redimensionné à la dimension du pb
};
// cas d'un changement de taille pour les densité d’effort dont la direction reste fixe
void LesChargeExtSurElement::LesEffortsDirFixe_Change_taille(int n)
{if (lesEffortsDirFixe==NULL)
{lesEffortsDirFixe = new Tableau <Tableau <Coordonnee> >(n);}
else if (lesEffortsDirFixe->Taille() == n) {return;} //cas le plus courant
else {lesEffortsDirFixe->Change_taille(n);};
};
// cas d'un changement de taille pour les densités éventuelles d’effort de surface dont la direction suit la face face de l'élément
void LesChargeExtSurElement::LesPressDir_Change_taille(int n)
{if (lesPressDir==NULL) {lesPressDir = new Tableau <Tableau <Coordonnee> >(n);}
else if (lesPressDir->Taille() == n) {return;} //cas le plus courant
else {lesPressDir->Change_taille(n);};
};
// cas d'un changement de taille pour les densités éventuelles d’effort de surface d'origine hydrodynamique
void LesChargeExtSurElement::LesHydroDyna_Change_taille(int n)
{if (lesHydroDyna==NULL) {lesHydroDyna = new Tableau <Tableau <Force_hydroDyna> >(n);}
else {lesHydroDyna->Change_taille(n);};
};
// cas d'un changement de taille pour charge linéique
void LesChargeExtSurElement::LesLineique_Change_taille(int n)
{if (lesLineique==NULL) {lesLineique = new Tableau <Tableau <Coordonnee> >(n);}
else if (lesLineique->Taille() == n) {return;} //cas le plus courant
else {lesLineique->Change_taille(n);};
};
// cas d'un changement de taille pour charge linéique suiveuse
void LesChargeExtSurElement::LesLineiqueSuiveuse_Change_taille(int n)
{if (lesLineiqueSuiveuse==NULL) {lesLineiqueSuiveuse = new Tableau <Tableau <Coordonnee> >(n);}
else if (lesLineiqueSuiveuse->Taille() == n) {return;} //cas le plus courant
else {lesLineiqueSuiveuse->Change_taille(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 LesChargeExtSurElement::Lecture_base_info (ifstream& ent,const int )
{ // l'entrée est identique quelque soit la valeur de cas
ent >> (*this);
};
// cas donne le niveau de sauvegarde
// = 1 : on sauvegarde tout
// = 2 : on sauvegarde uniquement les données variables (supposées comme telles)
void LesChargeExtSurElement::Ecriture_base_info(ofstream& sort,const int )
{ // la sortie est identique quelque soit la valeur de cas
sort << (*this);
};
// surcharge de l'operateur de lecture
istream & operator >> (istream & entree, LesChargeExtSurElement & a)
{ // vérification du type
string nom;
entree >> nom;
#ifdef MISE_AU_POINT
if (nom != "LesChargeExtSurElement")
{ cout << "\nErreur, en lecture d'une instance LesChargeExtSurElement "
<< " on attendait LesChargeExtSurElement et on a lue: " << nom ;
cout << "istream & operator >> (istream & entree, LesChargeExtSurElement & a)\n";
Sortie(1);
};
#endif
// puis lecture des différents éléments
// cas des forces de pression
int tail_pression = 0.;//a.lesPressionsExternes.Taille();
entree >> nom >> tail_pression ;
if (tail_pression != 0)
{ if (a.lesPressionsExternes == NULL)
// cas où il faut créer
{a.lesPressionsExternes = new Tableau <Tableau <Pression_appliquee> >(tail_pression);}
else if (a.lesPressionsExternes->Taille() != tail_pression)
// cas où il faut modifier la taille
{a.lesPressionsExternes->Change_taille(tail_pression);};
// maintenant on peut lire
entree >> (*a.lesPressionsExternes);
}
else // sinon rien n'a lire
{ if (a.lesPressionsExternes != NULL)
delete a.lesPressionsExternes;
};
// cas des forces de volumes
int tail_vol = 0.;
entree >> nom >> tail_vol ;
if (tail_vol != 0)
{ if (a.force_volume == NULL)
// cas où il faut créer
{a.force_volume = new Tableau <Coordonnee>(tail_vol);}
else if (a.force_volume->Taille() != tail_vol)
// cas où il faut modifier la taille
{a.force_volume->Change_taille(tail_vol);};
// maintenant on peut lire
entree >> (*a.force_volume);
}
else // sinon rien n'a lire
{ if (a.force_volume != NULL)
delete a.force_volume;
};
// cas des densités d'effort de direction fixe
int tail_F_DirFixe = 0.;
entree >> nom >> tail_F_DirFixe ;
if (tail_F_DirFixe != 0)
{ if (a.lesEffortsDirFixe == NULL)
// cas où il faut créer
{a.lesEffortsDirFixe = new Tableau <Tableau <Coordonnee> >(tail_F_DirFixe);}
else if (a.lesEffortsDirFixe->Taille() != tail_F_DirFixe)
// cas où il faut modifier la taille
{a.lesEffortsDirFixe->Change_taille(tail_F_DirFixe);};
// maintenant on peut lire
entree >> (*a.lesEffortsDirFixe);
}
else // sinon rien n'a lire
{ if (a.lesEffortsDirFixe != NULL)
delete a.lesEffortsDirFixe;
};
// cas des densités d'effort suiveur
int tail_F_Dir = 0.;
entree >> nom >> tail_F_Dir ;
if (tail_F_Dir != 0)
{ if (a.lesPressDir == NULL)
// cas où il faut créer
{a.lesPressDir = new Tableau <Tableau <Coordonnee> >(tail_F_Dir);}
else if (a.lesPressDir->Taille() != tail_F_Dir)
// cas où il faut modifier la taille
{a.lesPressDir->Change_taille(tail_F_Dir);};
// maintenant on peut lire
entree >> (*a.lesPressDir);
}
else // sinon rien n'a lire
{ if (a.lesPressDir != NULL)
delete a.lesPressDir;
};
// cas des densités d'effort de type hydrodynamique
int tail_F_HydroDyna = 0.;
entree >> nom >> tail_F_HydroDyna ;
if (tail_F_HydroDyna != 0)
{ if (a.lesHydroDyna == NULL)
// cas où il faut créer
{a.lesHydroDyna = new Tableau <Tableau <Force_hydroDyna> >(tail_F_HydroDyna);}
else if (a.lesHydroDyna->Taille() != tail_F_HydroDyna)
// cas où il faut modifier la taille
{a.lesHydroDyna->Change_taille(tail_F_HydroDyna);};
// maintenant on peut lire
entree >> (*a.lesHydroDyna);
}
else // sinon rien n'a lire
{ if (a.lesHydroDyna != NULL)
delete a.lesHydroDyna;
};
// cas des charges linéiques
int tail_F_lin = 0.;
entree >> nom >> tail_F_lin ;
if (tail_F_lin != 0)
{ if (a.lesLineique == NULL)
// cas où il faut créer
{a.lesLineique = new Tableau <Tableau <Coordonnee> >(tail_F_lin);}
else if (a.lesLineique->Taille() != tail_F_lin)
// cas où il faut modifier la taille
{a.lesLineique->Change_taille(tail_F_lin);};
// maintenant on peut lire
entree >> (*a.lesLineique);
}
else // sinon rien n'a lire
{ if (a.lesLineique != NULL)
delete a.lesLineique;
};
// cas des linéiques suiveuses
int tail_F_linSuiv = 0.;
entree >> nom >> tail_F_linSuiv ;
if (tail_F_linSuiv != 0)
{ if (a.lesLineiqueSuiveuse == NULL)
// cas où il faut créer
{a.lesLineiqueSuiveuse = new Tableau <Tableau <Coordonnee> >(tail_F_linSuiv);}
else if (a.lesLineiqueSuiveuse->Taille() != tail_F_linSuiv)
// cas où il faut modifier la taille
{a.lesLineiqueSuiveuse->Change_taille(tail_F_linSuiv);};
// maintenant on peut lire
entree >> (*a.lesLineiqueSuiveuse);
}
else // sinon rien n'a lire
{ if (a.lesLineiqueSuiveuse != NULL)
delete a.lesLineiqueSuiveuse;
};
return entree;
};
// surcharge de l'operateur d'ecriture
ostream & operator << ( ostream & sort,const LesChargeExtSurElement & a)
{ // tout d'abord un indicateur donnant le type
sort << "\n LesChargeExtSurElement \n" ;
// cas des forces de pression
sort << "Press: ";
if (a.lesPressionsExternes != NULL)
{sort << a.lesPressionsExternes->Taille() << " ";
sort << (*a.lesPressionsExternes);
}
else {sort << " 0 ";};
// cas des forces de volumes
sort << "F_vol: ";
if (a.force_volume != NULL)
{sort << a.force_volume->Taille() << " ";
sort << (*a.force_volume);}
else {sort << " 0 ";};
// cas des densités d'effort de direction fixe
sort << "F_DirFixe: ";
if (a.lesEffortsDirFixe != NULL)
{sort << a.lesEffortsDirFixe->Taille() << " ";
sort << (*a.lesEffortsDirFixe);
}
else {sort << " 0 ";};
// cas des densités d'effort suiveur
sort << "F_Dir: ";
if (a.lesPressDir != NULL)
{sort << a.lesPressDir->Taille() << " ";
sort << (*a.lesPressDir);
}
else {sort << " 0 ";};
// cas des densités d'effort de type hydrodynamique
sort << "F_HydroDyna: ";
if (a.lesHydroDyna != NULL)
{sort << a.lesHydroDyna->Taille() << " ";
sort << (*a.lesHydroDyna);
}
else {sort << " 0 ";};
// cas des charges linéiques
sort << "F_lin: ";
if (a.lesLineique != NULL)
{sort << a.lesLineique->Taille() << " ";
sort << (*a.lesLineique);
}
else {sort << " 0 ";};
// cas des linéiques suiveuses
sort << "F_linSuiv: ";
if (a.lesLineiqueSuiveuse != NULL)
{sort << a.lesLineiqueSuiveuse->Taille() << " ";
sort << (*a.lesLineiqueSuiveuse);
}
else {sort << " 0 ";};
return sort;
};
Reference in a new issue Copy permalink