

/************************************************************************
 *     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  
