

// 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 <iostream>
using namespace std;  //introduces namespace std
#include <stdlib.h>
#include "Sortie.h"
#include "NevezTenseurQ.h"
//#include "Tenseur1.h"
//#include "Tenseur2.h"
#include "TenseurQ3gene.h"
#include "TenseurQ1gene.h"
#include "TenseurQ-3.h"
#include "TenseurQ-2.h"
#include "TenseurQ-1.h"
#include "Tenseur1_TroisSym.h"
#include "Tenseur2_TroisSym.h"
#include "Tenseur3_TroisSym.h"

TenseurHHHH * NevezTenseurHHHH(int dim,double val)
  { TenseurHHHH * ptr;
    switch (dim)
     { case 106 : ptr = new TenseurQ1_troisSym_HHHH(val); break;
       case 206 : ptr = new TenseurQ2_troisSym_HHHH(val); break;
       case 30 : ptr = new TenseurQ3geneHHHH(val); break;
       case 11 : ptr = new Tenseur1HHHH(val); break;
       case 22 : ptr = new Tenseur2HHHH(val); break;
       case 33 : ptr = new Tenseur3HHHH(val); break;
       case 306 : ptr = new TenseurQ3_troisSym_HHHH(val); break;
       default : { cout << " erreur d'allocation de nouveau tenseurHHHH \n"; Sortie(1); }
     }
    return ptr; 
   };    
TenseurBBBB * NevezTenseurBBBB(int dim,double val)
  { TenseurBBBB * ptr;
    switch (dim)
     { case 106 : ptr = new TenseurQ1_troisSym_BBBB(val); break;
       case 206 : ptr = new TenseurQ2_troisSym_BBBB(val); break;
       case 30 : ptr = new TenseurQ3geneBBBB(val); break;
       case 11 : ptr = new Tenseur1BBBB(val); break;
       case 22 : ptr = new Tenseur2BBBB(val); break;
       case 33 : ptr = new Tenseur3BBBB(val); break;
       case 306 : ptr = new TenseurQ3_troisSym_BBBB(val); break;
       default : { cout << " erreur d'allocation de nouveau tenseurBBBB \n"; Sortie(1); }
     }
    return ptr;  
   };  
TenseurHHBB * NevezTenseurHHBB(int dim,double val)
  { TenseurHHBB * ptr;
    switch (dim)
     { case 30 : ptr = new TenseurQ3geneHHBB(val); break;
       case 11 : ptr = new Tenseur1HHBB(val); break;
       case 22 : ptr = new Tenseur2HHBB(val); break;
       case 33 : ptr = new Tenseur3HHBB(val); break;
       default : { cout << " erreur d'allocation de nouveau tenseurHHBB \n"; Sortie(1); }
     }
    return ptr;    
   };  
TenseurBBHH * NevezTenseurBBHH(int dim,double val)
  { TenseurBBHH * ptr;
    switch (dim)
     { case 30 : ptr = new TenseurQ3geneBBHH(val); break;
       case 11 : ptr = new Tenseur1BBHH(val); break;
       case 22 : ptr = new Tenseur2BBHH(val); break;
       case 33 : ptr = new Tenseur3BBHH(val); break;
       default : { cout << " erreur d'allocation de nouveau tenseurBBHH \n"; Sortie(1); }
     }
    return ptr;     
   };
      
//---------------- en mixe ----------------------------
TenseurHBHB * NevezTenseurHBHB(int dim,double val)
  { TenseurHBHB * ptr;
    switch (dim)
     { case 106 : ptr = new TenseurQ1geneHBHB(val); break;
       default : { cout << " erreur d'allocation de nouveau tenseurHBHB \n"; Sortie(1); }
     }
    return ptr; 
   };    
TenseurBHBH * NevezTenseurBHBH(int dim,double val)
  { TenseurBHBH * ptr;
    switch (dim)
     { case 106 : ptr = new TenseurQ1geneBHBH(val); break;
       default : { cout << " erreur d'allocation de nouveau tenseurBHBH \n"; Sortie(1); }
     }
    return ptr; 
   };    
TenseurHBBH * NevezTenseurHBBH(int dim,double val)
  { TenseurHBBH * ptr;
    switch (dim)
     { case 106 : ptr = new TenseurQ1geneHBBH(val); break;
       default : { cout << " erreur d'allocation de nouveau tenseurHBBH \n"; Sortie(1); }
     }
    return ptr; 
   };    
TenseurBHHB * NevezTenseurBHHB(int dim,double val)
  { TenseurBHHB * ptr;
    switch (dim)
     { case 106 : ptr = new TenseurQ1geneBHHB(val); break;
       default : { cout << " erreur d'allocation de nouveau tenseurBHHB \n"; Sortie(1); }
     }
    return ptr; 
   };    
