3193 lines
172 KiB
C++
3193 lines
172 KiB
C++
|
|
// 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-2022 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
|
|
{
|
|
#ifndef UTILISATION_MPI
|
|
// 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();
|
|
};
|
|
|
|
#else
|
|
// ParaGlob::Monde()->barrier(); // synchronisation ici de tous les process
|
|
// cas d'un calcul multi-CPU , si cpu 0, idem cas non parallèle
|
|
if (ParaGlob::Monde()->rank() == 0)
|
|
{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();
|
|
};
|
|
}
|
|
else
|
|
{// on va parcourir les éléments associés au cpu
|
|
// on récupère la distribution d'éléments concernant le cpu en cours
|
|
// si c'est le cpu 0 on initialise tous les éléments
|
|
const Tableau < list <int > >& tab_list_elem_cpu =
|
|
ParaGlob::param->const_List_element_CPU_en_cours();
|
|
// la taille est identique à nbMailMax, sauf si c'est le cpu 0, là le tableau est vide et il n'y
|
|
// aura pas de boucle, (ou plutôt on sortira directement de la boucle
|
|
// le cas CPU 0 est traité à part
|
|
int nb_mail_distrib = tab_list_elem_cpu.Taille();
|
|
for (int imail =1; imail<= nb_mail_distrib; imail++)
|
|
{const list <int >& list_elem_cpu= tab_list_elem_cpu(imail); // pour simplifier
|
|
// on balaie les éléments nécessaires
|
|
list <int >::const_iterator il,ilfin=list_elem_cpu.end();
|
|
for (il = list_elem_cpu.begin();il != ilfin;il++)
|
|
{ int iele = (*il);
|
|
lesMail->Element_LesMaille(imail,iele).Initialisation_avant_chargement();
|
|
};
|
|
};
|
|
};
|
|
#endif
|
|
|
|
int posi = Id_nom_ddl("X1") -1;
|
|
int dim = ParaGlob::Dimension();
|
|
// 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--;
|
|
|
|
// $$$ --- cas des forces ponctuelles --- $$$
|
|
#ifdef UTILISATION_MPI
|
|
// cas d'un calcul //, les chargements aux noeuds sont calculés par le cpu 0 uniquement
|
|
if (ParaGlob::Monde()->rank() == 0)
|
|
#endif
|
|
// 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 --- $$$
|
|
#ifdef UTILISATION_MPI
|
|
// cas d'un calcul //, les chargements aux noeuds sont calculés par le cpu 0 uniquement
|
|
if (ParaGlob::Monde()->rank() == 0)
|
|
#endif
|
|
// 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));
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// on définit les conteneurs de passage d'info
|
|
int proc_en_cours = ParaGlob::Monde()->rank();
|
|
int index_transfert; // index pour incrémenter dans les tableaux
|
|
|
|
bool premier_passage = true;
|
|
if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
|
|
// --- cas des forces surfaciques ---$$$
|
|
int tabsurfactaille = tabFsurfac.Taille();
|
|
if ( tabsurfactaille != 0)
|
|
{
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{ int num_elem = ref.NumeroElem(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
// 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;
|
|
};
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
// appel du calcul du second membre correspondant à la charge surfacique
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
int num_face = ref.NumeroFA(ns);
|
|
SM_transfert = elem.SM_charge_surfacique_E_tdt(vforce,pt_fonct,num_face,pa);
|
|
int tyfront = 5; // init par défaut du type de frontière
|
|
if (ParaGlob::AxiSymetrie())
|
|
// dans le cas axiSymétrique, les surfaces sont générées par les lignes,
|
|
{//enum Enum_type_geom { POINT_G = 1 , LIGNE , SURFACE, VOLUME, RIEN_TYPE_GEOM };
|
|
tyfront = 2;}
|
|
else // cas normale
|
|
{tyfront = 3; };// la surface
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_SM(premier_passage,tyfront,
|
|
num_face,SM_transfert,
|
|
index_transfert,num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{
|
|
// appel du calcul du second membre correspondant à la charge surfacique
|
|
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
|
|
}
|
|
#endif
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
// --- cas des pressions ---$$$
|
|
int tabPresUniftaille = tabPresUnif.Taille();
|
|
if ( tabPresUniftaille != 0)
|
|
{
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{ int num_elem = ref.NumeroElem(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
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;
|
|
};
|
|
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
int num_face = ref.NumeroFA(ns);
|
|
SM_transfert = elem.SM_charge_pression_E_tdt(press_ac,pt_fonct,num_face,pa);
|
|
int tyfront = 5; // init par défaut du type de frontière
|
|
if (ParaGlob::AxiSymetrie())
|
|
// dans le cas axiSymétrique, les surfaces sont générées par les lignes,
|
|
{//enum Enum_type_geom { POINT_G = 1 , LIGNE , SURFACE, VOLUME, RIEN_TYPE_GEOM };
|
|
tyfront = 2;}
|
|
else // cas normale
|
|
{tyfront = 3; };// la surface
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_SM(premier_passage,tyfront,
|
|
num_face,SM_transfert,
|
|
index_transfert,num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{ // appel du calcul du second membre correspondant à la charge de type pression
|
|
// ici on récupère une adresse car il n'y a pas de crainte d'écraser un vecteur déjà en cours
|
|
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
|
|
}
|
|
#endif
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
// --- 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)
|
|
{
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{int num_elem = ref.NumeroElem(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
// 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
|
|
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
int num_face = ref.NumeroFA(ns);
|
|
SM_transfert = elem.SM_charge_presUniDir_E_tdt(press_uni,pt_fonct,num_face,pa);
|
|
int tyfront = 5; // init par défaut du type de frontière
|
|
if (ParaGlob::AxiSymetrie())
|
|
// dans le cas axiSymétrique, les surfaces sont générées par les lignes,
|
|
{//enum Enum_type_geom { POINT_G = 1 , LIGNE , SURFACE, VOLUME, RIEN_TYPE_GEOM };
|
|
tyfront = 2;}
|
|
else // cas normale
|
|
{tyfront = 3; };// la surface
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_SM(premier_passage,tyfront,
|
|
num_face,SM_transfert,
|
|
index_transfert,num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{ // appel du calcul du second membre correspondant à la charge de type pression
|
|
// ici on récupère une adresse car il n'y a pas de crainte d'écraser un vecteur déjà en cours
|
|
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
|
|
}
|
|
#endif
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
// --- cas des forces lineique ---$$$
|
|
int tablineiquetaille = tabFlineique.Taille();
|
|
if ( tablineiquetaille != 0)
|
|
{
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{ int num_elem = ref.NumeroElem(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
// 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;
|
|
};
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
int num_ligne = ref.NumeroFA(ns);
|
|
SM_transfert =elem.SM_charge_lineique_E_tdt(f_lin,pt_fonct,num_ligne,pa);
|
|
int tyfront = 2; // type de frontière ligne
|
|
// si on est en axi c'est interprété comme une force surfacique
|
|
// on ne change pas le type de frontière
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_SM(premier_passage,tyfront,
|
|
num_ligne,SM_transfert,
|
|
index_transfert,num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{ // appel du calcul du second membre correspondant à la charge lineique
|
|
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
|
|
}
|
|
#endif
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
// --- 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
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
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++)
|
|
{ int num_elem = ref.NumeroElem(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
// 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;
|
|
}
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
int num_ligne = ref.NumeroFA(ns);
|
|
SM_transfert = elem.SM_charge_lineique_Suiv_E_tdt(f_lin,pt_fonct,num_ligne,pa);
|
|
int tyfront = 2; // type de frontière ligne
|
|
// si on est en axi c'est interprété comme une force surfacique
|
|
// on ne change pas le type de frontière
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_SM(premier_passage,tyfront,
|
|
num_ligne,SM_transfert,
|
|
index_transfert,num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{ // appel du calcul du second membre correspondant à la charge lineique
|
|
// 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
|
|
};
|
|
#endif
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
// --- cas des forces volumiques ---$$$
|
|
int tabvoltaille = tabFvol.Taille();
|
|
if ( tabvoltaille != 0)
|
|
{
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{ int num_elem = ref.Numero(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
// 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_");
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
int num_inter = 0; // ne sert pas ici
|
|
SM_transfert = elem.SM_charge_volumique_E_tdt(f_vol,pt_fonct,pa,volume_finale);
|
|
int tyfront = 4; // type d'un volume
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_SM(premier_passage,tyfront,
|
|
num_inter,SM_transfert,
|
|
index_transfert,num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{// appel du calcul du second membre correspondant à la charge volumique
|
|
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
|
|
}
|
|
#endif
|
|
};
|
|
};
|
|
}
|
|
}
|
|
|
|
// --- cas des des pressions hydrostatiques ---$$$
|
|
int PresHydrotaille = PresHydro.Taille();
|
|
if ( PresHydrotaille != 0)
|
|
{
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{ int num_elem = ref.NumeroElem(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
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;
|
|
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
int num_face = ref.NumeroFA(ns);
|
|
SM_transfert = elem.SM_charge_hydrostatique_E_tdt
|
|
(N,p_hydro,num_face,A,pa,sans_limitation) ;
|
|
int tyfront = 5; // init par défaut du type de frontière
|
|
if (ParaGlob::AxiSymetrie())
|
|
// dans le cas axiSymétrique, les surfaces sont générées par les lignes,
|
|
{//enum Enum_type_geom { POINT_G = 1 , LIGNE , SURFACE, VOLUME, RIEN_TYPE_GEOM };
|
|
tyfront = 2;}
|
|
else // cas normale
|
|
{tyfront = 3; };// la surface
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_SM(premier_passage,tyfront,
|
|
num_face,SM_transfert,
|
|
index_transfert,num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{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
|
|
};
|
|
#endif
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
// --- cas des des efforts hydrodynamiques ---$$$
|
|
int coefHydroDynataille = coefHydroDyna.Taille();
|
|
if ( coefHydroDynataille != 0)
|
|
{if (ParaGlob::AxiSymetrie()) // pas pris en compte
|
|
{cout << "\n *** erreur : le chargement hydrodynamique en axisymetrique n'est pas pris en compte ! ";
|
|
Sortie(1);
|
|
};
|
|
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{ int num_elem = ref.NumeroElem(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
// 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();};
|
|
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
int num_front = ref.NumeroFA(ns);
|
|
SM_transfert = elem.SM_charge_hydrodynamique_E_tdt
|
|
(coefHydroDyna_i.Frot_fluid(),poidvol
|
|
,coefHydroDyna_i.Coef_aero_n(),num_front,coeff_charge
|
|
,coefHydroDyna_i.Coef_aero_t(),pa) ;
|
|
int tyfront = 5; // init par défaut du type de frontière
|
|
switch (ParaGlob::Dimension())
|
|
{ case 3: {tyfront=3; break;};// la surface frontière
|
|
case 2: {tyfront=2; break;};// la ligne frontière
|
|
case 1: {tyfront=1; break;};// le point frontière
|
|
};
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_SM(premier_passage,tyfront,
|
|
num_front,SM_transfert,
|
|
index_transfert,num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{// 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
|
|
}
|
|
#endif
|
|
};
|
|
};
|
|
};
|
|
}; //-- fin de hydrodyna
|
|
|
|
temps_cpu_chargement.Arret_du_comptage(); // fin comptage cpu
|
|
// maintenant on s'occupe du cpu 0
|
|
#ifdef UTILISATION_MPI
|
|
|
|
// arrivée ici on va indiquer au CPU 0 que c'est fini
|
|
int tyfront = - proc_en_cours; // init par défaut du type de frontière
|
|
// le signe - indique une fin
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // ne sert pas ici
|
|
Transfert_SM(premier_passage,tyfront,
|
|
0,SM_transfert,
|
|
index_transfert,0,0
|
|
);
|
|
}
|
|
else // donc ici cas ou on a le rank == 0 et on récolte
|
|
{ // récup d'un second membre
|
|
temps_cpu_chargement.Mise_en_route_du_comptage(); // comptage cpu
|
|
int nb_proc_terminer = 0; // permettra de terminer
|
|
// on va boucler sur les éléments récupérés des différents process
|
|
// jusqu'à ce que tous les éléments aient finis
|
|
premier_passage = true;
|
|
int index_transfert = 1; // on se sert du premier élément de tableau
|
|
int ne,nbMail,tyfront,num_front,taille_SM; // inter pour la persistance
|
|
int source; // le nb de la source émettante
|
|
// int index_local_de_tab = 0;
|
|
mpi::request & reqs1 = tab_reqs1(index_transfert); // pour simplifier
|
|
mpi::request & reqs2 = tab_reqs2(index_transfert); // pour simplifier
|
|
Vecteur& six_faux_entiers = tab_six_faux_entiers(index_transfert); // pour simplifier
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
// int i_proc = 1; // essai de réception avec le num du proc
|
|
// Tableau < int > non_fin_proc(nb_proc-1,1); // essai
|
|
while (nb_proc_terminer < (ParaGlob::Monde()->size()-1)) // gérer par les valeurs de tyfront
|
|
{ // on récupère un résultat de calcul
|
|
temps_cpu_chargement.Arret_du_comptage(); // fin comptage cpu
|
|
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
|
|
reqs1 = six_faux_entiers.Irecup_MPI(mpi::any_source, 34);
|
|
// if (non_fin_proc(i_proc)) // essai
|
|
// {reqs1 = six_faux_entiers.Irecup_MPI(i_proc, 34); // essai
|
|
// temps_transfert_court.Arret_du_comptage(); // comptage cpu
|
|
// temps_attente.Mise_en_route_du_comptage(); // comptage cpu
|
|
mpi::status stat = reqs1.wait();
|
|
temps_transfert_court.Arret_du_comptage(); // comptage cpu
|
|
// temps_attente.Arret_du_comptage(); // comptage cpu
|
|
temps_cpu_chargement.Mise_en_route_du_comptage(); // comptage cpu
|
|
ne = (int) six_faux_entiers(1);
|
|
nbMail = (int) six_faux_entiers(2);
|
|
tyfront = (int) six_faux_entiers(3);
|
|
num_front = (int) six_faux_entiers(4);
|
|
taille_SM = (int) six_faux_entiers(5);
|
|
index_transfert = six_faux_entiers(6);
|
|
source = stat.source();
|
|
|
|
|
|
////-------debug
|
|
//cout << "\n debug Charge::ChargeSecondMembre_Ex_mecaSolid proc= "<< ParaGlob::Monde()->rank()
|
|
//// << " recup CinqEntiers " << num_el_mail_tyfront_nufront << flush;
|
|
// << " recup six_faux_entiers " << six_faux_entiers << flush;
|
|
////-------fin debug
|
|
// int tyfront = num_el_mail_tyfront_nufront.trois;
|
|
if (tyfront > 0)
|
|
{Element& elem = lesMail->Element_LesMaille(nbMail,ne);
|
|
// def de SM avec la bonne dimension
|
|
SM_transfert.Change_taille(taille_SM);//num_el_mail_tyfront_nufront.cinq);
|
|
// récupération des conteneurs ad hoc vecteur et raideur
|
|
temps_cpu_chargement.Arret_du_comptage(); // fin comptage cpu
|
|
temps_transfert_long.Mise_en_route_du_comptage(); // comptage cpu
|
|
// reqs2 = SM_transfert.Irecup_MPI(source, 350+index_transfert);
|
|
reqs2 = SM_transfert.Irecup_MPI(source, 35);
|
|
reqs2.wait(); // on attend que le conteneur soit rempli
|
|
temps_transfert_long.Arret_du_comptage(); // fin comptage cpu
|
|
////-------debug
|
|
//cout << "\n debug Charge::ChargeSecondMembre_Ex_mecaSolid proc= "<< ParaGlob::Monde()->rank()
|
|
// << " SM= " << SM << flush;
|
|
////-------fin debug
|
|
|
|
// assemblage
|
|
|
|
temps_cpu_chargement.Mise_en_route_du_comptage(); // comptage cpu
|
|
switch (tyfront)
|
|
{
|
|
case 1: // cas d'un point frontière
|
|
{const ElFrontiere* elfront =elem.Frontiere_points(num_front);// num_el_mail_tyfront_nufront.quatre);
|
|
assemb.AssemSM (vecglob,SM_transfert,elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
break;
|
|
}
|
|
case 2: // cas d'une ligne
|
|
{const ElFrontiere* elfront = elem.Frontiere_lineique(num_front);// num_el_mail_tyfront_nufront.quatre);
|
|
assemb.AssemSM (vecglob,SM_transfert,elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
break;
|
|
}
|
|
case 3: // cas d'une surface
|
|
{const ElFrontiere* elfront = elem.Frontiere_surfacique(num_front);//num_el_mail_tyfront_nufront.quatre);
|
|
assemb.AssemSM (vecglob,SM_transfert,elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
break;
|
|
}
|
|
case 4: // cas d'un volume
|
|
{assemb.AssemSM (vecglob,SM_transfert,elem.TableauDdl(),elem.Tab_noeud());
|
|
break;
|
|
}
|
|
default:
|
|
{cout << "\n erreur*** Charge::ChargeSecondMembre_Ex_mecaSolid proc= "<< proc_en_cours
|
|
<< " le cas tyfront = " << tyfront << " n'est pas pris en compte pour l'instant !! ";
|
|
Sortie(1);
|
|
} ;
|
|
};
|
|
}
|
|
else if (tyfront < 0)
|
|
{// on est dans le cas où un proc a terminé
|
|
nb_proc_terminer++;
|
|
// non_fin_proc(i_proc)=0; // essai
|
|
}
|
|
else
|
|
{cout << "\n erreur*** Charge::ChargeSecondMembre_Ex_mecaSolid proc= "<< proc_en_cours
|
|
<< " tyfront ne doit jamais etre nul !! ";
|
|
Sortie(1);
|
|
} ;
|
|
// }; // essai
|
|
// i_proc++; // essai
|
|
// if (i_proc > nb_proc-1) // essai
|
|
// i_proc = 1; // essai
|
|
};
|
|
temps_cpu_chargement.Arret_du_comptage(); // fin comptage cpu
|
|
////-------debug
|
|
//cout << "\n debug Charge::ChargeSecondMembre_Ex_mecaSolid proc= "<< ParaGlob::Monde()->rank()
|
|
// << " vecglob final = " << vecglob << flush;
|
|
////------fin debug
|
|
};
|
|
#endif
|
|
|
|
//#ifdef UTILISATION_MPI
|
|
////-------debug
|
|
//cout << "\n debug Charge::ChargeSecondMembre_Ex_mecaSolid poc= "<< proc_en_cours
|
|
// << " SM= " << vecglob << flush;
|
|
//#else
|
|
// cout << "\n debug Charge::ChargeSecondMembre_Ex_mecaSolid "
|
|
// << " SM= "; vecglob.Affiche();
|
|
////------fin debug
|
|
//#endif
|
|
|
|
// 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();
|
|
#ifdef UTILISATION_MPI
|
|
temps_attente.Mise_en_route_du_comptage();
|
|
ParaGlob::Monde()->barrier(); // synchronisation ici de tous les process
|
|
temps_attente.Arret_du_comptage();
|
|
#endif
|
|
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
|
|
{
|
|
#ifndef UTILISATION_MPI
|
|
// 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();
|
|
};
|
|
#else
|
|
// cas d'un calcul multi-CPU , si cpu 0, idem cas non parallèle
|
|
if (ParaGlob::Monde()->rank() == 0)
|
|
{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();
|
|
};
|
|
}
|
|
else
|
|
{// on va parcourir les éléments associés au cpu
|
|
// on récupère la distribution d'éléments concernant le cpu en cours
|
|
// si c'est le cpu 0 on initialise tous les éléments
|
|
const Tableau < list <int > >& tab_list_elem_cpu =
|
|
ParaGlob::param->const_List_element_CPU_en_cours();
|
|
// la taille est identique à nbMailMax, sauf si c'est le cpu 0, là le tableau est vide et il n'y
|
|
// aura pas de boucle, (ou plutôt on sortira directement de la boucle
|
|
// le cas CPU 0 est traité à part
|
|
int nb_mail_distrib = tab_list_elem_cpu.Taille();
|
|
for (int imail =1; imail<= nb_mail_distrib; imail++)
|
|
{const list <int >& list_elem_cpu= tab_list_elem_cpu(imail); // pour simplifier
|
|
// on balaie les éléments nécessaires
|
|
list <int >::const_iterator il,ilfin=list_elem_cpu.end();
|
|
for (il = list_elem_cpu.begin();il != ilfin;il++)
|
|
{ int iele = (*il);
|
|
lesMail->Element_LesMaille(imail,iele).Initialisation_avant_chargement();
|
|
};
|
|
};
|
|
};
|
|
#endif
|
|
|
|
// 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();
|
|
// 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--;
|
|
|
|
// $$$--- cas des forces ponctuelles ---$$$
|
|
#ifdef UTILISATION_MPI
|
|
// cas d'un calcul //, les chargements aux noeuds sont calculés par le cpu 0uniquement
|
|
if (ParaGlob::Monde()->rank() == 0)
|
|
#endif
|
|
// 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 ---$$$
|
|
#ifdef UTILISATION_MPI
|
|
// cas d'un calcul //, les chargements aux noeuds sont calculés par le cpu 0 uniquement
|
|
if (ParaGlob::Monde()->rank() == 0)
|
|
#endif
|
|
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));
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// on définit les conteneurs de passage d'info
|
|
int proc_en_cours = ParaGlob::Monde()->rank();
|
|
int index_transfert; // index pour incrémenter dans les tableaux
|
|
bool premier_passage = true;
|
|
if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
|
|
|
|
// $$$--- cas des forces surfaciques ---$$$
|
|
// il y a une implication éventuelle sur la raideur
|
|
int tabsurfactaille = tabFsurfac.Taille();
|
|
if ( tabsurfactaille != 0)
|
|
{
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{ int num_elem = ref.NumeroElem(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
// 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);
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
// appel du calcul du second membre correspondant à la charge surfacique
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
Mat_pleine& MAT_transfert = tabMat_transfert(index_transfert);
|
|
Mat_pleine* pt_MAT = NULL;
|
|
int num_face = ref.NumeroFA(ns);
|
|
// on change de conteneur pour permettre de calculer plusieurs chargements même si le transfert n'est pas terminé
|
|
SM_transfert = *(resu.res);
|
|
if (avec_raid)
|
|
{MAT_transfert = *(resu.raid);
|
|
pt_MAT = &MAT_transfert;
|
|
};
|
|
|
|
int tyfront = 5; // init par défaut du type de frontière
|
|
if (ParaGlob::AxiSymetrie())
|
|
// dans le cas axiSymétrique, les surfaces sont générées par les lignes,
|
|
{//enum Enum_type_geom { POINT_G = 1 , LIGNE , SURFACE, VOLUME, RIEN_TYPE_GEOM };
|
|
tyfront = 2;}
|
|
else // cas normale
|
|
{tyfront = 3; };// la surface
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_MatSm(premier_passage,tyfront,
|
|
num_face,SM_transfert,
|
|
pt_MAT,index_transfert,
|
|
num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{ // 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());
|
|
}
|
|
#endif
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
// $$$--- cas des pressions ---$$$
|
|
int tabPresUniftaille = tabPresUnif.Taille();
|
|
if ( tabPresUniftaille != 0)
|
|
{
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{ int num_elem = ref.NumeroElem(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
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);
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
// appel du calcul du second membre correspondant à la charge surfacique
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
Mat_pleine& MAT_transfert = tabMat_transfert(index_transfert);
|
|
Mat_pleine* pt_MAT = NULL;
|
|
int num_face = ref.NumeroFA(ns);
|
|
// on change de conteneur pour permettre de calculer plusieurs chargements même si le transfert n'est pas terminé
|
|
SM_transfert = *(resu.res);
|
|
if (avec_raid)
|
|
{MAT_transfert = *(resu.raid);
|
|
pt_MAT = &MAT_transfert;
|
|
};
|
|
|
|
int tyfront = 5; // init par défaut du type de frontière
|
|
if (ParaGlob::AxiSymetrie())
|
|
// dans le cas axiSymétrique, les surfaces sont générées par les lignes,
|
|
{//enum Enum_type_geom { POINT_G = 1 , LIGNE , SURFACE, VOLUME, RIEN_TYPE_GEOM };
|
|
tyfront = 2;}
|
|
else // cas normale
|
|
{tyfront = 3; };// la surface
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_MatSm(premier_passage,tyfront,
|
|
num_face,SM_transfert,
|
|
pt_MAT,index_transfert,
|
|
num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{ // 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());
|
|
}
|
|
#endif
|
|
};
|
|
};
|
|
}
|
|
}
|
|
|
|
|
|
// $$$--- 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)
|
|
{
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{ int num_elem = ref.NumeroElem(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
// 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);
|
|
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
// appel du calcul du second membre correspondant à la charge surfacique
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
Mat_pleine& MAT_transfert = tabMat_transfert(index_transfert);
|
|
Mat_pleine* pt_MAT = NULL;
|
|
int num_face = ref.NumeroFA(ns);
|
|
// on change de conteneur pour permettre de calculer plusieurs chargements même si le transfert n'est pas terminé
|
|
SM_transfert = *(resu.res);
|
|
if (avec_raid)
|
|
{MAT_transfert = *(resu.raid);
|
|
pt_MAT = &MAT_transfert;
|
|
};
|
|
|
|
int tyfront = 5; // init par défaut du type de frontière
|
|
if (ParaGlob::AxiSymetrie())
|
|
// dans le cas axiSymétrique, les surfaces sont générées par les lignes,
|
|
{//enum Enum_type_geom { POINT_G = 1 , LIGNE , SURFACE, VOLUME, RIEN_TYPE_GEOM };
|
|
tyfront = 2;}
|
|
else // cas normale
|
|
{tyfront = 3; };// la surface
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_MatSm(premier_passage,tyfront,
|
|
num_face,SM_transfert,
|
|
pt_MAT,index_transfert,
|
|
num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
|
|
{ // 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());
|
|
}
|
|
#endif
|
|
};
|
|
};
|
|
}
|
|
}
|
|
|
|
// $$$--- cas des forces lineique ---$$$
|
|
int tablineiquetaille = tabFlineique.Taille();
|
|
if ( tablineiquetaille != 0)
|
|
{
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{ int num_elem = ref.NumeroElem(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
// 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) ;
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
// appel du calcul du second membre correspondant à la charge surfacique
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
Mat_pleine& MAT_transfert = tabMat_transfert(index_transfert);
|
|
Mat_pleine* pt_MAT = NULL;
|
|
int num_ligne = ref.NumeroFA(ns);
|
|
// on change de conteneur pour permettre de calculer plusieurs chargements même si le transfert n'est pas terminé
|
|
SM_transfert = *(resu.res);
|
|
if (avec_raid)
|
|
{MAT_transfert = *(resu.raid);
|
|
pt_MAT = &MAT_transfert;
|
|
};
|
|
int tyfront = 2; // type de frontière ligne
|
|
// si on est en axi c'est interprété comme une force surfacique
|
|
// on ne change pas le type de frontière
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_MatSm(premier_passage,tyfront,
|
|
num_ligne,SM_transfert,
|
|
pt_MAT,index_transfert,
|
|
num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{ // 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());
|
|
}
|
|
#endif
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
// $$$--- cas des forces lineiques suiveuses ---$$$
|
|
int tablineiqueSuivtaille = tabFlineiqueSuiv.Taille();
|
|
if ( tablineiqueSuivtaille != 0)
|
|
{
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{ int num_elem = ref.NumeroElem(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
// 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) ;
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
// appel du calcul du second membre correspondant à la charge surfacique
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
Mat_pleine& MAT_transfert = tabMat_transfert(index_transfert);
|
|
Mat_pleine* pt_MAT = NULL;
|
|
int num_ligne = ref.NumeroFA(ns);
|
|
// on change de conteneur pour permettre de calculer plusieurs chargements même si le transfert n'est pas terminé
|
|
SM_transfert = *(resu.res);
|
|
if (avec_raid)
|
|
{MAT_transfert = *(resu.raid);
|
|
pt_MAT = &MAT_transfert;
|
|
};
|
|
int tyfront = 2; // type de frontière ligne
|
|
// si on est en axi c'est interprété comme une force surfacique
|
|
// on ne change pas le type de frontière
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_MatSm(premier_passage,tyfront,
|
|
num_ligne,SM_transfert,
|
|
pt_MAT,index_transfert,
|
|
num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{ // 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());
|
|
}
|
|
#endif
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
// $$$--- cas des forces volumiques ---$$$
|
|
int tabvoltaille = tabFvol.Taille();
|
|
if ( tabvoltaille != 0)
|
|
{
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{ int num_elem = ref.Numero(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
// 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);
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
// appel du calcul du second membre correspondant à la charge surfacique
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
Mat_pleine& MAT_transfert = tabMat_transfert(index_transfert);
|
|
Mat_pleine* pt_MAT = NULL;
|
|
int num_inter = 0; // ne sert pas ici
|
|
// on change de conteneur pour permettre de calculer plusieurs hargements même si le transfert n'est pas terminé
|
|
SM_transfert = *(resu.res);
|
|
if (avec_raid)
|
|
{MAT_transfert = *(resu.raid);
|
|
pt_MAT = &MAT_transfert;
|
|
};
|
|
int tyfront = 4; // type d'un volume
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_MatSm(premier_passage,tyfront,
|
|
num_inter,SM_transfert,
|
|
pt_MAT,index_transfert,
|
|
num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{ // 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());
|
|
}
|
|
#endif
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
// $$$--- cas des des pressions hydrostatiques ---$$$
|
|
int PresHydrotaille = PresHydro.Taille();
|
|
if ( PresHydrotaille != 0)
|
|
{
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{ int num_elem = ref.NumeroElem(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
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) ;
|
|
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
// appel du calcul du second membre correspondant à la charge surfacique
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
int num_face = ref.NumeroFA(ns);
|
|
Mat_pleine& MAT_transfert = tabMat_transfert(index_transfert);
|
|
Mat_pleine* pt_MAT = NULL;
|
|
int tyfront = 5; // init par défaut du type de frontière
|
|
if (ParaGlob::AxiSymetrie())
|
|
// dans le cas axiSymétrique, les surfaces sont générées par les lignes,
|
|
{//enum Enum_type_geom { POINT_G = 1 , LIGNE , SURFACE, VOLUME, RIEN_TYPE_GEOM };
|
|
tyfront = 2;}
|
|
else // cas normale
|
|
{tyfront = 3; };// la surface
|
|
// on change de conteneur pour permettre de calculer plusieurs hargements même si le transfert n'est pas terminé
|
|
SM_transfert = *(resu.res);
|
|
if (avec_raid)
|
|
{MAT_transfert = *(resu.raid);
|
|
pt_MAT = &MAT_transfert;
|
|
};
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_MatSm(premier_passage,tyfront,
|
|
num_face,SM_transfert,
|
|
pt_MAT,index_transfert,
|
|
num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{// 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());
|
|
};
|
|
#endif
|
|
};
|
|
};
|
|
}
|
|
};
|
|
|
|
// $$$--- cas des des efforts hydrodynamiques ---$$$
|
|
int coefHydroDynataille = coefHydroDyna.Taille();
|
|
if ( coefHydroDynataille != 0)
|
|
{if (ParaGlob::AxiSymetrie()) // pas pris en compte
|
|
{cout << "\n *** erreur : le chargement hydrodynamique en axisymetrique n'est pas pris en compte ! ";
|
|
Sortie(1);
|
|
};
|
|
|
|
#ifdef UTILISATION_MPI
|
|
index_transfert=1; // index pour incrémenter dans les tableaux
|
|
#endif
|
|
// 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++)
|
|
{ int num_elem = ref.NumeroElem(ns);
|
|
int num_mail = ref.Nbmaille();
|
|
#ifdef UTILISATION_MPI
|
|
// on ne continue que si l'élément est concerné
|
|
if (ParaGlob::param->Element_concerner(num_mail,num_elem) )
|
|
{if (proc_en_cours != 0)
|
|
{
|
|
#endif
|
|
// récupération de l'élément fini
|
|
Element& elem = lesMail->Element_LesMaille(num_mail, num_elem);
|
|
// 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) ;
|
|
|
|
|
|
#ifdef UTILISATION_MPI
|
|
// appel du calcul du second membre correspondant à la charge de type pression
|
|
// appel du calcul du second membre correspondant à la charge surfacique
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
int num_front = ref.NumeroFA(ns);
|
|
Mat_pleine& MAT_transfert = tabMat_transfert(index_transfert);
|
|
Mat_pleine* pt_MAT = NULL;
|
|
int tyfront = 5; // init par défaut du type de frontière
|
|
switch (ParaGlob::Dimension())
|
|
{ case 3: {tyfront=3; break;};// la surface frontière
|
|
case 2: {tyfront=2; break;};// la ligne frontière
|
|
case 1: {tyfront=1; break;};// le point frontière
|
|
};
|
|
// on change de conteneur pour permettre de calculer plusieurs hargements même si le transfert n'est pas terminé
|
|
SM_transfert = *(resu.res);
|
|
if (avec_raid)
|
|
{MAT_transfert = *(resu.raid);
|
|
pt_MAT = &MAT_transfert;
|
|
};
|
|
temps_cpu_chargement.Arret_du_comptage();
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Transfert_MatSm(premier_passage,tyfront,
|
|
num_front,SM_transfert,
|
|
pt_MAT,index_transfert,
|
|
num_mail,num_elem
|
|
);
|
|
temps_cpu_chargement.Mise_en_route_du_comptage();
|
|
}
|
|
};
|
|
#else // cas non //
|
|
{// 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());
|
|
}
|
|
#endif
|
|
};
|
|
};
|
|
};
|
|
}; //-- fin de hydrodyna
|
|
|
|
temps_cpu_chargement.Arret_du_comptage(); // fin comptage cpu
|
|
// maintenant on s'occupe du cpu 0
|
|
#ifdef UTILISATION_MPI
|
|
|
|
// arrivée ici on va indiquer au CPU 0 que c'est fini
|
|
int tyfront = - proc_en_cours; // init par défaut du type de frontière
|
|
// le signe - indique une fin
|
|
// appel du transfert et mise à jour de l'index des tableaux
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // ne sert pas ici
|
|
Transfert_SM(premier_passage,tyfront,
|
|
0,SM_transfert,
|
|
index_transfert,0,0
|
|
);
|
|
}
|
|
else // donc ici cas ou on a le rank == 0 et on récolte
|
|
{ // récup d'un second membre et de la matrice
|
|
temps_cpu_chargement.Mise_en_route_du_comptage(); // comptage cpu
|
|
int nb_proc_terminer = 0; // permettra de terminer
|
|
// on va boucler sur les éléments récupérés des différents process
|
|
// jusqu'à ce que tous les éléments aient finis
|
|
premier_passage = true;
|
|
int index_transfert = 1; // on se sert du premier élément de tableau
|
|
int ne,nbMail,tyfront,num_front,taille_SM; // inter pour la persistance
|
|
int source; // le nb de la source émettante
|
|
mpi::request & reqs1 = tab_reqs1(index_transfert); // pour simplifier
|
|
mpi::request & reqs2 = tab_reqs2(index_transfert); // pour simplifier
|
|
mpi::request & reqs3 = tab_reqs3(index_transfert); // pour simplifier
|
|
Vecteur& six_faux_entiers = tab_six_faux_entiers(index_transfert); // pour simplifier
|
|
Vecteur& SM_transfert = tabV_transfert(index_transfert); // pour simplifier
|
|
Mat_pleine& MAT_transfert = tabMat_transfert(index_transfert); // idem
|
|
while (nb_proc_terminer < (ParaGlob::Monde()->size()-1)) // gérer par les valeurs de tyfront
|
|
{ // on récupère un résultat de calcul
|
|
temps_cpu_chargement.Arret_du_comptage(); // fin comptage cpu
|
|
temps_transfert_court.Mise_en_route_du_comptage(); // comptage cpu
|
|
reqs1 = six_faux_entiers.Irecup_MPI(mpi::any_source, 34);
|
|
mpi::status stat = reqs1.wait();
|
|
temps_transfert_court.Arret_du_comptage(); // comptage cpu
|
|
temps_cpu_chargement.Mise_en_route_du_comptage(); // comptage cpu
|
|
ne = (int) six_faux_entiers(1);
|
|
nbMail = (int) six_faux_entiers(2);
|
|
tyfront = (int) six_faux_entiers(3);
|
|
num_front = (int) six_faux_entiers(4);
|
|
taille_SM = (int) six_faux_entiers(5);
|
|
index_transfert = six_faux_entiers(6);
|
|
source = stat.source();
|
|
|
|
////-------debug
|
|
//cout << "\n debug Charge::ChargeSMembreRaideur_Im_mecaSolid proc= "<< ParaGlob::Monde()->rank()
|
|
//// << " recup CinqEntiers " << num_el_mail_tyfront_nufront << flush;
|
|
// << " recup six_faux_entiers " << six_faux_entiers << flush;
|
|
////-------fin debug
|
|
// int tyfront = num_el_mail_tyfront_nufront.trois;
|
|
if (tyfront > 0)
|
|
{Element& elem = lesMail->Element_LesMaille(nbMail,ne);
|
|
// def de SM et MAT avec la bonne dimension
|
|
SM_transfert.Change_taille(taille_SM);
|
|
if (MAT_transfert.Nb_ligne () != taille_SM)
|
|
MAT_transfert.Initialise(taille_SM,taille_SM);
|
|
// récupération des conteneurs ad hoc vecteur et raideur
|
|
temps_cpu_chargement.Arret_du_comptage(); // fin comptage cpu
|
|
temps_transfert_long.Mise_en_route_du_comptage(); // comptage cpu
|
|
reqs2 = SM_transfert.Irecup_MPI(source, 35);
|
|
reqs2.wait(); // on attend que le conteneur soit rempli
|
|
// idem pour la matrice
|
|
reqs3 = MAT_transfert.Irecup_MPI(source,36);
|
|
temps_transfert_long.Arret_du_comptage(); // fin comptage cpu
|
|
////-------debug
|
|
//cout << "\n debug Charge::ChargeSMembreRaideur_Im_mecaSolid proc= "<< ParaGlob::Monde()->rank()
|
|
// << " SM= " << SM << flush;
|
|
////-------fin debug
|
|
|
|
// assemblage
|
|
|
|
temps_cpu_chargement.Mise_en_route_du_comptage(); // comptage cpu
|
|
switch (tyfront)
|
|
{
|
|
case 1: // cas d'un point frontière
|
|
{const ElFrontiere* elfront =elem.Frontiere_points(num_front);// num_el_mail_tyfront_nufront.quatre);
|
|
assemb.AssemSM (vecglob,SM_transfert,elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
// assemblage de la raideur si nécessaire
|
|
if (avec_raid)
|
|
// appel de la fonction adoc, via le pointeur de fonction
|
|
(assemb.*assembMat) (matglob,MAT_transfert,elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
break;
|
|
}
|
|
case 2: // cas d'une ligne
|
|
{const ElFrontiere* elfront = elem.Frontiere_lineique(num_front);// num_el_mail_tyfront_nufront.quatre);
|
|
assemb.AssemSM (vecglob,SM_transfert,elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
// assemblage de la raideur si nécessaire
|
|
if (avec_raid)
|
|
// appel de la fonction adoc, via le pointeur de fonction
|
|
(assemb.*assembMat) (matglob,MAT_transfert,elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
break;
|
|
}
|
|
case 3: // cas d'une surface
|
|
{const ElFrontiere* elfront = elem.Frontiere_surfacique(num_front);//num_el_mail_tyfront_nufront.quatre);
|
|
assemb.AssemSM (vecglob,SM_transfert,elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
// assemblage de la raideur si nécessaire
|
|
if (avec_raid)
|
|
// appel de la fonction adoc, via le pointeur de fonction
|
|
(assemb.*assembMat) (matglob,MAT_transfert,elfront->DdlElem_const(),elfront->TabNoeud_const());
|
|
break;
|
|
}
|
|
case 4: // cas d'un volume
|
|
{assemb.AssemSM (vecglob,SM_transfert,elem.TableauDdl(),elem.Tab_noeud());
|
|
// assemblage de la raideur si nécessaire
|
|
if (avec_raid)
|
|
// appel de la fonction adoc, via le pointeur de fonction
|
|
(assemb.*assembMat) (matglob,MAT_transfert,elem.TableauDdl(),elem.Tab_noeud());
|
|
break;
|
|
}
|
|
default:
|
|
{cout << "\n erreur*** Charge::ChargeSMembreRaideur_Im_mecaSolid proc= "<< proc_en_cours
|
|
<< " le cas tyfront = " << tyfront << " n'est pas pris en compte pour l'instant !! ";
|
|
Sortie(1);
|
|
} ;
|
|
};
|
|
}
|
|
else if (tyfront < 0)
|
|
{// on est dans le cas où un proc a terminé
|
|
nb_proc_terminer++;
|
|
}
|
|
else
|
|
{cout << "\n erreur*** Charge::ChargeSMembreRaideur_Im_mecaSolid proc= "<< proc_en_cours
|
|
<< " tyfront ne doit jamais etre nul !! ";
|
|
Sortie(1);
|
|
} ;
|
|
|
|
};
|
|
temps_cpu_chargement.Arret_du_comptage(); // fin comptage cpu
|
|
////-------debug
|
|
//cout << "\n debug Charge::ChargeSMembreRaideur_Im_mecaSolid proc= "<< ParaGlob::Monde()->rank()
|
|
// << " vecglob final = " << vecglob << flush;
|
|
////------fin debug
|
|
};
|
|
#endif
|
|
|
|
//#ifdef UTILISATION_MPI
|
|
////-------debug
|
|
//cout << "\n debug Charge::ChargeSecondMembre_Ex_mecaSolid poc= "<< proc_en_cours
|
|
// << " SM= " << vecglob << flush;
|
|
//#else
|
|
// cout << "\n debug Charge::ChargeSecondMembre_Ex_mecaSolid "
|
|
// << " SM= "; vecglob.Affiche();
|
|
////------fin debug
|
|
//#endif
|
|
|
|
|
|
|
|
// 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;
|
|
};
|