2146 lines
124 KiB
C++
Executable file
2146 lines
124 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 "Charge.h"
|
|
#include "ConstMath.h"
|
|
#include "MathUtil.h"
|
|
#include "ReferenceNE.h"
|
|
#include "ReferenceAF.h"
|
|
|
|
|
|
|
|
// mise en place du chargement impose sur le second membre global
|
|
// cas explicite
|
|
// la variable relative à la classe assemblage est passé en argument ce qui permet d'utiliser
|
|
// éventuellement plusieurs type d'assemblage
|
|
// retour false si problème de calcul
|
|
bool Charge::ChargeSecondMembre_Ex_mecaSolid
|
|
(Assemblage & assemb,LesMaillages * lesMail,LesReferences* lesRef,Vecteur& vecglob
|
|
,const ParaAlgoControle & pa,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD)
|
|
{
|
|
temps_cpu_chargement.Mise_en_route_du_comptage(); // temps cpu
|
|
bool retour = true; // init par défaut
|
|
try
|
|
{
|
|
// pour tous les maillages, pour tous les éléments on effectue une initialisation éventuelle
|
|
int nb_mail = lesMail->NbMaillage();
|
|
for (int imail = 1;imail<=nb_mail;imail++)
|
|
{ int nb_ele = lesMail->Nombre_element(imail);
|
|
for (int iele =1;iele<=nb_ele;iele++)
|
|
lesMail->Element_LesMaille(imail,iele).Initialisation_avant_chargement();
|
|
};
|
|
|
|
int posi = Id_nom_ddl("X1") -1;
|
|
int dim = ParaGlob::Dimension();
|
|
|
|
// $$$ --- cas des forces ponctuelles --- $$$
|
|
|
|
// on regarde si l'espace de travail est axi-symétrique, si oui on utilise une dimension réduite
|
|
int dima=dim; // c'est dima qui est utiliser pour la mise en place des efforts ponctuelles
|
|
if (ParaGlob::AxiSymetrie()) dima--;
|
|
// on parcours le tableau tabPonctuel
|
|
for (int i=1;i<= tabPonctuel.Taille();i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<BlocForces> >& tabPonctuel_i = tabPonctuel(i);
|
|
const ReferenceNE & ref =
|
|
((ReferenceNE &) lesRef->Trouve(tabPonctuel_i.NomRef(),tabPonctuel_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(tabPonctuel_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(tabPonctuel_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(tabPonctuel_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{int reftaille = ref.Taille();
|
|
int cas_assemblage = (assemb.Nb_cas_assemb()).n; // récup du cas d'assemblage
|
|
for (int nn =1; nn<= reftaille;nn++) // nn = position des num de noeud
|
|
{ Noeud & noe=lesMail->Noeud_LesMaille(ref.Nbmaille(),ref.Numero(nn));
|
|
Coordonnee force; // init
|
|
// on traite en fonction du fait que c'est un champ ou non
|
|
switch (tabPonctuel_i.Champ())
|
|
{ case 1: // c'est un champ de valeurs
|
|
force = (tabPonctuel_i.Vect_de_coordonnee(nn)); break;
|
|
case 2: // c'est un champ de fonctions
|
|
// pour l'instant, le seul cas est celui des fonctions du temps
|
|
// on récupère les courbes pour les dim composantes
|
|
{ switch (dima)
|
|
{ case 3 : {Courbe1D * pt_courbe_force_nn_3 =
|
|
lesCourbes1D->Trouve(tabPonctuel_i.Nom_vect(nn,3));
|
|
force(3) = pt_courbe_force_nn_3->Valeur(Temps_courant());
|
|
}
|
|
case 2 : {Courbe1D * pt_courbe_force_nn_2 =
|
|
lesCourbes1D->Trouve(tabPonctuel_i.Nom_vect(nn,2));
|
|
force(2) = pt_courbe_force_nn_2->Valeur(Temps_courant());
|
|
}
|
|
case 1 : {Courbe1D * pt_courbe_force_nn_1 =
|
|
lesCourbes1D->Trouve(tabPonctuel_i.Nom_vect(nn,1));
|
|
force(1) = pt_courbe_force_nn_1->Valeur(Temps_courant());
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
case 0: default:// ce n'est pas un champ
|
|
force = (tabPonctuel_i.Vect_de_coordonnee(1)); break;
|
|
};
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
// ou au point + grandeurs globales éventuelles
|
|
const string & nomF_charge = tabPonctuel_i.NomF_charge();
|
|
if(nomF_charge.length())
|
|
{Fonction_nD * pt_fonct = lesFonctionsnD->Trouve(nomF_charge);
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{ // on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{force *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : force(3) *= tava(3);
|
|
case 2 : force(2) *= tava(2);
|
|
case 1 : force(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des forces ponctuelles sur la ref: "<< tabPonctuel_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 et la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else if (pt_fonct->Depend_M() != 0) // signifie qu'il y a une dépendance au point M
|
|
{ if ((pt_fonct->Depend_M()<0) && pt_fonct->Nom_variables().Taille() == dima)
|
|
{ // on vérifie également qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
const Coordonnee& M_tdt = noe.Coord2();
|
|
// comme pt_fonct->Depend_M()<0, cela signifie que la fonction dépend que de M
|
|
// donc dans les paramètres d'appel on ne transmet que M
|
|
Tableau <Coordonnee> tab_M(1,M_tdt);
|
|
Tableau <double> & tava = pt_fonct->Val_FnD_Evoluee(NULL,&tab_M,NULL); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{force *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : force(3) *= tava(3);
|
|
case 2 : force(2) *= tava(2);
|
|
case 1 : force(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des forces ponctuelles sur la ref: "<< tabPonctuel_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 ou de la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else
|
|
{ if ((pt_fonct->Depend_M()>0)|| pt_fonct->Nom_variables().Taille() != dima)
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD utilisant les coordonnees du point"
|
|
<< " cas des forces ponctuelles sur la ref: "<< tabPonctuel_i.NomRef()
|
|
<< " actuellement la fonction doit avoir uniquement comme parametres, les coordonnees du point et eventuellement des variables globales ";
|
|
cout << "\n fonction nD: "; pt_fonct->Affiche();
|
|
Sortie(1);
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
if ((noe.Pointeur_assemblage(X1,cas_assemblage) != -1) && (noe.En_service(X1)) && (noe.UneVariable(X1)))
|
|
// les forces ponctuelles correspondent aux ddl X1 X2 ...
|
|
for (int di=1;di<= dima;di++)
|
|
{// maintenant deux cas: soit avec ou sans courbes de charge
|
|
int pt_adres = noe.Pointeur_assemblage(Enum_ddl(posi+di),cas_assemblage);
|
|
if(pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
// cas d'une grandeur fixe
|
|
{ vecglob (pt_adres) += coeff * (force(di));}
|
|
else // cas d'une fonction nD sans courbe
|
|
{ vecglob (pt_adres) += (force(di))* tabPonctuel_i.Echelle_courbe();}
|
|
}
|
|
else
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * tabPonctuel_i.Echelle_courbe();
|
|
vecglob (pt_adres) += coeff_charge * (force(di));
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
|
|
// $$$ --- cas des torseurs de forces ponctuelles --- $$$
|
|
|
|
// on parcours le tableau tabTorseurPonct
|
|
for (int i=1;i<= tabTorseurPonct.Taille();i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<PTorseurPonct> >& tabTorseurPonct_i = tabTorseurPonct(i);
|
|
const ReferenceNE & ref =
|
|
((ReferenceNE &) lesRef->Trouve(tabTorseurPonct_i.NomRef(),tabTorseurPonct_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge globale on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(tabTorseurPonct_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(tabTorseurPonct_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(tabTorseurPonct_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{int reftaille = ref.Taille();
|
|
int cas_assemblage = (assemb.Nb_cas_assemb()).n; // récup du cas d'assemblage
|
|
// on renseigne les positions des points où vont s'appliquer les forces équivalentes au torseur
|
|
Tableau < Coordonnee >& tab_P_i = tab_P(i); // pour simplier
|
|
Tableau < Coordonnee >& t_force_i = t_force(i); // idem
|
|
for (int nn =1; nn<= reftaille;nn++) // nn = position des num de noeud
|
|
{ Noeud & noe=lesMail->Noeud_LesMaille(ref.Nbmaille(),ref.Numero(nn));
|
|
tab_P_i(nn) = noe.Coord2();
|
|
};
|
|
// on calcul les efforts ponctuelles correspondant au torseur
|
|
tabTorseurPonct_i.Force(tab_P_i,t_force_i);
|
|
// maintenant on calcule l'action de chaque force ponctuelle
|
|
for (int nn =1; nn<= reftaille;nn++) // nn = position des num de noeud
|
|
{ Noeud & noe=lesMail->Noeud_LesMaille(ref.Nbmaille(),ref.Numero(nn));
|
|
Coordonnee& force = t_force_i(nn); // pour simplifier
|
|
// on regarde si jamais on a une dépendance globale à des grandeurs globales
|
|
// ou au point + grandeurs globales éventuelles
|
|
const string & nomF_charge = tabTorseurPonct_i.NomF_charge();
|
|
if(nomF_charge.length())
|
|
{Fonction_nD * pt_fonct = lesFonctionsnD->Trouve(nomF_charge);
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{ // on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{force *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : force(3) *= tava(3);
|
|
case 2 : force(2) *= tava(2);
|
|
case 1 : force(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des torseurs de forces ponctuelles sur la ref: "
|
|
<< tabTorseurPonct_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 et la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else if (pt_fonct->Depend_M() != 0) // signifie qu'il y a une dépendance au point M
|
|
{ if ((pt_fonct->Depend_M()<0) && pt_fonct->Nom_variables().Taille() == dima)
|
|
{ // on vérifie également qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
const Coordonnee& M_tdt = noe.Coord2();
|
|
// comme pt_fonct->Depend_M()<0, cela signifie que la fonction dépend que de M
|
|
// donc dans les paramètres d'appel on ne transmet que M
|
|
Tableau <Coordonnee> tab_M(1,M_tdt);
|
|
Tableau <double> & tava = pt_fonct->Val_FnD_Evoluee(NULL,&tab_M,NULL); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{force *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : force(3) *= tava(3);
|
|
case 2 : force(2) *= tava(2);
|
|
case 1 : force(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des torseurs de forces ponctuelles sur la ref: "
|
|
<< tabTorseurPonct_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 ou de la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else
|
|
{ if ((pt_fonct->Depend_M()>0)|| pt_fonct->Nom_variables().Taille() != dima)
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD utilisant les coordonnees du point"
|
|
<< " cas des forces ponctuelles sur la ref: "<< tabTorseurPonct_i.NomRef()
|
|
<< " actuellement la fonction doit avoir uniquement comme parametres, les coordonnees du point et eventuellement des variables globales ";
|
|
cout << "\n fonction nD: "; pt_fonct->Affiche();
|
|
Sortie(1);
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
if ((noe.Pointeur_assemblage(X1,cas_assemblage) != -1) && (noe.En_service(X1)) && (noe.UneVariable(X1)))
|
|
// les forces ponctuelles correspondent aux ddl X1 X2 ...
|
|
for (int di=1;di<= dima;di++)
|
|
{// maintenant deux cas: soit avec ou sans courbes de charge
|
|
int pt_adres = noe.Pointeur_assemblage(Enum_ddl(posi+di),cas_assemblage);
|
|
if(pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
// cas d'une grandeur fixe
|
|
{ vecglob (pt_adres) += coeff * (force(di));}
|
|
else // cas d'une fonction nD sans courbe
|
|
{ vecglob (pt_adres) += (force(di))* tabTorseurPonct_i.Echelle_courbe();}
|
|
}
|
|
else
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * tabTorseurPonct_i.Echelle_courbe();
|
|
vecglob (pt_adres) += coeff_charge * (force(di));
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
// --- cas des forces surfaciques ---$$$
|
|
int tabsurfactaille = tabFsurfac.Taille();
|
|
if ( tabsurfactaille != 0)
|
|
{// on parcours le tableau tabFsurfac dans le repère absolu
|
|
for (int i=1;i<= tabsurfactaille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<BlocForces> >& tabFsurfac_i = tabFsurfac(i);
|
|
const ReferenceAF & ref =
|
|
((ReferenceAF &) lesRef->Trouve(tabFsurfac_i.NomRef(),tabFsurfac_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(tabFsurfac_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(tabFsurfac_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(tabFsurfac_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments et les surfaces associes
|
|
Coordonnee vforce; // init par défaut
|
|
int nbref = ref.Taille();
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.NumeroElem(ns));
|
|
// récupération de la force de référence
|
|
// on traite en fonction du fait que c'est un champ ou non
|
|
switch (tabFsurfac_i.Champ())
|
|
{ case 1: // c'est un champ de valeurs
|
|
vforce = (tabFsurfac_i.Vect_de_coordonnee(ns)); break;
|
|
case 2: // c'est un champ de fonctions
|
|
// pour l'instant, le seul cas est celui des fonctions du temps
|
|
// on récupère les courbes pour les dim composantes
|
|
{ switch (dima)
|
|
{ case 3 : {Courbe1D * pt_courbe_force_ns_3 =
|
|
lesCourbes1D->Trouve(tabFsurfac_i.Nom_vect(ns,3));
|
|
vforce(3) = pt_courbe_force_ns_3->Valeur(Temps_courant());
|
|
}
|
|
case 2 : {Courbe1D * pt_courbe_force_ns_2 =
|
|
lesCourbes1D->Trouve(tabFsurfac_i.Nom_vect(ns,2));
|
|
vforce(2) = pt_courbe_force_ns_2->Valeur(Temps_courant());
|
|
}
|
|
case 1 : {Courbe1D * pt_courbe_force_ns_1 =
|
|
lesCourbes1D->Trouve(tabFsurfac_i.Nom_vect(ns,1));
|
|
vforce(1) = pt_courbe_force_ns_1->Valeur(Temps_courant());
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
case 0: default:// ce n'est pas un champ
|
|
vforce = (tabFsurfac_i.Vect_de_coordonnee(1)); break;
|
|
};
|
|
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
const string & nomF_charge = tabFsurfac_i.NomF_charge();
|
|
Fonction_nD * pt_fonct=NULL;
|
|
if(nomF_charge.length())
|
|
{pt_fonct = lesFonctionsnD->Trouve(tabFsurfac_i.NomF_charge());
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{// on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{vforce *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : vforce(3) *= tava(3);
|
|
case 2 : vforce(2) *= tava(2);
|
|
case 1 : vforce(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des forces surfaciques sur la ref: "<< tabFsurfac_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 et la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
// on désactive la fonction nD car elle a déjà été utilisée
|
|
pt_fonct = NULL;
|
|
};
|
|
};
|
|
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
if(pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
{ vforce *= coeff;} // cas d'une grandeur fixe
|
|
else // sinon il ne reste plus qu'à intégrer l'échelle
|
|
{ vforce *= tabFsurfac_i.Echelle_courbe();};
|
|
}
|
|
else //sinon c'est idem avec ou sans fonction nD car c'est déjà intégré
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * tabFsurfac_i.Echelle_courbe();
|
|
vforce *= coeff_charge;
|
|
};
|
|
// appel du calcul du second membre correspondant à la charge surfacique
|
|
// Coordonnee vforce = tabFsurfac_i.Coord() * coeff;
|
|
Vecteur SM = elem.SM_charge_surfacique_E_tdt(vforce,pt_fonct,ref.NumeroFA(ns),pa);
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à la face chargée
|
|
const ElFrontiere* elfront = NULL; // init
|
|
if (ParaGlob::AxiSymetrie())
|
|
// dans le cas axiSymétrique, les surfaces sont générées par les lignes,
|
|
{elfront = elem.Frontiere_lineique(ref.NumeroFA(ns));}
|
|
else // cas normale
|
|
{elfront = elem.Frontiere_surfacique(ref.NumeroFA(ns)); };// la surface frontière
|
|
assemb.AssemSM (vecglob,SM,elfront->DdlElem_const(),elfront->TabNoeud_const()); // assemblage
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
// --- cas des pressions ---$$$
|
|
int tabPresUniftaille = tabPresUnif.Taille();
|
|
if ( tabPresUniftaille != 0)
|
|
{// on parcours le tableau tabPresUnif
|
|
for (int i=1;i<= tabPresUniftaille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<BlocIntensite> >& tabPresUnif_i = tabPresUnif(i);
|
|
const ReferenceAF & ref =
|
|
((ReferenceAF &) lesRef->Trouve(tabPresUnif_i.NomRef(),tabPresUnif_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(tabPresUnif_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(tabPresUnif_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(tabPresUnif_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments et les surfaces associes
|
|
int nbref = ref.Taille();
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.NumeroElem(ns));
|
|
double press_ac = 0.; // init
|
|
// récupération de la pression de référence
|
|
// on traite en fonction du fait que c'est un champ ou non
|
|
switch (tabPresUnif_i.Champ())
|
|
{ case 1: // c'est un champ de valeurs
|
|
press_ac = (tabPresUnif_i.Val(ns)); break;
|
|
case 2: // c'est un champ de fonctions
|
|
// pour l'instant, le seul cas est celui des fonctions du temps
|
|
{ Courbe1D * pt_courbe_force_ns =
|
|
lesCourbes1D->Trouve(tabPresUnif_i.Nom_val(ns));
|
|
press_ac = pt_courbe_force_ns->Valeur(Temps_courant());
|
|
break;
|
|
}
|
|
case 0: default:// ce n'est pas un champ
|
|
press_ac = (tabPresUnif_i.Val(1)); break;
|
|
};
|
|
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
const string & nomF_charge = tabPresUnif_i.NomF_charge();
|
|
Fonction_nD * pt_fonct = NULL;
|
|
if(nomF_charge.length())
|
|
{pt_fonct = lesFonctionsnD->Trouve(tabPresUnif_i.NomF_charge());
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{// on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{press_ac *= tava(1);}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas de pression sur la ref: "<< tabPresUnif_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
// on désactive la fonction nD car elle a déjà été utilisée
|
|
pt_fonct = NULL;
|
|
};
|
|
};
|
|
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
if(pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
{ press_ac *= coeff;} // cas d'une grandeur fixe
|
|
else // sinon il ne reste plus qu'à intégrer l'échelle
|
|
{ press_ac *= tabPresUnif_i.Echelle_courbe();};
|
|
}
|
|
else //sinon c'est idem avec ou sans fonction nD car c'est déjà intégré
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * tabPresUnif_i.Echelle_courbe();
|
|
press_ac *= coeff_charge;
|
|
};
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
// double press_ac = (tabPresUnif_i.Val()) * coeff;
|
|
Vecteur SM = elem.SM_charge_pression_E_tdt(press_ac,pt_fonct,ref.NumeroFA(ns),pa);
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à la face chargée
|
|
const ElFrontiere* elfront = NULL; // init
|
|
if (ParaGlob::AxiSymetrie())
|
|
// dans le cas axiSymétrique, les surfaces sont générées par les lignes,
|
|
{elfront = elem.Frontiere_lineique(ref.NumeroFA(ns));}
|
|
else // cas normale
|
|
{elfront = elem.Frontiere_surfacique(ref.NumeroFA(ns)); };// la surface frontière
|
|
assemb.AssemSM (vecglob,SM,elfront->DdlElem_const(),elfront->TabNoeud_const()); // assemblage
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
// --- cas des pression unidirectionnelle ---
|
|
// c'est-à-dire des forces qui sont appliquée sur la surface en gardant la même
|
|
// direction localement pendant toute la transformation
|
|
int PresUniDirtaille = PresUniDir.Taille();
|
|
if ( PresUniDirtaille != 0)
|
|
{// on parcours le tableau PresUniDir
|
|
for (int i=1;i<= PresUniDirtaille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<BlocForces> >& PresUniDir_i = PresUniDir(i);
|
|
const ReferenceAF & ref =
|
|
((ReferenceAF &) lesRef->Trouve(PresUniDir_i.NomRef(),PresUniDir_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(PresUniDir_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(PresUniDir_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(PresUniDir_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments et les surfaces associes
|
|
int nbref = ref.Taille();
|
|
Coordonnee press_uni; // init par défaut
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.NumeroElem(ns));
|
|
// récupération de la force de référence
|
|
// on traite en fonction du fait que c'est un champ ou non
|
|
switch (PresUniDir_i.Champ())
|
|
{ case 1: // c'est un champ de valeurs
|
|
press_uni = (PresUniDir_i.Vect_de_coordonnee(ns)); break;
|
|
case 2: // c'est un champ de fonctions
|
|
// pour l'instant, le seul cas est celui des fonctions du temps
|
|
// on récupère les courbes pour les dim composantes
|
|
{ switch (dima)
|
|
{ case 3 : {Courbe1D * pt_courbe_force_ns_3 =
|
|
lesCourbes1D->Trouve(PresUniDir_i.Nom_vect(ns,3));
|
|
press_uni(3) = pt_courbe_force_ns_3->Valeur(Temps_courant());
|
|
}
|
|
case 2 : {Courbe1D * pt_courbe_force_ns_2 =
|
|
lesCourbes1D->Trouve(PresUniDir_i.Nom_vect(ns,2));
|
|
press_uni(2) = pt_courbe_force_ns_2->Valeur(Temps_courant());
|
|
}
|
|
case 1 : {Courbe1D * pt_courbe_force_ns_1 =
|
|
lesCourbes1D->Trouve(PresUniDir_i.Nom_vect(ns,1));
|
|
press_uni(1) = pt_courbe_force_ns_1->Valeur(Temps_courant());
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
case 0: default:// ce n'est pas un champ
|
|
press_uni = (PresUniDir_i.Vect_de_coordonnee(1)); break;
|
|
};
|
|
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
const string & nomF_charge = PresUniDir_i.NomF_charge();
|
|
Fonction_nD * pt_fonct=NULL;
|
|
if(nomF_charge.length())
|
|
{pt_fonct = lesFonctionsnD->Trouve(PresUniDir_i.NomF_charge());
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{// on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{press_uni *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : press_uni(3) *= tava(3);
|
|
case 2 : press_uni(2) *= tava(2);
|
|
case 1 : press_uni(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des des pression unidirectionnelle sur la ref: "<< PresUniDir_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 et la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
// on désactive la fonction nD car elle a déjà été utilisée
|
|
pt_fonct = NULL;
|
|
};
|
|
};
|
|
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
if(pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
{ press_uni *= coeff;} // cas d'une grandeur fixe
|
|
else // sinon il ne reste plus qu'à intégrer l'échelle
|
|
{ press_uni *= PresUniDir_i.Echelle_courbe();};
|
|
}
|
|
else //sinon c'est idem avec ou sans fonction nD car c'est déjà intégré
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * PresUniDir_i.Echelle_courbe();
|
|
press_uni *= coeff_charge;
|
|
};
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
// Coordonnee press_uni = (PresUniDir_i.Coord()) * coeff;
|
|
Vecteur SM = elem.SM_charge_presUniDir_E_tdt(press_uni,pt_fonct,ref.NumeroFA(ns),pa);
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à la face chargée
|
|
const ElFrontiere* elfront = NULL; // init
|
|
if (ParaGlob::AxiSymetrie())
|
|
// dans le cas axiSymétrique, les surfaces sont générées par les lignes,
|
|
{elfront = elem.Frontiere_lineique(ref.NumeroFA(ns));}
|
|
else // cas normale
|
|
{elfront = elem.Frontiere_surfacique(ref.NumeroFA(ns)); };// la surface frontière
|
|
assemb.AssemSM (vecglob,SM,elfront->DdlElem_const(),elfront->TabNoeud_const()); // assemblage
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
// --- cas des forces lineique ---$$$
|
|
int tablineiquetaille = tabFlineique.Taille();
|
|
if ( tablineiquetaille != 0)
|
|
{// on parcours le tableau tabFlineique dans le repère absolu
|
|
for (int i=1;i<= tablineiquetaille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<BlocForces> >& tabFlineique_i = tabFlineique(i);
|
|
const ReferenceAF & ref =
|
|
((ReferenceAF &) lesRef->Trouve(tabFlineique_i.NomRef(),tabFlineique_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(tabFlineique_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(tabFlineique_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(tabFlineique_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments et les aretes associes
|
|
int nbref = ref.Taille();
|
|
Coordonnee f_lin; // init par défaut
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.NumeroElem(ns));
|
|
// récupération de la force de référence
|
|
// on traite en fonction du fait que c'est un champ ou non
|
|
switch (tabFlineique_i.Champ())
|
|
{ case 1: // c'est un champ de valeurs
|
|
f_lin = (tabFlineique_i.Vect_de_coordonnee(ns)); break;
|
|
case 2: // c'est un champ de fonctions
|
|
// pour l'instant, le seul cas est celui des fonctions du temps
|
|
// on récupère les courbes pour les dim composantes
|
|
{ switch (dima)
|
|
{ case 3 : {Courbe1D * pt_courbe_force_ns_3 =
|
|
lesCourbes1D->Trouve(tabFlineique_i.Nom_vect(ns,3));
|
|
f_lin(3) = pt_courbe_force_ns_3->Valeur(Temps_courant());
|
|
}
|
|
case 2 : {Courbe1D * pt_courbe_force_ns_2 =
|
|
lesCourbes1D->Trouve(tabFlineique_i.Nom_vect(ns,2));
|
|
f_lin(2) = pt_courbe_force_ns_2->Valeur(Temps_courant());
|
|
}
|
|
case 1 : {Courbe1D * pt_courbe_force_ns_1 =
|
|
lesCourbes1D->Trouve(tabFlineique_i.Nom_vect(ns,1));
|
|
f_lin(1) = pt_courbe_force_ns_1->Valeur(Temps_courant());
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
case 0: default:// ce n'est pas un champ
|
|
f_lin = (tabFlineique_i.Vect_de_coordonnee(1)); break;
|
|
};
|
|
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
const string & nomF_charge = tabFlineique_i.NomF_charge();
|
|
Fonction_nD * pt_fonct = NULL;
|
|
if(nomF_charge.length())
|
|
{pt_fonct = lesFonctionsnD->Trouve(tabFlineique_i.NomF_charge());
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{// on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{f_lin *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : f_lin(3) *= tava(3);
|
|
case 2 : f_lin(2) *= tava(2);
|
|
case 1 : f_lin(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des des forces lineiques sur la ref: "<< tabFlineique_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 et la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
// on désactive la fonction nD car elle a déjà été utilisée
|
|
pt_fonct = NULL;
|
|
};
|
|
};
|
|
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
if(pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
{ f_lin *= coeff;} // cas d'une grandeur fixe
|
|
else // sinon il ne reste plus qu'à intégrer l'échelle
|
|
{ f_lin *= tabFlineique_i.Echelle_courbe();};
|
|
}
|
|
else //sinon c'est idem avec ou sans fonction nD car c'est déjà intégré
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * tabFlineique_i.Echelle_courbe();
|
|
f_lin *= coeff_charge;
|
|
};
|
|
// appel du calcul du second membre correspondant à la charge lineique
|
|
// Vecteur f_lin = (tabFlineique_i.Coord()) * coeff ;
|
|
Vecteur SM = elem.SM_charge_lineique_E_tdt(f_lin,pt_fonct,ref.NumeroFA(ns),pa);
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à la ligne chargée
|
|
const ElFrontiere* elfront = elem.Frontiere_lineique(ref.NumeroFA(ns)); // l'arete frontière
|
|
assemb.AssemSM (vecglob,SM,elfront->DdlElem_const(),elfront->TabNoeud_const()); // assemblage
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
// --- cas des forces lineiques suiveuses ---$$$
|
|
int tablineiqueSuivtaille = tabFlineiqueSuiv.Taille();
|
|
if ( tablineiqueSuivtaille != 0)
|
|
{// on parcours le tableau tabFlineiqueSuiv des forces exprimées dans le repère global
|
|
for (int i=1;i<= tablineiqueSuivtaille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<BlocForces> > & tabFlineiqueSuiv_i = tabFlineiqueSuiv(i);
|
|
const ReferenceAF & ref =
|
|
((ReferenceAF &) lesRef->Trouve(tabFlineiqueSuiv_i.NomRef(),tabFlineiqueSuiv_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(tabFlineiqueSuiv_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(tabFlineiqueSuiv_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(tabFlineiqueSuiv_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments et les aretes associes
|
|
int nbref = ref.Taille();
|
|
Coordonnee f_lin; // init par défaut
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.NumeroElem(ns));
|
|
// récupération de la force de référence
|
|
// on traite en fonction du fait que c'est un champ ou non
|
|
switch (tabFlineiqueSuiv_i.Champ())
|
|
{ case 1: // c'est un champ de valeurs
|
|
f_lin = (tabFlineiqueSuiv_i.Vect_de_coordonnee(ns)); break;
|
|
case 2: // c'est un champ de fonctions
|
|
// pour l'instant, le seul cas est celui des fonctions du temps
|
|
// on récupère les courbes pour les dim composantes
|
|
{ switch (dima)
|
|
{ case 3 : {Courbe1D * pt_courbe_force_ns_3 =
|
|
lesCourbes1D->Trouve(tabFlineiqueSuiv_i.Nom_vect(ns,3));
|
|
f_lin(3) = pt_courbe_force_ns_3->Valeur(Temps_courant());
|
|
}
|
|
case 2 : {Courbe1D * pt_courbe_force_ns_2 =
|
|
lesCourbes1D->Trouve(tabFlineiqueSuiv_i.Nom_vect(ns,2));
|
|
f_lin(2) = pt_courbe_force_ns_2->Valeur(Temps_courant());
|
|
}
|
|
case 1 : {Courbe1D * pt_courbe_force_ns_1 =
|
|
lesCourbes1D->Trouve(tabFlineiqueSuiv_i.Nom_vect(ns,1));
|
|
f_lin(1) = pt_courbe_force_ns_1->Valeur(Temps_courant());
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
case 0: default:// ce n'est pas un champ
|
|
f_lin = (tabFlineiqueSuiv_i.Vect_de_coordonnee(1)); break;
|
|
};
|
|
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
const string & nomF_charge = tabFlineiqueSuiv_i.NomF_charge();
|
|
Fonction_nD * pt_fonct = NULL;
|
|
if(nomF_charge.length())
|
|
{pt_fonct = lesFonctionsnD->Trouve(tabFlineiqueSuiv_i.NomF_charge());
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{// on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{f_lin *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : f_lin(3) *= tava(3);
|
|
case 2 : f_lin(2) *= tava(2);
|
|
case 1 : f_lin(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des des forces lineiques suiveuses sur la ref: "<< tabFlineiqueSuiv_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 et la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
// on désactive la fonction nD car elle a déjà été utilisée
|
|
pt_fonct = NULL;
|
|
};
|
|
};
|
|
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
if(pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
{ f_lin *= coeff;} // cas d'une grandeur fixe
|
|
else // sinon il ne reste plus qu'à intégrer l'échelle
|
|
{ f_lin *= tabFlineiqueSuiv_i.Echelle_courbe();};
|
|
}
|
|
else //sinon c'est idem avec ou sans fonction nD car c'est déjà intégré
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * tabFlineiqueSuiv_i.Echelle_courbe();
|
|
f_lin *= coeff_charge;
|
|
}
|
|
// appel du calcul du second membre correspondant à la charge lineique
|
|
// Vecteur f_lin = (tabFlineiqueSuiv_i.Coord()) * coeff ;
|
|
Vecteur SM = elem.SM_charge_lineique_Suiv_E_tdt(f_lin,pt_fonct,ref.NumeroFA(ns),pa);
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à la ligne chargée
|
|
const ElFrontiere* elfront = elem.Frontiere_lineique(ref.NumeroFA(ns)); // l'arete frontière
|
|
assemb.AssemSM (vecglob,SM,elfront->DdlElem_const(),elfront->TabNoeud_const()); // assemblage
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
// --- cas des forces volumiques ---$$$
|
|
int tabvoltaille = tabFvol.Taille();
|
|
if ( tabvoltaille != 0)
|
|
{// on parcours le tableau tabFvol dans le repère absolu
|
|
for (int i=1;i<= tabvoltaille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<BlocForces> >& tabFvol_i = tabFvol(i);
|
|
const ReferenceNE & ref =
|
|
((ReferenceNE &) lesRef->Trouve(tabFvol_i.NomRef(),tabFvol_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(tabFvol_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(tabFvol_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(tabFvol_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments
|
|
int nbref = ref.Taille();
|
|
Coordonnee f_vol; // init par défaut
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.Numero(ns));
|
|
// récupération de la force de référence
|
|
// on traite en fonction du fait que c'est un champ ou non
|
|
switch (tabFvol_i.Champ())
|
|
{ case 1: // c'est un champ de valeurs
|
|
f_vol = (tabFvol_i.Vect_de_coordonnee(ns)); break;
|
|
case 2: // c'est un champ de fonctions
|
|
// pour l'instant, le seul cas est celui des fonctions du temps
|
|
// on récupère les courbes pour les dim composantes
|
|
{ switch (dima)
|
|
{ case 3 : {Courbe1D * pt_courbe_force_ns_3 =
|
|
lesCourbes1D->Trouve(tabFvol_i.Nom_vect(ns,3));
|
|
f_vol(3) = pt_courbe_force_ns_3->Valeur(Temps_courant());
|
|
}
|
|
case 2 : {Courbe1D * pt_courbe_force_ns_2 =
|
|
lesCourbes1D->Trouve(tabFvol_i.Nom_vect(ns,2));
|
|
f_vol(2) = pt_courbe_force_ns_2->Valeur(Temps_courant());
|
|
}
|
|
case 1 : {Courbe1D * pt_courbe_force_ns_1 =
|
|
lesCourbes1D->Trouve(tabFvol_i.Nom_vect(ns,1));
|
|
f_vol(1) = pt_courbe_force_ns_1->Valeur(Temps_courant());
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
case 0: default:// ce n'est pas un champ
|
|
f_vol = (tabFvol_i.Vect_de_coordonnee(1)); break;
|
|
};
|
|
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
const string & nomF_charge = tabFvol_i.NomF_charge();
|
|
Fonction_nD * pt_fonct = NULL;
|
|
if(nomF_charge.length())
|
|
{pt_fonct = lesFonctionsnD->Trouve(tabFvol_i.NomF_charge());
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{// on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{f_vol *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : f_vol(3) *= tava(3);
|
|
case 2 : f_vol(2) *= tava(2);
|
|
case 1 : f_vol(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des des forces lineiques sur la ref: "<< tabFvol_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 et la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
// on désactive la fonction nD car elle a déjà été utilisée
|
|
pt_fonct = NULL;
|
|
};
|
|
};
|
|
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
if(pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
{ f_vol *= coeff;} // cas d'une grandeur fixe
|
|
else // sinon il ne reste plus qu'à intégrer l'échelle
|
|
{ f_vol *= tabFvol_i.Echelle_courbe();};
|
|
}
|
|
else //sinon c'est idem avec ou sans fonction nD car c'est déjà intégré
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * tabFvol_i.Echelle_courbe();
|
|
f_vol *= coeff_charge;
|
|
};
|
|
// on indique si éventuellement on veut se référer au volume initial
|
|
bool volume_finale = !(tabFvol_i.Attribut() == "sur_volume_initial_");
|
|
// appel du calcul du second membre correspondant à la charge volumique
|
|
// Vecteur f_vol = (tabFvol_i.Coord()) * coeff;
|
|
Vecteur SM = elem.SM_charge_volumique_E_tdt(f_vol,pt_fonct,pa,volume_finale);
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à l'élément
|
|
assemb.AssemSM (vecglob,SM,elem.TableauDdl(),elem.Tab_noeud()); // assemblage
|
|
};
|
|
};
|
|
}
|
|
}
|
|
|
|
// --- cas des des pressions hydrostatiques ---$$$
|
|
int PresHydrotaille = PresHydro.Taille();
|
|
if ( PresHydrotaille != 0)
|
|
{// on parcours le tableau PresHydro
|
|
for (int i=1;i<= PresHydrotaille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<PHydro> > & PresHydro_i = PresHydro(i);
|
|
const ReferenceAF & ref =
|
|
((ReferenceAF &) lesRef->Trouve(PresHydro_i.NomRef(),PresHydro_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(PresHydro_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(PresHydro_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(PresHydro_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments et les surfaces associes
|
|
int nbref = ref.Taille();
|
|
// on récupère le vecteur normal et le point de la surface libre
|
|
const Coordonnee& N = PresHydro_i.Direction_N(); // récup de la direction N normée
|
|
const Coordonnee& A = PresHydro_i.Point_M(); // récup du point de la surface libre
|
|
double p_hydro_ref = (PresHydro_i.Val(1));
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.NumeroElem(ns));
|
|
double p_hydro = p_hydro_ref;
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
if(pt_courbe == NULL)
|
|
{ p_hydro *= coeff;} // cas d'une grandeur fixe
|
|
else
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * PresHydro_i.Echelle_courbe();
|
|
p_hydro *= coeff_charge;
|
|
}
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
bool sans_limitation=false;
|
|
if (PresHydro_i.Attribut() == "sans_limitation_") sans_limitation= true;
|
|
Vecteur SM = elem.SM_charge_hydrostatique_E_tdt
|
|
(N,p_hydro,ref.NumeroFA(ns),A,pa,sans_limitation) ;
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à la face chargée
|
|
const ElFrontiere* elfront = NULL; // init
|
|
if (ParaGlob::AxiSymetrie())
|
|
// dans le cas axiSymétrique, les surfaces sont générées par les lignes,
|
|
{elfront = elem.Frontiere_lineique(ref.NumeroFA(ns));}
|
|
else // cas normale
|
|
{elfront = elem.Frontiere_surfacique(ref.NumeroFA(ns)); };// la surface frontière
|
|
assemb.AssemSM (vecglob,SM,elfront->DdlElem_const(),elfront->TabNoeud_const()); // assemblage
|
|
}
|
|
};
|
|
}
|
|
};
|
|
|
|
// --- cas des des efforts hydrodynamiques ---$$$
|
|
int coefHydroDynataille = coefHydroDyna.Taille();
|
|
if ( coefHydroDynataille != 0)
|
|
{// on parcours le tableau coefHydroDyna
|
|
for (int i=1;i<= coefHydroDynataille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<PHydrodyna> > & coefHydroDyna_i = coefHydroDyna(i);
|
|
const ReferenceAF & ref =
|
|
((ReferenceAF &) lesRef->Trouve(coefHydroDyna_i.NomRef(),coefHydroDyna_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(coefHydroDyna_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(coefHydroDyna_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(coefHydroDyna_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments et les noeuds ou arretes ou surfaces associes suivant la dimension
|
|
int nbref = ref.Taille();
|
|
// récup du poids volumique poids volumique = ro * g, qui n'est pas soumis à la courbe de charge
|
|
double poidvol = (coefHydroDyna_i.Val(1));
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.NumeroElem(ns));
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
double coeff_charge=1.;
|
|
if(pt_courbe != NULL)
|
|
{ coeff_charge = (pt_courbe->Valeur(Temps_courant())) * coefHydroDyna_i.Echelle_courbe();};
|
|
// appel du calcul du second membre correspondant aux efforts hydrodynamique
|
|
Vecteur SM = elem.SM_charge_hydrodynamique_E_tdt(coefHydroDyna_i.Frot_fluid(),poidvol
|
|
,coefHydroDyna_i.Coef_aero_n(),ref.NumeroFA(ns),coeff_charge
|
|
,coefHydroDyna_i.Coef_aero_t(),pa) ;
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à la face chargée
|
|
const ElFrontiere* elfront;
|
|
switch (ParaGlob::Dimension())
|
|
{ case 3: {elfront = elem.Frontiere_surfacique(ref.NumeroFA(ns)); break;};// la surface frontière
|
|
case 2: {elfront = elem.Frontiere_lineique(ref.NumeroFA(ns)); break;};// la ligne frontière
|
|
case 1: {elfront = elem.Frontiere_points(ref.NumeroFA(ns)); break;};// le point frontière
|
|
};
|
|
assemb.AssemSM (vecglob,SM,elfront->DdlElem_const(),elfront->TabNoeud_const()); // assemblage
|
|
};
|
|
};
|
|
};
|
|
}; //-- fin de hydrodyna
|
|
|
|
// affichage éventuelle du second membre
|
|
if (ParaGlob::NiveauImpression() >= 10)
|
|
{ string entete = " affichage du second membre apres chargement";
|
|
vecglob.Affichage_ecran(entete);
|
|
};
|
|
}
|
|
catch (ErrSortieFinale)
|
|
// cas d'une direction voulue vers la sortie
|
|
// on relance l'interuption pour le niveau supérieur
|
|
{ ErrSortieFinale toto;
|
|
throw (toto);
|
|
}
|
|
catch ( ... )
|
|
{ if (ParaGlob::NiveauImpression() >= 1)
|
|
{cout << "\n\n ****!!** erreur dans le calcul du chargement impose ***";
|
|
if (ParaGlob::NiveauImpression() >= 4)
|
|
cout << "\n Charge::ChargeSecondMembre_Ex_mecaSolid(..";
|
|
cout << flush;
|
|
};
|
|
retour = false;
|
|
};
|
|
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
return retour;
|
|
};
|
|
|
|
|
|
// cas implicite avec également modification de la raideur quand le chargement dépend
|
|
// de la géométrie, en fonction des paramètres de pa
|
|
// la variable relative à la classe assemblage est passé en argument ce qui permet d'utiliser
|
|
// éventuellement plusieurs type d'assemblage
|
|
// de plus il faut prévoir un pointeur d'assemblage pour séparer le cas d'assemblage symétrique ou non
|
|
// d'où la variable pointeur de fonction membre d'assemblage
|
|
// retour false si problème de calcul
|
|
bool Charge::ChargeSMembreRaideur_Im_mecaSolid
|
|
(Assemblage & assemb,LesMaillages * lesMail,LesReferences* lesRef
|
|
,Vecteur& vecglob, Mat_abstraite& matglob
|
|
,void (Assemblage::* assembMat) // le pointeur de fonction
|
|
(Mat_abstraite & matglob,const Mat_abstraite & matloc,
|
|
const DdlElement& tab_ddl,const Tableau<Noeud *>&tab_noeud)
|
|
,const ParaAlgoControle & pa
|
|
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD)
|
|
{
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
bool retour = true; // init par défaut
|
|
try
|
|
{// pour tous les maillages, pour tous les éléments on effectue une initialisation éventuelle
|
|
int nb_mail = lesMail->NbMaillage();
|
|
for (int imail = 1;imail<=nb_mail;imail++)
|
|
{ int nb_ele = lesMail->Nombre_element(imail);
|
|
for (int iele =1;iele<=nb_ele;iele++)
|
|
lesMail->Element_LesMaille(imail,iele).Initialisation_avant_chargement();
|
|
};
|
|
|
|
// récup
|
|
bool avec_raid = pa.Var_charge_externe();
|
|
int cas_assemblage = (assemb.Nb_cas_assemb()).n; // récup du cas d'assemblage
|
|
int posi = Id_nom_ddl("X1") -1;
|
|
int dim = ParaGlob::Dimension();
|
|
|
|
// $$$--- cas des forces ponctuelles ---$$$
|
|
// on regarde si l'espace de travail est axi-symétrique, si oui on utilise une dimension réduite
|
|
int dima=dim; // c'est dima qui est utiliser pour la mise en place des efforts ponctuelles
|
|
if (ParaGlob::AxiSymetrie()) dima--;
|
|
// on parcours le tableau tabPonctuel
|
|
// ici il n'y a pas d'implication sur la raideur
|
|
for (int i=1;i<= tabPonctuel.Taille();i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<BlocForces> >& tabPonctuel_i = tabPonctuel(i);
|
|
//tabPonctuel_i.Affiche();cout << endl;
|
|
const ReferenceNE & ref =
|
|
((ReferenceNE &) lesRef->Trouve(tabPonctuel_i.NomRef(),tabPonctuel_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(tabPonctuel_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(tabPonctuel_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(tabPonctuel_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{int reftaille = ref.Taille();
|
|
for (int nn =1; nn<= reftaille;nn++) // nn = position des num de noeud
|
|
{ Noeud & noe=lesMail->Noeud_LesMaille(ref.Nbmaille(),ref.Numero(nn));
|
|
Coordonnee force; // init
|
|
// on traite en fonction du fait que c'est un champ ou non
|
|
switch (tabPonctuel_i.Champ())
|
|
{ case 1: // c'est un champ de valeurs
|
|
force = (tabPonctuel_i.Vect_de_coordonnee(nn)); break;
|
|
case 2: // c'est un champ de fonctions
|
|
// pour l'instant, le seul cas est celui des fonctions du temps
|
|
// on récupère les courbes pour les dim composantes
|
|
{ switch (dima)
|
|
{ case 3 : {Courbe1D * pt_courbe_force_nn_3 =
|
|
lesCourbes1D->Trouve(tabPonctuel_i.Nom_vect(nn,3));
|
|
force(3) = pt_courbe_force_nn_3->Valeur(Temps_courant());
|
|
}
|
|
case 2 : {Courbe1D * pt_courbe_force_nn_2 =
|
|
lesCourbes1D->Trouve(tabPonctuel_i.Nom_vect(nn,2));
|
|
force(2) = pt_courbe_force_nn_2->Valeur(Temps_courant());
|
|
}
|
|
case 1 : {Courbe1D * pt_courbe_force_nn_1 =
|
|
lesCourbes1D->Trouve(tabPonctuel_i.Nom_vect(nn,1));
|
|
force(1) = pt_courbe_force_nn_1->Valeur(Temps_courant());
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
case 0: default:// ce n'est pas un champ
|
|
force = (tabPonctuel_i.Vect_de_coordonnee(1)); break;
|
|
};
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
const string & nomF_charge = tabPonctuel_i.NomF_charge();
|
|
Fonction_nD * pt_fonct = NULL;
|
|
if(nomF_charge.length())
|
|
{pt_fonct = lesFonctionsnD->Trouve(nomF_charge);
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{ // on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{force *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : force(3) *= tava(3);
|
|
case 2 : force(2) *= tava(2);
|
|
case 1 : force(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des forces ponctuelles sur la ref: "<< tabPonctuel_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 et la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else if (pt_fonct->Depend_M() != 0) // signifie qu'il y a une dépendance au point M
|
|
{ if ((pt_fonct->Depend_M()<0) && pt_fonct->Nom_variables().Taille() == dima)
|
|
{ // on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
const Coordonnee& M_tdt = noe.Coord2();
|
|
Tableau <Coordonnee> tab_M(1,M_tdt);
|
|
Tableau <double> & tava = pt_fonct->Val_FnD_Evoluee(NULL,&tab_M,NULL); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{force *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : force(3) *= tava(3);
|
|
case 2 : force(2) *= tava(2);
|
|
case 1 : force(1) *= tava(1);
|
|
////----- debug ---
|
|
//cout << "\n debug Charge::ChargeSMembreRaideur_Im_mecaSolid ** ";
|
|
//cout << "\n tava= " << tava << endl;
|
|
//
|
|
////--- fin debug ---
|
|
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des forces ponctuelles sur la ref: "<< tabPonctuel_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 ou de la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else
|
|
{ if ((pt_fonct->Depend_M()>0)|| pt_fonct->Nom_variables().Taille() != dima)
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD utilisant les coordonnees du point"
|
|
<< " cas des forces ponctuelles sur la ref: "<< tabPonctuel_i.NomRef()
|
|
<< " actuellement la fonction doit avoir uniquement comme parametres, les coordonnees du point et eventuellement des variables globales ";
|
|
cout << "\n fonction nD: "; pt_fonct->Affiche();
|
|
Sortie(1);
|
|
};
|
|
};
|
|
};
|
|
};
|
|
// les efforts s'appliques sur les ddl de position, il faut donc que X1 soit actif
|
|
// pour le cas d'assemblage considéré et en activité
|
|
if ((noe.Pointeur_assemblage(X1,cas_assemblage) != -1) && (noe.En_service(X1))
|
|
&& (noe.UneVariable(X1)))
|
|
// les forces ponctuelles correspondent aux ddl 1 2 ...
|
|
for (int di=1;di<= dima;di++)
|
|
{// maintenant deux cas: soit avec ou sans courbes de charge
|
|
int pt_adres = noe.Pointeur_assemblage(Enum_ddl(posi+di),cas_assemblage);
|
|
if (pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
// cas d'une grandeur fixe
|
|
{ vecglob (pt_adres) += coeff * (force(di));}
|
|
else // cas d'une fonction nD sans courbe
|
|
{ vecglob (pt_adres) += (force(di))* tabPonctuel_i.Echelle_courbe();}
|
|
}
|
|
else // cas avec courbe, avec ou sans fonction c'est pareil
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * tabPonctuel_i.Echelle_courbe();
|
|
vecglob (pt_adres) += coeff_charge * (force(di));
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
|
|
// $$$--- cas des torseurs de forces ponctuelles ---$$$
|
|
for (int i=1;i<= tabTorseurPonct.Taille();i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<PTorseurPonct> >& tabTorseurPonct_i = tabTorseurPonct(i);
|
|
//tabTorseurPonct_i.Affiche();cout << endl;
|
|
const ReferenceNE & ref =
|
|
((ReferenceNE &) lesRef->Trouve(tabTorseurPonct_i.NomRef(),tabTorseurPonct_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(tabTorseurPonct_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(tabTorseurPonct_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(tabTorseurPonct_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{int reftaille = ref.Taille();
|
|
// on renseigne les positions des points où vont s'appliquer les forces équivalentes au torseur
|
|
Tableau < Coordonnee >& tab_P_i = tab_P(i); // pour simplier
|
|
Tableau < Coordonnee >& t_force_i = t_force(i); // idem
|
|
for (int nn =1; nn<= reftaille;nn++) // nn = position des num de noeud
|
|
{ Noeud & noe=lesMail->Noeud_LesMaille(ref.Nbmaille(),ref.Numero(nn));
|
|
tab_P_i(nn) = noe.Coord2();
|
|
};
|
|
// on calcul les efforts ponctuelles correspondant au torseur
|
|
tabTorseurPonct_i.Force(tab_P_i,t_force_i);
|
|
// maintenant on calcule l'action de chaque force ponctuelle
|
|
for (int nn =1; nn<= reftaille;nn++) // nn = position des num de noeud
|
|
{ Noeud & noe=lesMail->Noeud_LesMaille(ref.Nbmaille(),ref.Numero(nn));
|
|
Coordonnee& force = t_force_i(nn); // pour simplifier
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
const string & nomF_charge = tabTorseurPonct_i.NomF_charge();
|
|
Fonction_nD * pt_fonct = NULL;
|
|
if(nomF_charge.length())
|
|
{pt_fonct = lesFonctionsnD->Trouve(nomF_charge);
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{ // on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{force *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : force(3) *= tava(3);
|
|
case 2 : force(2) *= tava(2);
|
|
case 1 : force(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des torseurs de forces ponctuelles sur la ref: "<< tabTorseurPonct_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 et la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else if (pt_fonct->Depend_M() != 0) // signifie qu'il y a une dépendance au point M
|
|
{ if ((pt_fonct->Depend_M()<0) && pt_fonct->Nom_variables().Taille() == dima)
|
|
{ // on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
const Coordonnee& M_tdt = noe.Coord2();
|
|
Tableau <Coordonnee> tab_M(1,M_tdt);
|
|
Tableau <double> & tava = pt_fonct->Val_FnD_Evoluee(NULL,&tab_M,NULL); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{force *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : force(3) *= tava(3);
|
|
case 2 : force(2) *= tava(2);
|
|
case 1 : force(1) *= tava(1);
|
|
////----- debug ---
|
|
//cout << "\n debug Charge::ChargeSMembreRaideur_Im_mecaSolid ** ";
|
|
//cout << "\n tava= " << tava << endl;
|
|
//
|
|
////--- fin debug ---
|
|
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des torseurs de forces ponctuelles sur la ref: "<< tabTorseurPonct_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 ou de la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
}
|
|
else
|
|
{ if ((pt_fonct->Depend_M()>0)|| pt_fonct->Nom_variables().Taille() != dima)
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD utilisant les coordonnees du point"
|
|
<< " cas des des torseurs de ponctuelles sur la ref: "<< tabTorseurPonct_i.NomRef()
|
|
<< " actuellement la fonction doit avoir uniquement comme parametres, les coordonnees du point et eventuellement des variables globales ";
|
|
cout << "\n fonction nD: "; pt_fonct->Affiche();
|
|
Sortie(1);
|
|
};
|
|
};
|
|
};
|
|
};
|
|
// les efforts s'appliques sur les ddl de position, il faut donc que X1 soit actif
|
|
// pour le cas d'assemblage considéré et en activité
|
|
if ((noe.Pointeur_assemblage(X1,cas_assemblage) != -1) && (noe.En_service(X1))
|
|
&& (noe.UneVariable(X1)))
|
|
// les forces ponctuelles correspondent aux ddl 1 2 ...
|
|
for (int di=1;di<= dima;di++)
|
|
{// maintenant deux cas: soit avec ou sans courbes de charge
|
|
int pt_adres = noe.Pointeur_assemblage(Enum_ddl(posi+di),cas_assemblage);
|
|
if (pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
// cas d'une grandeur fixe
|
|
{ vecglob (pt_adres) += coeff * (force(di));}
|
|
else // cas d'une fonction nD sans courbe
|
|
{ vecglob (pt_adres) += (force(di))* tabTorseurPonct_i.Echelle_courbe();}
|
|
}
|
|
else // cas avec courbe, avec ou sans fonction c'est pareil
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * tabTorseurPonct_i.Echelle_courbe();
|
|
vecglob (pt_adres) += coeff_charge * (force(di));
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
// $$$--- cas des forces surfaciques ---$$$
|
|
// il y a une implication éventuelle sur la raideur
|
|
int tabsurfactaille = tabFsurfac.Taille();
|
|
if ( tabsurfactaille != 0)
|
|
{// on parcours le tableau tabFsurfac dans le repère absolu
|
|
for (int i=1;i<= tabsurfactaille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<BlocForces> >& tabFsurfac_i = tabFsurfac(i);
|
|
const ReferenceAF & ref =
|
|
((ReferenceAF &) lesRef->Trouve(tabFsurfac_i.NomRef(),tabFsurfac_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(tabFsurfac_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(tabFsurfac_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(tabFsurfac_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments et les surfaces associes
|
|
int nbref = ref.Taille();
|
|
Coordonnee vforce; // init par défaut
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.NumeroElem(ns));
|
|
// récupération de la force de référence
|
|
// on traite en fonction du fait que c'est un champ ou non
|
|
switch (tabFsurfac_i.Champ())
|
|
{ case 1: // c'est un champ de valeurs
|
|
vforce = (tabFsurfac_i.Vect_de_coordonnee(ns)); break;
|
|
case 2: // c'est un champ de fonctions
|
|
// pour l'instant, le seul cas est celui des fonctions du temps
|
|
// on récupère les courbes pour les dim composantes
|
|
{ switch (dima)
|
|
{ case 3 : {Courbe1D * pt_courbe_force_ns_3 =
|
|
lesCourbes1D->Trouve(tabFsurfac_i.Nom_vect(ns,3));
|
|
vforce(3) = pt_courbe_force_ns_3->Valeur(Temps_courant());
|
|
}
|
|
case 2 : {Courbe1D * pt_courbe_force_ns_2 =
|
|
lesCourbes1D->Trouve(tabFsurfac_i.Nom_vect(ns,2));
|
|
vforce(2) = pt_courbe_force_ns_2->Valeur(Temps_courant());
|
|
}
|
|
case 1 : {Courbe1D * pt_courbe_force_ns_1 =
|
|
lesCourbes1D->Trouve(tabFsurfac_i.Nom_vect(ns,1));
|
|
vforce(1) = pt_courbe_force_ns_1->Valeur(Temps_courant());
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
case 0: default:// ce n'est pas un champ
|
|
vforce = (tabFsurfac_i.Vect_de_coordonnee(1)); break;
|
|
};
|
|
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
const string & nomF_charge = tabFsurfac_i.NomF_charge();
|
|
Fonction_nD * pt_fonct = NULL;
|
|
if(nomF_charge.length())
|
|
{pt_fonct = lesFonctionsnD->Trouve(tabFsurfac_i.NomF_charge());
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{// on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{vforce *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : vforce(3) *= tava(3);
|
|
case 2 : vforce(2) *= tava(2);
|
|
case 1 : vforce(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des forces surfaciques sur la ref: "<< tabFsurfac_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 et la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
// on désactive la fonction nD car elle a déjà été utilisée
|
|
pt_fonct = NULL;
|
|
};
|
|
};
|
|
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
if(pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
{ vforce *= coeff;} // cas d'une grandeur fixe
|
|
else // sinon il ne reste plus qu'à intégrer l'échelle
|
|
{ vforce *= tabFsurfac_i.Echelle_courbe();};
|
|
}
|
|
else //sinon c'est idem avec ou sans fonction nD car c'est déjà intégré
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * tabFsurfac_i.Echelle_courbe();
|
|
vforce *= coeff_charge;
|
|
};
|
|
// -- appel du calcul du second membre et de la raideur éventuelle
|
|
// correspondant à la charge surfacique
|
|
Element::ResRaid resu = elem.SMR_charge_surfacique_I(vforce,pt_fonct,ref.NumeroFA(ns),pa);
|
|
// ((tabFsurfac_i.Coord())*coeff ,ref.NumeroFA(ns),pa);
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à la face chargée
|
|
const ElFrontiere* elfront = NULL;
|
|
if (!ParaGlob::AxiSymetrie())
|
|
elfront = elem.Frontiere_surfacique(ref.NumeroFA(ns)); // la surface frontière: cas normal
|
|
else // cas axisymétrique
|
|
elfront = elem.Frontiere_lineique(ref.NumeroFA(ns)); // la surface arête générant une surface en rotation
|
|
assemb.AssemSM (vecglob,*(resu.res),elfront->DdlElem_const(),elfront->TabNoeud_const()); // assemblage du second membre
|
|
// assemblage de la raideur si nécessaire
|
|
if (avec_raid)
|
|
// appel de la fonction adoc, via le pointeur de fonction
|
|
(assemb.*assembMat) (matglob,*(resu.raid),elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
// $$$--- cas des pressions ---$$$
|
|
int tabPresUniftaille = tabPresUnif.Taille();
|
|
if ( tabPresUniftaille != 0)
|
|
{// on parcours le tableau tabPresUnif
|
|
for (int i=1;i<= tabPresUniftaille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<BlocIntensite> >& tabPresUnif_i = tabPresUnif(i);
|
|
const ReferenceAF & ref =
|
|
((ReferenceAF &) lesRef->Trouve(tabPresUnif_i.NomRef(),tabPresUnif_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(tabPresUnif_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(tabPresUnif_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(tabPresUnif_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments et les surfaces associes
|
|
int nbref = ref.Taille();
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.NumeroElem(ns));
|
|
double press_ac = 0.; // init
|
|
// récupération de la pression de référence
|
|
// on traite en fonction du fait que c'est un champ ou non
|
|
switch (tabPresUnif_i.Champ())
|
|
{ case 1: // c'est un champ de valeurs
|
|
press_ac = (tabPresUnif_i.Val(ns)); break;
|
|
case 2: // c'est un champ de fonctions
|
|
// pour l'instant, le seul cas est celui des fonctions du temps
|
|
{ Courbe1D * pt_courbe_force_ns =
|
|
lesCourbes1D->Trouve(tabPresUnif_i.Nom_val(ns));
|
|
press_ac = pt_courbe_force_ns->Valeur(Temps_courant());
|
|
break;
|
|
}
|
|
case 0: default:// ce n'est pas un champ
|
|
press_ac = (tabPresUnif_i.Val(1)); break;
|
|
};
|
|
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
const string & nomF_charge = tabPresUnif_i.NomF_charge();
|
|
Fonction_nD * pt_fonct = NULL;
|
|
if(nomF_charge.length())
|
|
{pt_fonct = lesFonctionsnD->Trouve(tabPresUnif_i.NomF_charge());
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{ // on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{press_ac *= tava(1);}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas de pression sur la ref: "<< tabPresUnif_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
// on désactive la fonction nD car elle a déjà été utilisée
|
|
pt_fonct = NULL;
|
|
};
|
|
};
|
|
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
if(pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
{ press_ac *= coeff;} // cas d'une grandeur fixe
|
|
else // sinon il ne reste plus qu'à intégrer l'échelle
|
|
{ press_ac *= tabPresUnif_i.Echelle_courbe();};
|
|
}
|
|
else //sinon c'est idem avec ou sans fonction nD car c'est déjà intégré
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de { // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * tabPresUnif_i.Echelle_courbe();
|
|
press_ac *= coeff_charge;
|
|
}
|
|
// appel du calcul du second membre et de la raideur éventuelle
|
|
// correspondant à la charge de type pression
|
|
Element::ResRaid resu = elem.SMR_charge_pression_I(press_ac,pt_fonct,ref.NumeroFA(ns),pa);
|
|
// (coeff *(tabPresUnif_i.Val()),ref.NumeroFA(ns),pa);
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à la face chargée
|
|
const ElFrontiere* elfront = NULL;
|
|
if (!ParaGlob::AxiSymetrie())
|
|
elfront = elem.Frontiere_surfacique(ref.NumeroFA(ns)); // la surface frontière: cas normal
|
|
else // cas axisymétrique
|
|
elfront = elem.Frontiere_lineique(ref.NumeroFA(ns)); // la surface arête générant une surface en rotation
|
|
assemb.AssemSM (vecglob,*(resu.res),elfront->DdlElem_const(),elfront->TabNoeud_const()); // assemblage
|
|
// assemblage de la raideur si nécessaire
|
|
if (avec_raid)
|
|
// appel de la fonction adoc, via le pointeur de fonction
|
|
(assemb.*assembMat) (matglob,*(resu.raid),elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
|
|
// $$$--- cas des pression unidirectionnelle ---$$$
|
|
// c'est-à-dire des forces qui sont appliquée sur la surface en gardant la même
|
|
// direction localement pendant toute la transformation
|
|
int PresUniDirtaille = PresUniDir.Taille();
|
|
if ( PresUniDirtaille != 0)
|
|
{// on parcours le tableau PresUniDir
|
|
for (int i=1;i<= PresUniDirtaille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<BlocForces> >& PresUniDir_i = PresUniDir(i);
|
|
const ReferenceAF & ref =
|
|
((ReferenceAF &) lesRef->Trouve(PresUniDir_i.NomRef(),PresUniDir_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(PresUniDir_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(PresUniDir_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(PresUniDir_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments et les surfaces associes
|
|
int nbref = ref.Taille();
|
|
Coordonnee press_uni; // init par défaut
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.NumeroElem(ns));
|
|
// récupération de la force de référence
|
|
// on traite en fonction du fait que c'est un champ ou non
|
|
switch (PresUniDir_i.Champ())
|
|
{ case 1: // c'est un champ de valeurs
|
|
press_uni = (PresUniDir_i.Vect_de_coordonnee(ns)); break;
|
|
case 2: // c'est un champ de fonctions
|
|
// pour l'instant, le seul cas est celui des fonctions du temps
|
|
// on récupère les courbes pour les dim composantes
|
|
{ switch (dima)
|
|
{ case 3 : {Courbe1D * pt_courbe_force_ns_3 =
|
|
lesCourbes1D->Trouve(PresUniDir_i.Nom_vect(ns,3));
|
|
press_uni(3) = pt_courbe_force_ns_3->Valeur(Temps_courant());
|
|
}
|
|
case 2 : {Courbe1D * pt_courbe_force_ns_2 =
|
|
lesCourbes1D->Trouve(PresUniDir_i.Nom_vect(ns,2));
|
|
press_uni(2) = pt_courbe_force_ns_2->Valeur(Temps_courant());
|
|
}
|
|
case 1 : {Courbe1D * pt_courbe_force_ns_1 =
|
|
lesCourbes1D->Trouve(PresUniDir_i.Nom_vect(ns,1));
|
|
press_uni(1) = pt_courbe_force_ns_1->Valeur(Temps_courant());
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
case 0: default:// ce n'est pas un champ
|
|
press_uni = (PresUniDir_i.Vect_de_coordonnee(1)); break;
|
|
};
|
|
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
const string & nomF_charge = PresUniDir_i.NomF_charge();
|
|
Fonction_nD * pt_fonct = NULL;
|
|
if(nomF_charge.length())
|
|
{pt_fonct = lesFonctionsnD->Trouve(PresUniDir_i.NomF_charge());
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{// on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{press_uni *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : press_uni(3) *= tava(3);
|
|
case 2 : press_uni(2) *= tava(2);
|
|
case 1 : press_uni(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des des pression unidirectionnelle sur la ref: "<< PresUniDir_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 et la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
// on désactive la fonction nD car elle a déjà été utilisée
|
|
pt_fonct = NULL;
|
|
};
|
|
};
|
|
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
if(pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
{ press_uni *= coeff;} // cas d'une grandeur fixe
|
|
else // sinon il ne reste plus qu'à intégrer l'échelle
|
|
{ press_uni *= PresUniDir_i.Echelle_courbe();};
|
|
}
|
|
else //sinon c'est idem avec ou sans fonction nD car c'est déjà intégré
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * PresUniDir_i.Echelle_courbe();
|
|
press_uni *= coeff_charge;
|
|
}
|
|
// appel du calcul du second membre et de la raideur éventuelle
|
|
// correspondant à la charge de type pression
|
|
// Vecteur pres_u = (PresUniDir_i.Coord()) * coeff;
|
|
Element::ResRaid resu = elem.SMR_charge_presUniDir_I(press_uni,pt_fonct,ref.NumeroFA(ns),pa);
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à la face chargée
|
|
const ElFrontiere* elfront = NULL;
|
|
if (!ParaGlob::AxiSymetrie())
|
|
elfront = elem.Frontiere_surfacique(ref.NumeroFA(ns)); // la surface frontière: cas normal
|
|
else // cas axisymétrique
|
|
elfront = elem.Frontiere_lineique(ref.NumeroFA(ns)); // la surface arête générant une surface en rotation
|
|
assemb.AssemSM (vecglob,*(resu.res),elfront->DdlElem_const(),elfront->TabNoeud_const()); // assemblage
|
|
// assemblage de la raideur si nécessaire
|
|
if (avec_raid)
|
|
// appel de la fonction adoc, via le pointeur de fonction
|
|
(assemb.*assembMat) (matglob,*(resu.raid),elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
};
|
|
};
|
|
}
|
|
}
|
|
|
|
// $$$--- cas des forces lineique ---$$$
|
|
int tablineiquetaille = tabFlineique.Taille();
|
|
if ( tablineiquetaille != 0)
|
|
{// on parcours le tableau tabFlineique dans le repère absolu
|
|
for (int i=1;i<= tablineiquetaille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<BlocForces> >& tabFlineique_i = tabFlineique(i);
|
|
const ReferenceAF & ref =
|
|
((ReferenceAF &) lesRef->Trouve(tabFlineique_i.NomRef(),tabFlineique_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(tabFlineique_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(tabFlineique_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(tabFlineique_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments et les aretes associes
|
|
int nbref = ref.Taille();
|
|
Coordonnee f_lin; // init par défaut
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.NumeroElem(ns));
|
|
// récupération de la force de référence
|
|
// on traite en fonction du fait que c'est un champ ou non
|
|
switch (tabFlineique_i.Champ())
|
|
{ case 1: // c'est un champ de valeurs
|
|
f_lin = (tabFlineique_i.Vect_de_coordonnee(ns)); break;
|
|
case 2: // c'est un champ de fonctions
|
|
// pour l'instant, le seul cas est celui des fonctions du temps
|
|
// on récupère les courbes pour les dim composantes
|
|
{ switch (dima)
|
|
{ case 3 : {Courbe1D * pt_courbe_force_ns_3 =
|
|
lesCourbes1D->Trouve(tabFlineique_i.Nom_vect(ns,3));
|
|
f_lin(3) = pt_courbe_force_ns_3->Valeur(Temps_courant());
|
|
}
|
|
case 2 : {Courbe1D * pt_courbe_force_ns_2 =
|
|
lesCourbes1D->Trouve(tabFlineique_i.Nom_vect(ns,2));
|
|
f_lin(2) = pt_courbe_force_ns_2->Valeur(Temps_courant());
|
|
}
|
|
case 1 : {Courbe1D * pt_courbe_force_ns_1 =
|
|
lesCourbes1D->Trouve(tabFlineique_i.Nom_vect(ns,1));
|
|
f_lin(1) = pt_courbe_force_ns_1->Valeur(Temps_courant());
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
case 0: default:// ce n'est pas un champ
|
|
f_lin = (tabFlineique_i.Vect_de_coordonnee(1)); break;
|
|
};
|
|
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
const string & nomF_charge = tabFlineique_i.NomF_charge();
|
|
Fonction_nD * pt_fonct = NULL;
|
|
if(nomF_charge.length())
|
|
{pt_fonct = lesFonctionsnD->Trouve(tabFlineique_i.NomF_charge());
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{// on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{f_lin *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : f_lin(3) *= tava(3);
|
|
case 2 : f_lin(2) *= tava(2);
|
|
case 1 : f_lin(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des des forces lineiques sur la ref: "<< tabFlineique_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 et la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
// on désactive la fonction nD car elle a déjà été utilisée
|
|
pt_fonct = NULL;
|
|
};
|
|
};
|
|
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
if(pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
{ f_lin *= coeff;} // cas d'une grandeur fixe
|
|
else // sinon il ne reste plus qu'à intégrer l'échelle
|
|
{ f_lin *= tabFlineique_i.Echelle_courbe();};
|
|
}
|
|
else //sinon c'est idem avec ou sans fonction nD car c'est déjà intégré
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * tabFlineique_i.Echelle_courbe();
|
|
f_lin *= coeff_charge;
|
|
}
|
|
// appel du calcul du second membre et de la raideur éventuelle
|
|
// correspondant à la charge lineique
|
|
// Vecteur f_lin = (tabFlineique_i.Coord()) * coeff;
|
|
Element::ResRaid resu = elem.SMR_charge_lineique_I(f_lin,pt_fonct,ref.NumeroFA(ns),pa) ;
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à la ligne chargée
|
|
const ElFrontiere* elfront = elem.Frontiere_lineique(ref.NumeroFA(ns)); // l'arrête frontière
|
|
assemb.AssemSM (vecglob,*(resu.res),elfront->DdlElem_const(),elfront->TabNoeud_const()); // assemblage
|
|
// assemblage de la raideur si nécessaire
|
|
if (avec_raid)
|
|
// appel de la fonction adoc, via le pointeur de fonction
|
|
(assemb.*assembMat) (matglob,*(resu.raid),elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
// $$$--- cas des forces lineiques suiveuses ---$$$
|
|
int tablineiqueSuivtaille = tabFlineiqueSuiv.Taille();
|
|
if ( tablineiqueSuivtaille != 0)
|
|
{// on parcours le tableau tabFlineiqueSuiv dans le repère global
|
|
for (int i=1;i<= tablineiqueSuivtaille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<BlocForces> > & tabFlineiqueSuiv_i = tabFlineiqueSuiv(i);
|
|
const ReferenceAF & ref =
|
|
((ReferenceAF &) lesRef->Trouve(tabFlineiqueSuiv_i.NomRef(),tabFlineiqueSuiv_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(tabFlineiqueSuiv_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(tabFlineiqueSuiv_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(tabFlineiqueSuiv_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments et les aretes associes
|
|
int nbref = ref.Taille();
|
|
Coordonnee f_lin; // init par défaut
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.NumeroElem(ns));
|
|
// récupération de la force de référence
|
|
// on traite en fonction du fait que c'est un champ ou non
|
|
switch (tabFlineiqueSuiv_i.Champ())
|
|
{ case 1: // c'est un champ de valeurs
|
|
f_lin = (tabFlineiqueSuiv_i.Vect_de_coordonnee(ns)); break;
|
|
case 2: // c'est un champ de fonctions
|
|
// pour l'instant, le seul cas est celui des fonctions du temps
|
|
// on récupère les courbes pour les dim composantes
|
|
{ switch (dima)
|
|
{ case 3 : {Courbe1D * pt_courbe_force_ns_3 =
|
|
lesCourbes1D->Trouve(tabFlineiqueSuiv_i.Nom_vect(ns,3));
|
|
f_lin(3) = pt_courbe_force_ns_3->Valeur(Temps_courant());
|
|
}
|
|
case 2 : {Courbe1D * pt_courbe_force_ns_2 =
|
|
lesCourbes1D->Trouve(tabFlineiqueSuiv_i.Nom_vect(ns,2));
|
|
f_lin(2) = pt_courbe_force_ns_2->Valeur(Temps_courant());
|
|
}
|
|
case 1 : {Courbe1D * pt_courbe_force_ns_1 =
|
|
lesCourbes1D->Trouve(tabFlineiqueSuiv_i.Nom_vect(ns,1));
|
|
f_lin(1) = pt_courbe_force_ns_1->Valeur(Temps_courant());
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
case 0: default:// ce n'est pas un champ
|
|
f_lin = (tabFlineiqueSuiv_i.Vect_de_coordonnee(1)); break;
|
|
};
|
|
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
const string & nomF_charge = tabFlineiqueSuiv_i.NomF_charge();
|
|
Fonction_nD * pt_fonct = NULL;
|
|
if(nomF_charge.length())
|
|
{pt_fonct = lesFonctionsnD->Trouve(tabFlineiqueSuiv_i.NomF_charge());
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{// on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{f_lin *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : f_lin(3) *= tava(3);
|
|
case 2 : f_lin(2) *= tava(2);
|
|
case 1 : f_lin(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des des forces lineiques suiveuses sur la ref: "<< tabFlineiqueSuiv_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 et la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
// on désactive la fonction nD car elle a déjà été utilisée
|
|
pt_fonct = NULL;
|
|
};
|
|
};
|
|
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
if(pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
{ f_lin *= coeff;} // cas d'une grandeur fixe
|
|
else // sinon il ne reste plus qu'à intégrer l'échelle
|
|
{ f_lin *= tabFlineiqueSuiv_i.Echelle_courbe();};
|
|
}
|
|
else //sinon c'est idem avec ou sans fonction nD car c'est déjà intégré
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * tabFlineiqueSuiv_i.Echelle_courbe();
|
|
f_lin *= coeff_charge;
|
|
}
|
|
// appel du calcul du second membre et de la raideur éventuelle
|
|
// correspondant à la charge lineique
|
|
// Vecteur f_lin = (tabFlineiqueSuiv_i.Coord()) * coeff;
|
|
Element::ResRaid resu = elem.SMR_charge_lineique_Suiv_I(f_lin,pt_fonct,ref.NumeroFA(ns),pa) ;
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à la ligne chargée
|
|
const ElFrontiere* elfront = elem.Frontiere_lineique(ref.NumeroFA(ns)); // l'arrête frontière
|
|
assemb.AssemSM (vecglob,*(resu.res),elfront->DdlElem_const(),elfront->TabNoeud_const()); // assemblage
|
|
// assemblage de la raideur si nécessaire
|
|
if (avec_raid)
|
|
// appel de la fonction adoc, via le pointeur de fonction
|
|
(assemb.*assembMat) (matglob,*(resu.raid),elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
// $$$--- cas des forces volumiques ---$$$
|
|
int tabvoltaille = tabFvol.Taille();
|
|
if ( tabvoltaille != 0)
|
|
{// on parcours le tableau tabFvol dans le repère absolu
|
|
for (int i=1;i<= tabvoltaille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<BlocForces> >& tabFvol_i = tabFvol(i);
|
|
const ReferenceNE & ref =
|
|
((ReferenceNE &) lesRef->Trouve(tabFvol_i.NomRef(),tabFvol_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(tabFvol_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(tabFvol_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(tabFvol_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments
|
|
int nbref = ref.Taille();
|
|
Coordonnee f_vol; // init par défaut
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.Numero(ns));
|
|
// récupération de la force de référence
|
|
// on traite en fonction du fait que c'est un champ ou non
|
|
switch (tabFvol_i.Champ())
|
|
{ case 1: // c'est un champ de valeurs
|
|
f_vol = (tabFvol_i.Vect_de_coordonnee(ns)); break;
|
|
case 2: // c'est un champ de fonctions
|
|
// pour l'instant, le seul cas est celui des fonctions du temps
|
|
// on récupère les courbes pour les dim composantes
|
|
{ switch (dima)
|
|
{ case 3 : {Courbe1D * pt_courbe_force_ns_3 =
|
|
lesCourbes1D->Trouve(tabFvol_i.Nom_vect(ns,3));
|
|
f_vol(3) = pt_courbe_force_ns_3->Valeur(Temps_courant());
|
|
}
|
|
case 2 : {Courbe1D * pt_courbe_force_ns_2 =
|
|
lesCourbes1D->Trouve(tabFvol_i.Nom_vect(ns,2));
|
|
f_vol(2) = pt_courbe_force_ns_2->Valeur(Temps_courant());
|
|
}
|
|
case 1 : {Courbe1D * pt_courbe_force_ns_1 =
|
|
lesCourbes1D->Trouve(tabFvol_i.Nom_vect(ns,1));
|
|
f_vol(1) = pt_courbe_force_ns_1->Valeur(Temps_courant());
|
|
}
|
|
};
|
|
break;
|
|
}
|
|
case 0: default:// ce n'est pas un champ
|
|
f_vol = (tabFvol_i.Vect_de_coordonnee(1)); break;
|
|
};
|
|
|
|
// on regarde si jamais on a une dépendance à des grandeurs globales
|
|
const string & nomF_charge = tabFvol_i.NomF_charge();
|
|
Fonction_nD * pt_fonct = NULL;
|
|
if(nomF_charge.length())
|
|
{pt_fonct = lesFonctionsnD->Trouve(tabFvol_i.NomF_charge());
|
|
if (pt_fonct->Nom_variables().Taille() == 0) // cas où il n'y a que des variables globales
|
|
{// on vérifie qu'en retour on a un scalaire ou un vecteur de dimension = la dimension de l'espace
|
|
Tableau <double> & tava = pt_fonct->Valeur_pour_variables_globales(); // pour simplifier
|
|
if (pt_fonct->NbComposante() == 1)
|
|
{f_vol *= tava(1);}
|
|
else if (pt_fonct->NbComposante() == dima)
|
|
{switch (dima)
|
|
{ case 3 : f_vol(3) *= tava(3);
|
|
case 2 : f_vol(2) *= tava(2);
|
|
case 1 : f_vol(1) *= tava(1);
|
|
};
|
|
}
|
|
else
|
|
{cout << "\n *** erreur en retour de l'utilisation d'une fonction nD avec grandeur(s) globale(s)"
|
|
<< " cas des des forces lineiques suiveuses sur la ref: "<< tabFvol_i.NomRef()
|
|
<< " en retour, le nombre de composante est different de 1 et la dimension de l'espace : "
|
|
<< dima << endl;
|
|
Sortie(1);
|
|
};
|
|
// on désactive la fonction nD car elle a déjà été utilisée
|
|
pt_fonct = NULL;
|
|
};
|
|
};
|
|
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
if(pt_courbe == NULL)
|
|
{if (!nomF_charge.length()) // pas de courbe et pas de fonction nD
|
|
{ f_vol *= coeff;} // cas d'une grandeur fixe
|
|
else // sinon il ne reste plus qu'à intégrer l'échelle
|
|
{ f_vol *= tabFvol_i.Echelle_courbe();};
|
|
}
|
|
else //sinon c'est idem avec ou sans fonction nD car c'est déjà intégré
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * tabFvol_i.Echelle_courbe();
|
|
f_vol *= coeff_charge;
|
|
}
|
|
// appel du calcul du second membre et de la raideur éventuelle
|
|
// correspondant à la charge volumique
|
|
// on indique si éventuellement on veut se référer au volume initial
|
|
bool volume_finale = !(tabFvol_i.Attribut() == "sur_volume_initial_");
|
|
// Vecteur f_vol = (tabFvol_i.Coord()) * coeff;
|
|
Element::ResRaid resu = elem.SMR_charge_volumique_I(f_vol,pt_fonct,pa,volume_finale);
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à l'élément
|
|
assemb.AssemSM (vecglob,*(resu.res),elem.TableauDdl(),elem.Tab_noeud()); // assemblage
|
|
// assemblage de la raideur si nécessaire
|
|
if (avec_raid)
|
|
// appel de la fonction adoc, via le pointeur de fonction
|
|
(assemb.*assembMat) (matglob,*(resu.raid),elem.TableauDdl(),elem.Tab_noeud());
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
// $$$--- cas des des pressions hydrostatiques ---$$$
|
|
int PresHydrotaille = PresHydro.Taille();
|
|
if ( PresHydrotaille != 0)
|
|
{// on parcours le tableau PresHydro
|
|
for (int i=1;i<= PresHydrotaille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<PHydro> > & PresHydro_i = PresHydro(i);
|
|
const ReferenceAF & ref =
|
|
((ReferenceAF &) lesRef->Trouve(PresHydro_i.NomRef(),PresHydro_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(PresHydro_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(PresHydro_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(PresHydro_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// on récupère le vecteur normal et le point de la surface libre
|
|
const Coordonnee& N = PresHydro_i.Direction_N(); // récup de la direction N normée
|
|
const Coordonnee& A = PresHydro_i.Point_M(); // récup du point de la surface libre
|
|
double p_hydro_ref = (PresHydro_i.Val(1));
|
|
// Maintenant les éléments et les surfaces associes
|
|
int nbref = ref.Taille();
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.NumeroElem(ns));
|
|
double p_hydro = p_hydro_ref;
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
if(pt_courbe == NULL)
|
|
{ p_hydro *= coeff;} // cas d'une grandeur fixe
|
|
else
|
|
{ // cas d'une courbe de charge calcul de la valeur du coeff de charge
|
|
double coeff_charge = (pt_courbe->Valeur(Temps_courant())) * PresHydro_i.Echelle_courbe();
|
|
p_hydro *= coeff_charge;
|
|
}
|
|
// appel du calcul du second membre et de la raideur éventuelle
|
|
// correspondant à la charge de type pression
|
|
bool sans_limitation=false;
|
|
if (PresHydro_i.Attribut() == "sans_limitation_") sans_limitation= true;
|
|
Element::ResRaid resu = elem.SMR_charge_hydrostatique_I
|
|
(N,p_hydro,ref.NumeroFA(ns),A,pa,sans_limitation) ;
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à la face chargée
|
|
const ElFrontiere* elfront = NULL;
|
|
if (!ParaGlob::AxiSymetrie())
|
|
elfront = elem.Frontiere_surfacique(ref.NumeroFA(ns)); // la surface frontière: cas normal
|
|
else // cas axisymétrique
|
|
elfront = elem.Frontiere_lineique(ref.NumeroFA(ns)); // la surface arête générant une surface en rotation
|
|
assemb.AssemSM (vecglob,*(resu.res),elfront->DdlElem_const(),elfront->TabNoeud_const()); // assemblage
|
|
// assemblage de la raideur si nécessaire
|
|
if (avec_raid)
|
|
// appel de la fonction adoc, via le pointeur de fonction
|
|
(assemb.*assembMat) (matglob,*(resu.raid),elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
// $$$--- cas des des efforts hydrodynamiques ---$$$
|
|
int coefHydroDynataille = coefHydroDyna.Taille();
|
|
if ( coefHydroDynataille != 0)
|
|
{// on parcours le tableau coefHydroDyna
|
|
for (int i=1;i<= coefHydroDynataille;i++)
|
|
{ // recup de la reference correspondant au mot cle
|
|
BlocCharge< BlocDdlLim<PHydrodyna> > & coefHydroDyna_i = coefHydroDyna(i);
|
|
const ReferenceAF & ref =
|
|
((ReferenceAF &) lesRef->Trouve(coefHydroDyna_i.NomRef(),coefHydroDyna_i.NomMaillage()));
|
|
// dans le cas d'une courbe de charge on récupère l'adresse
|
|
Courbe1D * pt_courbe = NULL;
|
|
if(coefHydroDyna_i.NomCourbeCharge() != "")
|
|
pt_courbe = lesCourbes1D->Trouve(coefHydroDyna_i.NomCourbeCharge());
|
|
// pas de calcul, si le temps est inférieur au temps actif
|
|
// ou si d'une part le temps n'est pas actif et qu'au pas précédent
|
|
// il n'était pas également actif on ne fait rien
|
|
if (!(coefHydroDyna_i.Pas_a_prendre_en_compte(Temps_courant())))
|
|
{// Maintenant les éléments et les surfaces associes
|
|
int nbref = ref.Taille();
|
|
// récup du poids volumique poids volumique = ro * g, qui n'est pas soumis à la courbe de charge
|
|
double poidvol = (coefHydroDyna_i.Val(1));
|
|
for (int ns=1;ns<= nbref;ns++)
|
|
{ // récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(ref.Nbmaille(), ref.NumeroElem(ns));
|
|
// maintenant deux cas: soit avec ou sans courbes de charge
|
|
double coeff_charge=1.;
|
|
if(pt_courbe != NULL)
|
|
{ coeff_charge = (pt_courbe->Valeur(Temps_courant())) * coefHydroDyna_i.Echelle_courbe();};
|
|
// appel du calcul du second membre correspondant aux efforts hydrodynamique
|
|
Element::ResRaid resu = elem.SMR_charge_hydrodynamique_I(coefHydroDyna_i.Frot_fluid(),poidvol
|
|
,coefHydroDyna_i.Coef_aero_n(),ref.NumeroFA(ns),coeff_charge
|
|
,coefHydroDyna_i.Coef_aero_t(),pa) ;
|
|
// assemblage du second membre
|
|
// il faut utiliser les noeuds et les ddlelement correspondant à la face chargée
|
|
const ElFrontiere* elfront;
|
|
switch (ParaGlob::Dimension())
|
|
{ case 3: {elfront = elem.Frontiere_surfacique(ref.NumeroFA(ns)); break;};// la surface frontière
|
|
case 2: {elfront = elem.Frontiere_lineique(ref.NumeroFA(ns)); break;};// la ligne frontière
|
|
case 1: {elfront = elem.Frontiere_points(ref.NumeroFA(ns)); break;};// le point frontière
|
|
};
|
|
assemb.AssemSM (vecglob,*(resu.res),elfront->DdlElem_const(),elfront->TabNoeud_const()); // assemblage
|
|
// assemblage de la raideur si nécessaire
|
|
if (avec_raid)
|
|
// appel de la fonction adoc, via le pointeur de fonction
|
|
(assemb.*assembMat) (matglob,*(resu.raid),elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
};
|
|
};
|
|
};
|
|
}; //-- fin de hydrodyna
|
|
|
|
|
|
// affichage éventuelle de la matrice de raideur et du second membre
|
|
if (ParaGlob::NiveauImpression() >= 10)
|
|
{ string entete = " affichage de la matrice de raideur apres chargement d'efforts externes ";
|
|
matglob.Affichage_ecran(entete);
|
|
entete = " affichage du second membre apres chargement d'efforts externes ";
|
|
vecglob.Affichage_ecran(entete);
|
|
};
|
|
}
|
|
catch (ErrSortieFinale)
|
|
// cas d'une direction voulue vers la sortie
|
|
// on relance l'interuption pour le niveau supérieur
|
|
{ ErrSortieFinale toto;
|
|
throw (toto);
|
|
}
|
|
catch ( ... )
|
|
{ if (ParaGlob::NiveauImpression() >= 1)
|
|
{cout << "\n *** erreur dans le calcul du chargement impose ";
|
|
if (ParaGlob::NiveauImpression() >= 4)
|
|
cout << "\n Charge::ChargeSMembreRaideur_Im_mecaSolid(..";
|
|
cout << flush;
|
|
};
|
|
retour = false;
|
|
};
|
|
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
return retour;
|
|
};
|