/** \file NevezTenseur.h
* déclaration des méthodes externes aux classes de tenseur d'ordre 2, qui permettent de définir un nouveau tenseur
*/


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


/************************************************************************
*     DATE:        23/01/97                                            *
*                                                                $     *
*     AUTEUR:      G RIO                                               *
*                                                                $     *
*     PROJET:      Herezh++                                            *
*                                                                $     *
************************************************************************
************************************************************************
*     BUT:   definir un nouveau tenseur en fonction de la dimension    *
*            ceci pour des tenseurs d'ordre 2.                         *
*                                                                $     *
*     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''     *
************************************************************************/

#ifndef NEVEZTENSEUR_H
#define NEVEZTENSEUR_H
#include "Tenseur.h"

/// la méthode retourne le pointeur affecte sur un tenseur de
/// la bonne taille en fonction de la dimension "dim"
/// par defaut les composantes du nouveau tenseur sont mise a zero
/// mais on peut indiquer une valeur qui sera affectee a tous les composantes
/// le signe de la dimension indique:
/// dim > 0 : tenseurs symétriques
/// dim < 0 : tenseurs non symétriques
TenseurHH * NevezTenseurHH(int dim,double val = 0.);
/// la méthode retourne le pointeur affecte sur un tenseur de
/// la bonne taille en fonction de la dimension "dim"
/// par defaut les composantes du nouveau tenseur sont mise a zero
/// mais on peut indiquer une valeur qui sera affectee a tous les composantes
/// le signe de la dimension indique:
/// dim > 0 : tenseurs symétriques
/// dim < 0 : tenseurs non symétriques
TenseurBB * NevezTenseurBB(int dim,double val = 0.);
/// la méthode retourne le pointeur affecte sur un tenseur de
/// la bonne taille en fonction de la dimension "dim"
/// par defaut les composantes du nouveau tenseur sont mise a zero
/// mais on peut indiquer une valeur qui sera affectee a tous les composantes
/// le signe de la dimension indique:
/// dim > 0 : tenseurs symétriques
/// dim < 0 : tenseurs non symétriques
TenseurHB * NevezTenseurHB(int dim,double val = 0.);
/// la méthode retourne le pointeur affecte sur un tenseur de
/// la bonne taille en fonction de la dimension "dim"
/// par defaut les composantes du nouveau tenseur sont mise a zero
/// mais on peut indiquer une valeur qui sera affectee a tous les composantes
/// le signe de la dimension indique:
/// dim > 0 : tenseurs symétriques
/// dim < 0 : tenseurs non symétriques
TenseurBH * NevezTenseurBH(int dim,double val = 0.);

/// en entree on fourni une référence sur un element de la classe generique
/// en sortie la méthode retourne le pointeur affecte sur un tenseur de
/// la bonne taille en fonction du tenseur du meme type
/// les composantes du nouveau tenseur sont identiques a celle du tenseur
/// passé en parametre
TenseurHH * NevezTenseurHH(const TenseurHH& a);
/// en entree on fourni une référence sur un element de la classe generique
/// en sortie la méthode retourne le pointeur affecte sur un tenseur de
/// la bonne taille en fonction du tenseur du meme type
/// les composantes du nouveau tenseur sont identiques a celle du tenseur
/// passé en parametre
TenseurBB * NevezTenseurBB(const TenseurBB& a);
/// en entree on fourni une référence sur un element de la classe generique
/// en sortie la méthode retourne le pointeur affecte sur un tenseur de
/// la bonne taille en fonction du tenseur du meme type
/// les composantes du nouveau tenseur sont identiques a celle du tenseur
/// passé en parametre
TenseurHB * NevezTenseurHB(const TenseurHB& a);
/// en entree on fourni une référence sur un element de la classe generique
/// en sortie la méthode retourne le pointeur affecte sur un tenseur de
/// la bonne taille en fonction du tenseur du meme type
/// les composantes du nouveau tenseur sont identiques a celle du tenseur
/// passé en parametre
TenseurBH * NevezTenseurBH(const TenseurBH& a);

/// définition de tenseur d'ordre 2 à partir d'un produit tensoriel de vecteur
/// en sortie le programme retourne le pointeur affecte sur un tenseur de
/// la bonne taille en fonction de la dimension du pb
TenseurBB * Produit_tensorielBB(const CoordonneeB & aB, const CoordonneeB & bB);
/// définition de tenseur d'ordre 2 à partir d'un produit tensoriel de vecteur
/// en sortie le programme retourne le pointeur affecte sur un tenseur de
/// la bonne taille en fonction de la dimension du pb
TenseurHH * Produit_tensorielHH(const CoordonneeH & aH, const CoordonneeH & bH);
/// définition de tenseur d'ordre 2 à partir d'un produit tensoriel de vecteur
/// en sortie le programme retourne le pointeur affecte sur un tenseur de
/// la bonne taille en fonction de la dimension du pb
TenseurHB * Produit_tensorielHB(const CoordonneeH & aH, const CoordonneeB & bB);
/// définition de tenseur d'ordre 2 à partir d'un produit tensoriel de vecteur
/// en sortie le programme retourne le pointeur affecte sur un tenseur de
/// la bonne taille en fonction de la dimension du pb
TenseurBH * Produit_tensorielBH(const CoordonneeB & aB, const CoordonneeH & bH);




#endif  
