Herezh_dev/herezh_pp/Elements/Mecanique/ElemMecaGene.h

161 lines
8.1 KiB
C++
Executable file

/************************************************************************
* DATE: 23/01/97 *
* $ *
* AUTEUR: G RIO (mailto:gerardrio56@free.fr) *
* $ *
* PROJET: Herezh++ *
* $ *
************************************************************************
* BUT: Defini l'element generique de mecanique. *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' * *
* VERIFICATION: *
* *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* ! ! ! ! *
* $ *
* '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' *
* MODIFICATIONS: *
* ! date ! auteur ! but ! *
* ------------------------------------------------------------ *
* $ *
************************************************************************/
#ifndef ELEMMECA_H
#define ELEMMECA_H
#include "Element.h"
#include "Tenseur.h"
#include "NevezTenseur.h"
#include "Deformation.h"
#include "Loi_comp_abstraite.h"
class ElemMeca : public Element
pour l'instant en essai pour une classe générale au dessus du solide et des fluides
{
public :
// VARIABLES PUBLIQUES :
// CONSTRUCTEURS :
ElemMeca ();
// Constructeur utile quand le numero d'identification de l'element est connu
ElemMeca (int num_id) ;
// Constructeur utile quand le numero et le tableau des noeuds
// de l'element sont connu
ElemMeca (int num_id,const Tableau<Noeud *>& tab);
// Constructeur utile quand le numero d'identification est connu,
// ainsi que la geometrie et le type d'interpolation de l'element
ElemMeca (int num_id,Enum_interpol id_interp_elt,Enum_geom id_geom_elt);
// Constructeur utile quand le numero d'identification est connu,
// ainsi que la geometrie et le type d'interpolation de l'element
ElemMeca (int num_id,char* nom_interpol,char* nom_geom);
// Constructeur utile quand toutes les donnees de la classe Element sont connues
ElemMeca (int num_id,const Tableau<Noeud *>& tab,Enum_interpol id_interp_elt,
Enum_geom id_geom_elt);
// Constructeur utile quand toutes les donnees de la classe Element sont connues
ElemMeca (int num_id,const Tableau<Noeud *>& tab,char* nom_interpol,
char* nom_geom);
// Constructeur de copie
ElemMeca ( ElemMeca& elt);
// DESTRUCTEUR :
~ElemMeca ();
// METHODES PUBLIQUES :
// test si l'element est complet
// = 1 tout est ok, =0 element incomplet
int TestComplet();
// calcul si un point est a l'interieur de l'element ou non
// condition d'utilisation : il faut que la dimension de M soit
// celle de l'element, c'a-dire si dim(M) = 3 il faut que l'element soit 3D
// si dim(M) = 2, l'element doit etre surfacique et si dim(M) = 1 il faut un
// element geometrique de type FrontPointF
// il faut egalement que M est la dimension globale
// les trois fonctions sont pour l'etude a t=0, t et tdt
bool Interne_0(Coordonnee& M);
bool Interne_t(Coordonnee& M);
bool Interne_tdt(Coordonnee& M);
protected :
// METHODES PROTEGEES utilisables par les classes derivees :
// Calcul du residu local et de la raideur locale,
// pour le schema implicite d'ou a l'instant t + dt
// ddl represente les degres de liberte specifiques a l'element
void Cal_implicit (DdlElement & tab_ddl,Tableau <TenseurBB *>& tabEpsBB,
Tableau <TenseurBB *> & d_epsBB,Tableau <TenseurHH *>& tabSigHH,
int nbint,Vecteur& poids);
// Calcul du residu local a l'instant t
// pour le schema explicit
// ddl represente les degres de liberte specifiques a l'element
// epsBB = deformation, sigHH = contrainte, d_epsbb = variation des def
// nbint = nb de pt d'integration , poids = poids d'integration
void Cal_explicit (DdlElement & ddl,Tableau <TenseurBB *>& tabEpsBB,
Tableau <TenseurBB *>& d_epsBB,Tableau <TenseurHH *>& tabSigHH,
int nbint,Vecteur& poids);
// affichage dans la sortie transmise, des variables duales "nom"
// aux differents points d'integration
// dans le cas ou nom est vide, affichage de "toute" les variables
// cas =1 -> premier passage pour de l'implicit
// cas = 2 -> premier passage pour de l'explicit
// cas = 11 -> passage autre que le premier pour de l'implicit
// cas = 12 -> passage autre que le premier pour de l'explicit
void VarDualSort(ofstream& sort, Tableau<string>& nom,
Tableau <TenseurHH *>& tabSigHH,Tableau <TenseurBB *> & tabEpsBB,
int nbint,int cas);
// utilitaires de VarDualSort
// affiche en fonction d'indic les differentes variables et appel
// AffDefContiD en fonction de la dimension i
//
void AffDefCont( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& epsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,
Vecteur& valPropreEps,Vecteur& valPropreSig,
int indic);
// cas 1D
void AffDefCont1D( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& epsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,
Vecteur& valPropreEps,Vecteur& valPropreSig,
int indic);
// cas 2D
void AffDefCont2D( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& epsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,
Vecteur& valPropreEps,Vecteur& valPropreSig,
int indic);
// cas 3D
void AffDefCont3D( ofstream& sort,Loi_comp_abstraite::SaveResul * saveDon,
TenseurBB& eps0BB,TenseurBB& epsBB,
TenseurHH& sigHH,
TenseurHB& epsHB,TenseurHB& sigHB,
Vecteur& valPropreEps,Vecteur& valPropreSig,
int indic);
// recherche si un point est interne a un element
bool Interne(Coordonnee& M);
// VARIABLES PROTEGEES :
Loi_comp_abstraite * loiComp; // loi de comportement defini dans les classes derivees
Met_abstraite * met; // definition specifique dans les classes derivees
Deformation * def; // definition specifique dans les classes derivees
Tableau <Loi_comp_abstraite::SaveResul *> tabSaveDon; //
// pour faciliter les routines Interne_t _0 et _tdt
static Coordonnee & (Met_abstraite::*PointM) (Tableau<Noeud *>& tab_noeud,Vecteur& Phi);
static void (Met_abstraite::*BaseND)
(Tableau<Noeud *>& tab_noeud,Mat_pleine& dphi,BaseB& bB,BaseH& bH);
};
#endif