219 lines
8.6 KiB
C++
Executable file
219 lines
8.6 KiB
C++
Executable file
|
|
|
|
// 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;
|
|
};
|
|
|