// --------------- non mixe -----------------------
TenseurHHHH * NevezTenseurHHHH(const TenseurHHHH& a)
  { TenseurHHHH * ptr;
    switch (a.Dimension())
     { case 106 : ptr = new TenseurQ1_troisSym_HHHH((TenseurQ1_troisSym_HHHH &) a); break;
       case 206 : ptr = new TenseurQ2_troisSym_HHHH((TenseurQ2_troisSym_HHHH &) a); break;
       case 30 : ptr = new TenseurQ3geneHHHH((Tenseur3HHHH &) a); break;
       case 11 : ptr = new Tenseur1HHHH((Tenseur1HHHH &) a); break;
       case 22 : ptr = new Tenseur2HHHH((Tenseur2HHHH &) a); break;
       case 33 : ptr = new Tenseur3HHHH((Tenseur3HHHH &) a); break;
       case 306 : ptr = new TenseurQ3_troisSym_HHHH((TenseurQ3_troisSym_HHHH &) a); break;
       default : { cout << " erreur d'allocation de nouveau tenseurHHHH \n"; Sortie(1); }
     }
    return ptr;     
   };   
        
TenseurBBBB * NevezTenseurBBBB(const TenseurBBBB& a)
  { TenseurBBBB * ptr;
    switch (a.Dimension())
     { case 106 : ptr = new TenseurQ1_troisSym_BBBB((TenseurQ1_troisSym_BBBB &) a); break;
       case 206 : ptr = new TenseurQ2_troisSym_BBBB((TenseurQ2_troisSym_BBBB &) a); break;
       case 30 : ptr = new TenseurQ3geneBBBB((Tenseur3BBBB&) a); break;
       case 11 : ptr = new Tenseur1BBBB((Tenseur1BBBB&) a); break;
       case 22 : ptr = new Tenseur2BBBB((Tenseur2BBBB&) a); break;
       case 33 : ptr = new Tenseur3BBBB((Tenseur3BBBB&) a); break;
       case 306 : ptr = new TenseurQ3_troisSym_BBBB((TenseurQ3_troisSym_BBBB &) a); break;
       default : { cout << " erreur d'allocation de nouveau tenseurBBBB \n"; Sortie(1); }
     }
    return ptr;  
   };  
TenseurHHBB * NevezTenseurHHBB(const TenseurHHBB& a)
  { TenseurHHBB * ptr;
    switch (a.Dimension())
     { case 30 : ptr = new TenseurQ3geneHHBB((Tenseur3HHBB&) a); break;
       case 11 : ptr = new Tenseur1HHBB((Tenseur1HHBB&) a); break;
       case 22 : ptr = new Tenseur2HHBB((Tenseur2HHBB&) a); break;
       case 33 : ptr = new Tenseur3HHBB((Tenseur3HHBB&) a); break;
       default : { cout << " erreur d'allocation de nouveau tenseurHHBB \n"; Sortie(1); }
     }
    return ptr;    
   };  
TenseurBBHH * NevezTenseurBBHH(const TenseurBBHH& a)
  { TenseurBBHH * ptr;
    switch (a.Dimension())
     { case 30 : ptr = new TenseurQ3geneBBHH((Tenseur3BBHH&) a); break;
       case 11 : ptr = new Tenseur1BBHH((Tenseur1BBHH&) a); break;
       case 22 : ptr = new Tenseur2BBHH((Tenseur2BBHH&) a); break;
       case 33 : ptr = new Tenseur3BBHH((Tenseur3BBHH&) a); break;
       default : { cout << " erreur d'allocation de nouveau tenseurBBHH \n"; Sortie(1); }
     }
    return ptr;     
   };   
      
//---------------- en mixe ----------------------------
TenseurHBHB * NevezTenseurHBHB(const TenseurHBHB& a)
  { TenseurHBHB * ptr;
    switch (a.Dimension())
     { case 106 : ptr = new TenseurQ1geneHBHB((TenseurQ1geneHBHB &) a); break;
       default : { cout << " erreur d'allocation de nouveau tenseurHBHB \n"; Sortie(1); }
     }
    return ptr;  
   };  

TenseurBHBH * NevezTenseurBHBH(const TenseurBHBH& a)
  { TenseurBHBH * ptr;
    switch (a.Dimension())
     { case 106 : ptr = new TenseurQ1geneBHBH((TenseurQ1geneBHBH &) a); break;
       default : { cout << " erreur d'allocation de nouveau tenseurBHBH \n"; Sortie(1); }
     }
    return ptr;  
   };  
TenseurBHHB * NevezTenseurBHHB(const TenseurBHHB& a)
  { TenseurBHHB * ptr;
    switch (a.Dimension())
     { case 106 : ptr = new TenseurQ1geneBHHB((TenseurQ1geneBHHB &) a); break;
       default : { cout << " erreur d'allocation de nouveau tenseurBHHB \n"; Sortie(1); }
     }
    return ptr;  
   };  
TenseurHBBH * NevezTenseurHBBH(const TenseurHBBH& a)
  { TenseurHBBH * ptr;
    switch (a.Dimension())
     { case 106 : ptr = new TenseurQ1geneHBBH((TenseurQ1geneHBBH &) a); break;
       default : { cout << " erreur d'allocation de nouveau tenseurHBBH \n"; Sortie(1); }
     }
    return ptr;  
   };  

