// 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 "LesCondLim.h"
#include "ReferenceNE.h"
#include "ReferenceAF.h"
#include "CharUtil.h"
#include "TypeQuelconqueParticulier.h"
// retourne la liste des types de ddl actuellement imposés
// aux noeuds pour chaque maillage, la liste est exhaustive
// elle contiend tous les types au moins une fois utilisée
// cela ne signifie pas que le ddl en question soit présent
// pour tous les noeud du maillage considéré
// - le tableau de retour est indicé par le numéro de maillage correspondant
// - il y a une liste par maillage
Tableau <List_io < Ddl_enum_etendu> > LesCondLim::Les_type_de_ddl_en_reaction() const
{ // définition du tableau de retour
Tableau <List_io <Ddl_enum_etendu> > tab_li(nb_maillage);
// on boucle sur les réactions en cours pour remplir le tableau
int nb_reac=reaction.Taille();
for (int i=1;i<=nb_reac;i++)
{ List_io <Ddl_enum_etendu>& li=tab_li(reaction(i).numMail);
Ddl_enum_etendu ddl_enu = (reaction(i).ddl.Id_nom());
if (find(li.begin(),li.end(),ddl_enu) == li.end())
li.push_back(ddl_enu);
};
// retour du tableau de listes
return tab_li;
};
/* // retourne les réactions aux conditions limites à un noeud noe d'un maillage mail
// en paramètre il y a un pointeur sur la liste de retour, pour éviter la création
// d'une liste intermédiaire
// s'il n'y a pas de conditions limites : retour d'une liste vide
const list<const LesCondLim::ReactStoc*>& LesCondLim::Reaction_noeud_mail(int numNoeud,int numMail) const
{ string cle("mail"+ChangeEntierSTring(numMail)+"noeud"+ChangeEntierSTring(numNoeud));
map < string, list<const ReactStoc*> , std::less <string> >::const_iterator it = map_reaction.find(cle);
if (it != map_reaction.end())
{ return (*it).second;};
// sinon pas d'existence donc retour d'une liste vide
const list<const LesCondLim::ReactStoc*> li; // construction d'une liste vide
return li;
}; */
// retourne la liste des torseurs de réaction actuellement actif pour les maillages
// appelons tab_lili la liste:
// - tab_lili(i) concerne le maillage nb i
// - les éléments de tab_lili(i) sont les noms des références qui conduisent à un torseur de réaction
// actif, et un indice de gestion utilisé par LesCondLim pour retrouver
// rapidemment les informations
Tableau < List_io <String_et_entier > > LesCondLim::TabListTorseurReaction(const LesMaillages & lesmail) const
{ // def de la grandeur de retour
Tableau < List_io <String_et_entier > > tab_lili(nb_maillage);
string nom; // une variable de travail
// on balaie le tableau des torseur
int ttail = tab_torseurReac.Taille(); // tabBloq, tab_iocondiline et tab_torseurReac n'ont pas la même dimension
for (int i=1;i<= ttail;i++)
{ TorseurReac& torseurReac = tab_torseurReac(i); // pour simplifier
if (torseurReac.existe_torseur_reac)
{if (torseurReac.bloque_ou_CLL)
// cas où le torseur provient d'une condition ddl bloquée
{DdlLim& tabBloq_i = tabBloq(*(ttorBloq(i).begin())); // pour simplifier
if (tabBloq_i.NomMaillage() != NULL)
{ const string& nom_maillage = *(tabBloq_i.NomMaillage()); // nom de maillage lue
tab_lili(lesmail.NumMaillage(nom_maillage)).push_back(String_et_entier(tabBloq_i.NomRef(),i));
}
else
{tab_lili(1).push_back(String_et_entier(tabBloq_i.NomRef(),i));
};
}
else
// cas où le torseur provient d'une condition CLL
{I_O_Condilineaire& iocondiline_i = tab_iocondiline((*(ttorCLL(i).begin())).un); // pour simplifier
if (iocondiline_i.NomMaillage() != NULL)
// cas où on considère les noms de maillage
{ int num_ref = (*(ttorCLL(i).begin())).deux; // pour simplifier
if (num_ref == 1)
{ // cas d'une référence principale de CLL
const string& nom_maillage = *(iocondiline_i.NomMaillage());
tab_lili(lesmail.NumMaillage(nom_maillage)).push_back
(String_et_entier(iocondiline_i.NomRef()+"_CLL",i));
}
else
{// cas d'une référence associé
// on fait (*(ttorCLL(i).begin())).deux - 1) car ttorCLL contient l'ensemble des refs, y compris
// la ref principale, et ReferenceAssociees() ne ramène que les ref associés, donc il faut retirer 1
// qui correspond à la référence principale
const string& nom_maillage = iocondiline_i.NomMaillageAssociees()((*(ttorCLL(i).begin())).deux-1);
tab_lili(lesmail.NumMaillage(nom_maillage)).push_back
(String_et_entier(iocondiline_i.ReferenceAssociees()((*(ttorCLL(i).begin())).deux - 1)+"_CLL",i));
};
}
else
{// cas où on ne considère pas les noms de maillage
int num_ref = (*(ttorCLL(i).begin())).deux; // pour simplifier
if (num_ref == 1)
{// cas d'une référence principale de CLL
tab_lili(1).push_back(String_et_entier(iocondiline_i.NomRef()+"_CLL",i));
}
else
{// cas d'une référence associé
// on fait (*(ttorCLL(i).begin())).deux - 1) car ttorCLL contient l'ensemble des refs, y compris
// la ref principale, et ReferenceAssociees() ne ramène que les ref associés, donc il faut retirer 1
// qui correspond à la référence principale
tab_lili(1).push_back
(String_et_entier(iocondiline_i.ReferenceAssociees()((*(ttorCLL(i).begin())).deux - 1)+"_CLL",i));
};
};
};
};
};
// retour des infos
return tab_lili;
};
// affichage et definition interactive des commandes pour les conditions limites CL
void LesCondLim::Info_commande_LesCondLim1(UtilLecture & entreePrinc)
{
cout << "\n# ----- definition des conditions limites cinematiques ----- ";
bool plusieurs_maillages = false;
string rep="_";
ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
// écriture de l'entête
sort << "\n blocages #------------# "
<< "\n#-----------------------------------------------------------"
<< "\n# nom du maillage | Ref noeud | Blocages"
<< "\n#-----------------------------------------------------------";
// def des conditions
try
{cout << "\n cas d'un seul maillage (par defaut) : rep o "
<< "\n cas de plusieurs maillages : rep n ";
rep = lect_return_defaut(true,"o");
if (rep == "n")
{ plusieurs_maillages = true; cout << "\n --> les prochaines CL seront associees a un nom de maillage ";};
rep="_"; // init
// boucle globale
while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
{ cout << "\n (0 ou f) (fin) "
<< "\n (1) def d'une nouvelle condition "
<< "\n ";
rep = lect_return_defaut(false,"f");
if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie directe
break;
int num = ChangeEntier(rep);
bool choix_valide=false;
if ((num >= 0)&&(num<=1))
{ choix_valide=true; }
else { cout << "\n Erreur on attendait un entier entre 0 et 1 !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour arreter le programme";
choix_valide=false;
};
switch (num)
{ case 0: // sortie
{ break;} // normalement cela a déjà été filtré avant
case 1: // def d'une liste d'elements associe a un nom de loi
{ DdlLim unddl; // init
unddl.Info_commande_DdlLim(sort,plusieurs_maillages);
break;
}
default:
cout << "\n le cas "<<rep<<" n'est pas traite !!, bizarre, il faut se plaindre !! ";
};
};
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch (...)//(UtilLecture::ErrNouvelleDonnee erreur)
{ cout << "\n Erreur on attendait un des mots cles proposes !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour sortir ";
};
sort << flush;
};
// affichage et definition interactive des commandes pour les conditions limites CLL
void LesCondLim::Info_commande_LesCondLim2(UtilLecture & entreePrinc)
{
cout << "\n# ----- definition des conditions limites lineaires ----- ";
bool plusieurs_maillages = false;
string rep="_";
ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
// écriture de l'entête
sort << "\n condition_limite_lineaire_ #------------# "
<< "\n#-----------------------------------------------------------"
<< "\n# nom du maillage | Ref noeud | CLL "
<< "\n#-----------------------------------------------------------";
// def des conditions
try
{cout << "\n cas d'un seul maillage (par defaut) : rep o "
<< "\n cas de plusieurs maillages : rep n ";
rep = lect_return_defaut(true,"o");
if (rep == "n")
{ plusieurs_maillages = true; cout << "\n --> les prochaines CLL seront associees a un nom de maillage ";};
rep="_"; // init
// boucle globale
while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
{ cout << "\n (0 ou f) (fin) "
<< "\n (1) def d'une nouvelle condition "
<< "\n ";
rep = lect_return_defaut(false,"f");
if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie directe
break;
int num = ChangeEntier(rep);
bool choix_valide=false;
if ((num >= 0)&&(num<=1))
{ choix_valide=true; }
else { cout << "\n Erreur on attendait un entier entre 0 et 1 !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour arreter le programme";
choix_valide=false;
};
switch (num)
{ case 0: // sortie
{ break;} // normalement cela a déjà été filtré avant
case 1: // def d'une liste d'elements associe a un nom de loi
{ I_O_Condilineaire uneCLL; // init
uneCLL.Info_commande_conditionLineaire(sort,plusieurs_maillages);
break;
}
default:
cout << "\n le cas "<<rep<<" n'est pas traite !!, bizarre, il faut se plaindre !! ";
};
};
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch (...)//(UtilLecture::ErrNouvelleDonnee erreur)
{ cout << "\n Erreur on attendait un des mots cles proposes !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour sortir ";
};
sort << flush;
};
// affichage et definition interactive des commandes pour les initialisations
void LesCondLim::Info_commande_LesCondLim3(UtilLecture & entreePrinc)
{ cout << "\n *** warning : la partie initialisation n'est pas encore operationnelle *** ";
return;
cout << "\n# ----- definition des conditions limites cinematiques ----- ";
bool plusieurs_maillages = false;
string rep="_";
ofstream & sort = *(entreePrinc.Commande_pointInfo()); // pour simplifier
// écriture de l'entête
sort << "\n blocages #------------# "
<< "\n#-----------------------------------------------------------"
<< "\n# nom du maillage | Ref noeud | Blocages"
<< "\n#-----------------------------------------------------------"
<< flush;
// def des conditions
try
{cout << "\n cas d'un seul maillage (par defaut) : rep o "
<< "\n cas de plusieurs maillages : rep n ";
rep = lect_return_defaut(true,"o");
if (rep == "n")
{ plusieurs_maillages = true; cout << "\n --> les prochaines CL seront associees a un nom de maillage ";};
rep="_"; // init
// boucle globale
while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
{ cout << "\n (0 ou f) (fin) "
<< "\n (1) def d'une nouvelle condition "
<< "\n ";
rep = lect_return_defaut(false,"f");
if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie directe
break;
int num = ChangeEntier(rep);
bool choix_valide=false;
if ((num >= 0)&&(num<=1))
{ choix_valide=true; }
else { cout << "\n Erreur on attendait un entier entre 0 et 1 !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour arreter le programme";
choix_valide=false;
};
switch (num)
{ case 0: // sortie
{ break;} // normalement cela a déjà été filtré avant
case 1: // def d'une liste d'elements associe a un nom de loi
{ DdlLim unddl; // init
unddl.Info_commande_DdlLim(sort,plusieurs_maillages);
break;
}
default:
cout << "\n le cas "<<rep<<" n'est pas traite !!, bizarre, il faut se plaindre !! ";
};
};
}
catch (ErrSortieFinale)
// cas d'une direction voulue vers la sortie
// on relance l'interuption pour le niveau supérieur
{ ErrSortieFinale toto;
throw (toto);
}
catch (...)//(UtilLecture::ErrNouvelleDonnee erreur)
{ cout << "\n Erreur on attendait un des mots cles proposes !!, "
<< "\n redonnez une bonne valeur"
<< "\n ou taper f ou 0 pour sortir ";
};
sort << flush;
};
// -------------- fonctions internes privées -------------------------
void LesCondLim::Init_appart_groupe(bool une_variable,Enum_ddl enu,bool fixe,Noeud& noe, int cas,bool choix)
{ // traitement en fonction de cas qui représente le cas d'association de plusieurs ddl
// on vérifie que le ddl appartient au groupe
if (Dans_combinaison(cas,enu)) // cas d'un ddl du groupe
{ // le ddl appartient au groupe
// récup des enu_ddl équivalent au groupe
Tableau <Enum_ddl> tmc = MemeCombinaison(cas,enu);
int taille = tmc.Taille();
for (int i=1;i<=taille;i++)
{if(tmc(i) != enu) // on ne traite que les cas différents du ddl principal
{ if (noe.Existe_ici(tmc(i)))
{ // le ddl existe déjà, on le met à fixe
// mais on ne change pas sa valeur
if (fixe)
{ noe.Change_fixe(tmc(i),true);}
// en fait on ne met pas à libre si fixe en false, on ne vérifie pas qu'il y a superposition
// de plusieurs initialisations en libre, celle-ci pouvant venir de plusieurs raisons que l'on ne peut
// pas gérer ici : par exemple au moment de la création des éléments il y a mise en place des ddl à libre
// avant l'initialisation donc si l'on impose par exemple la vitesse, X sera en souslibre !!
// else
// { noe.Change_fixe(tmc(i),false);}
}
else
// sinon on le cré, et on met à zéro
{ if (fixe)
{ if (une_variable) { Ddl inter(tmc(i),0.0,HSFIXE); noe.PlusDdl(inter);}
else { Ddl inter(tmc(i),0.0,HS_LISIBLE_FIXE); noe.PlusDdl(inter);};
}
else
{ if (une_variable) { Ddl inter(tmc(i),0.0,HSLIBRE); noe.PlusDdl(inter);}
else { Ddl inter(tmc(i),0.0,HS_LISIBLE_LIBRE); noe.PlusDdl(inter);};
};
noe.Change_val_0(tmc(i),0.);
noe.Change_val_t(tmc(i),0.);
if (choix)
noe.Change_val_tdt(tmc(i),0.);
};
};
};
}; //-- fin du cas ou le ddl fait partie d'une combinaison
};
// mise en place du blocage sur un ddl ou un groupe si besoin est
void LesCondLim::Mise_cl(int nd,DdlLim& ddlbloqu,Enum_ddl enu,Noeud& noe, int cas)
{
// traitement en fonction de cas qui représente le cas d'association de plusieurs ddl
// on vérifie que le ddl appartient au groupe sinon traitement simple
if (Dans_combinaison(cas,enu))
{ // le ddl appartient au groupe, on modifie globalement
// récup des enu_ddl équivalent au groupe
Tableau <Enum_ddl> tmc = MemeCombinaison(cas,enu);
int taille = tmc.Taille();
for (int i=1;i<=taille;i++)
noe.Change_fixe(tmc(i),true);
// le ddl du tableau des ddl bloqués est mis en service
(ddlbloqu.ElemLim(nd)).Met_en_service();
}
else // le ddl fixé n'appartient pas au groupe on le traite isolément
{ noe.Change_fixe(enu,true); // le noeud est fixé
// le ddl du tableau est mis en service
(ddlbloqu.ElemLim(nd)).Met_en_service();
};
};
// on retire le blocage sur un ddl ou un groupe si besoin est
void LesCondLim::Retire_cl(int nd,DdlLim& ddlbloqu,Enum_ddl enu,Noeud& noe, int cas)
{ // traitement en fonction de cas qui représente le cas d'association de plusieurs ddl
// on vérifie que le ddl appartient au groupe sinon traitement simple
if (Dans_combinaison(cas,enu))
{ // le ddl appartient au groupe, on modifie globalement
// récup des enu_ddl équivalent au groupe
Tableau <Enum_ddl> tmc = MemeCombinaison(cas,enu);
int taille = tmc.Taille();
for (int i=1;i<=taille;i++)
noe.Change_fixe(tmc(i),false);
// le ddl du tableau des ddl bloqués est mis hors service
(ddlbloqu.ElemLim(nd)).Met_hors_service();
}
else // le ddl fixé n'appartient pas au groupe on le traite isolément
{ noe.Change_fixe(enu,false); // le noeud est libéré
// le ddl du tableau est mis hors service
(ddlbloqu.ElemLim(nd)).Met_hors_service();
};
};
// vérification qu'il n'y a pas de surcharge de blocage
// choix indique si l'on vérifie à t ou à tdt
void LesCondLim::Verif_surcharge_blocage
(const LesMaillages * lesMail,const LesReferences* lesRef,const double& temps,int cas)
{ // prépa retour
bool erreur_blocage = false;
Tableau <Enum_ddl> tmc; // tableau de travail
int tabBloqTaille =tabBloq.Taille();
// on parcours le tableau de ddl bloques
for (int i=1;i<= tabBloqTaille;i++)
{ DdlLim& tabBloq_i = tabBloq(i);
// recup de la reference correspondant au mot cle
const ReferenceNE & ref =
((ReferenceNE &) lesRef->Trouve(tabBloq_i.NomRef(),tabBloq_i.NomMaillage()));
if (!((ref.Indic() == 4) && // dans le cas des conditions de tangence sur
(tabBloq_i.TypeDeCL()==TANGENTE_CL) ) // les arrêtes on n'applique pas ces vérifs
)
{int reftaille = ref.Taille();
for (int nn =1; nn<= reftaille;nn++)
{int tabBloqitaille = tabBloq_i.Taille();
// dans le cas d'un champ, pour chaque ddl on a un noeud associé, il ne faut donc pas itérer
// sur les noeuds, pour cela on modifie les borne de la boucle pour ne faire qu'un seul bon passage
int idebut=1; int ifinfin = tabBloqitaille;// début normale
if (tabBloq_i.Champ()) {idebut = nn; ifinfin = nn;};
for (int nd=idebut;nd<= ifinfin ;nd++)
{Ddl ddl = tabBloq_i.ElemLim(nd);
// pour le ddlLim, 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 (tabBloq_i.Pas_a_prendre_en_compte(temps)) break;
Noeud & noe=lesMail->Noeud_LesMaille(ref.Nbmaille(),ref.Numero(nn));
// on regarde si l'on a fixé plusieurs fois ou libéré plusieurs foix
// cas de deplacements imposes en coordonnees entrainees on change les Ui en Xi
// if (noe.Existe_ici(X1) && (strchr(ddl.Nom(),'U') != NULL))
if (noe.Existe_ici(X1) && (PremierDdlFamille(ddl.Id_nom())==UX))
ddl.Change_nom(UxyzXi(ddl.Id_nom()));
// récup des enu_ddl équivalent au groupe, pour l'instant on n'a que la combinaison 1 qui comporte plus d'un élément
if (Dans_combinaison(cas,ddl.Id_nom()))
{tmc = MemeCombinaison(cas,ddl.Id_nom());}
else
// sinon pour l'instant on fait comme si cas == 0 c'est à dire pas de combinaison
{tmc = MemeCombinaison(0,ddl.Id_nom());};
int tailletmc = tmc.Taille();
for (int itc=1;itc <= tailletmc;itc++)
{if (noe.Ddl_sous_ou_sur_fixe(tmc(itc)))
// cas d'un problème éventuel
{ // message d'avertissement
if (ParaGlob::NiveauImpression() >= 6)
cout << "\n ***** ATTENTION *****, le ddl " << ddl.Nom() << " du noeud " << noe.Num_noeud()
<< " du maillage " << lesMail->NomMaillage(noe.Num_Mail()) << " est bloque plusieurs fois";
if (ParaGlob::NiveauImpression() >= 7)
cout << ", cela indique que plusieurs conditions limites sont supperposees";
if (ParaGlob::NiveauImpression() >= 8)
{ cout << " \n temps = " << temps << ", reference de blocage, et ddl limite correspondant";
ref.Affiche(); tabBloq_i.Affiche();
cout << "\nvoid LesCondLim::Initial(LesMaillages * lesMail) " << endl;
}
// remise à normal du ddl pour que le calcul puisse continuer
noe.Retour_a_la_normal_sur_ou_sous_fixe(tmc(itc));
erreur_blocage = true; // pour un traitement global d'erreur éventuel
};
}; //-- fin du for (int itc=1;itc <= tailletmc;itc++)
}; //-- fin du for (int nd=idebut;nd<= ifinfin ;nd++)
}; //-- fin du for (int nn =1; nn<= reftaille;nn++)
}; //-- fin du if (!((ref.Indic() == 4) &&(tabBloq_i.TypeDeCL()==TANGENTE_CL) )
}; //-- fin du for (int i=1;i<= tabBloqTaille;i++)
};
// fourni la liste des ddl associé de même dim, pour un du groupe et en fonction du cas d'association
// ramène une référence sur tab_travail qui est mis à jour
Tableau <Ddl>& LesCondLim::Ddl_associe (Ddl& ddl,Noeud& noe,Tableau <Ddl>& tab_travail,int cas)
{ // cas de deplacements imposes en coordonnees entrainees on change les Ui en Xi
// if (noe.Existe_ici(X1) && (strchr(ddl.Nom(),'U') != NULL)) ddl.Change_nom(UxyzXi(ddl.Id_nom()));
if (noe.Existe_ici(X1) && (PremierDdlFamille(ddl.Id_nom())==UX)) ddl.Change_nom(UxyzXi(ddl.Id_nom()));
Enum_ddl enu = ddl.Id_nom(); // pour simplifier
// traitement en fonction de cas qui représente le cas d'association de plusieurs ddl
// on vérifie que le ddl appartient au groupe sinon traitement simple
if (Dans_combinaison(cas,enu))
{ // le ddl appartient au groupe, on modifie globalement
// récup des enu_ddl équivalent au groupe
Tableau <Enum_ddl> tmc = MemeCombinaison(cas,enu);
int taille = tmc.Taille();
for (int i=1;i<=taille;i++)
{ ddl.Change_nom(tmc(i));
tab_travail(i) = ddl;
}
}
else // le ddl fixé n'appartient pas au groupe on le traite isolément
{ tab_travail.Change_taille(1);
tab_travail(1) = ddl;
};
return tab_travail;
};
// cas particulier des mouvements solides, dans le second passage pour la méthode MiseAJour_tdt
void LesCondLim::MiseAjour_tdt_second_passage_mvtSolide(const double& mult_gene,LesMaillages * lesMail
,const double& deltat,int cas
,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD,const double& coef
,DdlLim& tabBloq_i,const ReferenceNE & ref,const double& temps,Enum_ddl en_ddl)
{ bool tous_les_blocages = true;
if (en_ddl != NU_DDL) tous_les_blocages = false;
int reftaille = ref.Taille();
int dima = ParaGlob::Dimension();
if(ParaGlob::AxiSymetrie())
// cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
// dimension-1 coordonnées donc on décrémente
dima--;
// on regarde si les temps dépendent d'une fct nD
// si oui on modifie les bornes du ddl
if (tabBloq_i.Temps_depend_nD())
LesCondLim::Mise_a_jour_t_minmax_ddlLim(tabBloq_i,lesFonctionsnD);
// pour le ddlLim, 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 (tabBloq_i.Pas_a_prendre_en_compte(temps))
return;
bool actif_pour_le_temps = tabBloq_i.Temps_actif(temps); // pour simplifier
if (!actif_pour_le_temps)
return; // je ne vois pas trop pourquoi, mais semble cohérent avec le prog général (à voir)
// petite vérif
int tabBloqitaille = tabBloq_i.Taille(); // normalement il y a uniquement les déplacements
#ifdef MISE_AU_POINT
if (tabBloqitaille != dima)
{ cout << "\nErreur : le nombre de ddl bloque pour un mouvement solide doit etre egale a la dimension du pb "
<< " ici ParaGlob::Dimension() = " << dima << " et le nombre de ddl bloque = " << tabBloqitaille ;
cout << " \n LesCondLim::MiseAjour_tdt_second_passage_mvtSolide(... ";
if (tempsCL.Comptage_en_cours()) tempsCL.Arret_du_comptage();
Sortie(1);
};
#endif
// --- dans le cas où il y a des centres de rotation qui sont des positions de noeud, on renseigne
// a) récupération des centres de rotation noeud, éventuellement
const list <String_et_entier>& lis_centre_noeud = (tabBloq_i.MouvementSolide())->Liste_ident_centreNoeud();
if (lis_centre_noeud.size() != 0)
{ list <String_et_entier>::const_iterator ict,ictfin=lis_centre_noeud.end();
list <Coordonnee> list_coor; // liste des coordonnées des noeuds centre de rotation
for (ict = lis_centre_noeud.begin();ict!=ictfin;ict++)
{if ((*ict).nom == "")
// cas où on n'a pas de nom de maillage
{ list_coor.push_back(lesMail->Noeud_LesMaille(1, (*ict).n).Coord2()); }
else // cas où on a plusieurs maillages
{ int num_maill= lesMail->NumMaillage((*ict).nom);
list_coor.push_back(lesMail->Noeud_LesMaille(num_maill, (*ict).n).Coord2());
};
};
// b) maintenant on passe l'info au mouvement solide
(tabBloq_i.MouvementSolide())->RenseigneCentreNoeud(list_coor);
};
// maintenant soit le ddlLim est actif ou il change de statut: actif à non actif
// on boucle sur les noeuds de la référence
for (int nn =1; nn<= reftaille;nn++)
{// ici on travaille sur les dima ddl de déplacements en même temps:
// mais on se sert du premier comme indicateur
Ddl ddl = tabBloq_i.ElemLim(1); // le premier ddl normalement est UX
// on fait une manip sur les UX <-> Xi pour distinguer les cas méca du solide et les autres
Noeud & noe=lesMail->Noeud_LesMaille(ref.Nbmaille(),ref.Numero(nn));
if (noe.Existe_ici(X1))
// cas de deplacements imposes en entraine on change donc les Ui en Xi
ddl.Change_nom(UxyzXi(ddl.Id_nom()));
bool a_considerer = tous_les_blocages;
if (! a_considerer) // cas ou on ne veut que certain blocage, a_bloque est faux
{if (Meme_famille(en_ddl,ddl.Id_nom())) a_considerer = true;};
if (a_considerer)
{ // def du point qui contiendra les coordonnées finales après rotation
Coordonnee M(dima);
// traitement en fonction du cas où il y courbe de charge ou pas
if ((tabBloq_i.Nom_courbe(1) != "")&&(tabBloq_i.NomF_charge(1) == ""))
{ // cas d'une courbe de charge, récup de la courbe
// pour les mouvements solides la courbe de charge et l'échelle sont stockées dans le premier ddl
Courbe1D * pt_courbe = lesCourbes1D->Trouve(tabBloq_i.Nom_courbe(1));
if (tabBloq_i.BlocageRelatif()) // cas d'une modif relativement au temps précédent
{ // mise à jour de la valeur de l'incrément (et non ce sa valeur) sur deltat
M = noe.Coord1(); // on travaille donc à partir des coordonnées à t
double amplitude = mult_gene * tabBloq_i.Echelle_courbe(1)
* ((pt_courbe->Valeur(temps)) - (pt_courbe->Valeur(temps-deltat))) ;
(tabBloq_i.Const_MouvementSolide())->AppliqueMvtSolide (M,amplitude);
}
else
{ // la courbe donne en fonction du temps la valeur de l'amplitude de 0 au temps présent
// et ici on considère la totalité du chargement de 0 au temps actuel
M = noe.Coord0(); // on travaille donc avec les coordonnées initiales
double amplitude = mult_gene * (pt_courbe->Valeur(temps)) * tabBloq_i.Echelle_courbe(1);
(tabBloq_i.Const_MouvementSolide())->AppliqueMvtSolide (M,amplitude);
};
}
else if ((tabBloq_i.NomF_charge(1) != "")&&(tabBloq_i.Nom_courbe(1) == ""))
{ // cas d'une fonction nD de charge, récup
Fonction_nD * pt_fctnD = lesFonctionsnD->Trouve(tabBloq_i.NomF_charge(1));
// on commence par récupérer les conteneurs des grandeurs à fournir
List_io <Ddl_enum_etendu>& li_enu_scal = pt_fctnD->Li_enu_etendu_scalaire();
List_io <TypeQuelconque >& li_quelc = pt_fctnD->Li_equi_Quel_evolue();
// on va utiliser la méhode Valeur_multi pour les grandeurs strictement scalaire
Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
(noe, TEMPS_tdt,li_enu_scal));
// on utilise la méthode des grandeurs évoluées pour les Coordonnees et Tenseur
Valeurs_Tensorielles_interpoler_ou_calculer(noe, TEMPS_tdt,li_quelc);
// calcul de la valeur et retour dans tab_ret
Tableau <double> & tab_ret = pt_fctnD->Valeur_FnD_Evoluee
(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
#ifdef MISE_AU_POINT
if (tab_ret.Taille() != 1)
{cout << "\n*** Erreur : la fonction nD retourne un vecteur et non un scalaire comme escompte "
<< "\n *** blocage via une fonction nD pour l'evolution d'un mouvement solide "
<< " \n LesCondLim::MiseAjour_tdt_second_passage_mvtSolide(... ";
if (tempsCL.Comptage_en_cours()) tempsCL.Arret_du_comptage();
Sortie(1);
};
#endif
if (tabBloq_i.BlocageRelatif()) // cas d'une modif relativement au temps précédent
{ // pour l'instant a priori ce n'est pas possible car le temps
// est une variable globale que l'on ne peut pas modifier pour les fonctions nD
// il faut donc utiliser conjointement une courbe1D pour le temps et la fonction nD pour le reste
cout << "\n *** blocage relatif d'un mouvement solide avec uniquement une fonction nD: ce n'est pas possible"
<< " pour avoir un blocage relatif il faut utiliser conjointement une courbe de charge "
<< " pour le temps et une fonction nD pour le reste !!!!"
<< " \n LesCondLim::MiseAjour_tdt_second_passage_mvtSolide(... ";
if (tempsCL.Comptage_en_cours()) tempsCL.Arret_du_comptage();
Sortie(1);
}
else
{ // la fonction donne la valeur de l'amplitude de 0 au temps présent
// et ici on considère la totalité du chargement de 0 au temps actuel
M = noe.Coord0(); // on travaille donc avec les coordonnées initiales
double amplitude = mult_gene * (tab_ret(1)) * tabBloq_i.Echelle_courbe(1);
(tabBloq_i.Const_MouvementSolide())->AppliqueMvtSolide (M,amplitude);
};
}
else if ((tabBloq_i.NomF_charge(1) != "")&&(tabBloq_i.Nom_courbe(1) != ""))
{ // cas d'une fonction nD de charge, récup
Fonction_nD * pt_fctnD = lesFonctionsnD->Trouve(tabBloq_i.NomF_charge(1));
// on commence par récupérer les conteneurs des grandeurs à fournir
List_io <Ddl_enum_etendu>& li_enu_scal = pt_fctnD->Li_enu_etendu_scalaire();
List_io <TypeQuelconque >& li_quelc = pt_fctnD->Li_equi_Quel_evolue();
// on va utiliser la méhode Valeur_multi pour les grandeurs strictement scalaire
Tableau <double> val_ddl_enum(Valeur_multi_interpoler_ou_calculer
(noe, TEMPS_tdt,li_enu_scal));
// on utilise la méthode des grandeurs évoluées pour les Coordonnees et Tenseur
Valeurs_Tensorielles_interpoler_ou_calculer(noe, TEMPS_tdt,li_quelc);
// calcul de la valeur et retour dans tab_ret
Tableau <double> & tab_ret = pt_fctnD->Valeur_FnD_Evoluee
(&val_ddl_enum,&li_enu_scal,&li_quelc,NULL,NULL);
#ifdef MISE_AU_POINT
if (tab_ret.Taille() != 1)
{cout << "\n*** Erreur : la fonction nD retourne un vecteur et non un scalaire comme escompte "
<< "\n *** blocage via une fonction nD pour l'evolution d'un mouvement solide "
<< " \n LesCondLim::MiseAjour_tdt_second_passage_mvtSolide(... ";
if (tempsCL.Comptage_en_cours()) tempsCL.Arret_du_comptage();
Sortie(1);
};
#endif
// idem pour la courbe 1D
Courbe1D * pt_courbe = lesCourbes1D->Trouve(tabBloq_i.Nom_courbe(1));
if (tabBloq_i.BlocageRelatif()) // cas d'une modif relativement au temps précédent
{ // mise à jour de la valeur de l'incrément (et non ce sa valeur) sur deltat
M = noe.Coord1(); // on travaille donc à partir des coordonnées à t
double amplitude = mult_gene * tabBloq_i.Echelle_courbe(1) * tab_ret(1)
* ((pt_courbe->Valeur(temps)) - (pt_courbe->Valeur(temps-deltat))) ;
(tabBloq_i.Const_MouvementSolide())->AppliqueMvtSolide (M,amplitude);
}
else
{ // la courbe donne en fonction du temps la valeur de l'amplitude de 0 au temps présent
// et ici on considère la totalité du chargement de 0 au temps actuel
M = noe.Coord0(); // on travaille donc avec les coordonnées initiales
double amplitude = mult_gene * (pt_courbe->Valeur(temps))
* tab_ret(1) * tabBloq_i.Echelle_courbe(1);
(tabBloq_i.Const_MouvementSolide())->AppliqueMvtSolide (M,amplitude);
};
}
else
// cas d'un mouvement à valeur fixe, on calcul l'accroissement par rapport au pas précédent
// coef intègre le multiplicateur global: mult_gene, et intègre l'acroissement par rapport au pas précédent
{ M = noe.Coord1();
(tabBloq_i.Const_MouvementSolide())->AppliqueMvtSolide (M,coef);
};
// maintenant on s'occupe de la mise à jour ou non des positions du noeud
for (int nd=1;nd<= tabBloqitaille ;nd++) // en fait ici nd =1 pour UX, =2 pour UY et =3 pour UZ
{Ddl ddl = tabBloq_i.ElemLim(nd);
if (noe.Existe_ici(X1))
// cas de deplacements imposes en entraine on change donc les Ui en Xi
ddl.Change_nom(UxyzXi(ddl.Id_nom()));
Enum_ddl ddlenu= ddl.Id_nom(); // pour simplifier
bool une_variable = noe.UneVariable(ddlenu); // pour simplifier
// cas des variables: si le ddl du noeud est en service on continue sinon on ne fait rien
// ou cas d'une donnée et le temps actif, mais si on arrive ici le temps est forcément actif
if ( ( une_variable && noe.En_service(ddlenu)) ||(!une_variable) )
{ // gestion des surcharges de blocage
// au second passage on fixe les ddl actifs
Mise_cl(nd,tabBloq_i,ddlenu,noe,cas);
// on met à jour les coordonnées finales
noe.Change_val_tdt(ddlenu,M(nd)); // car nd =1 pour UX, =2 pour UY, =3 pour UZ
};//-- fin du test si le ddl du noeud est en service
}; //-- fin de la boucle sur tabBloq_i
};//-- fin du test si le noeud est à considérer ou pas
}; //-- fin de la boucle sur nn
};
// mise à jour et calcul éventuel du torseur de réaction: uniquement pour les ddl X1, X2, X3
// --> pour au final obtenir le torseur des efforts globaux résultant de l'application d'un DdlLim
void LesCondLim::CalculTorseurReaction(TorseurReac& tr, const Noeud& noe, ReactStoc& reac)
{ int dimension = ParaGlob::Dimension();
if(ParaGlob::AxiSymetrie())
// cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
// dimension-1 coordonnées donc on décrémente
dimension--;
switch (dimension)
{ case 1: // pas de moment, et uniquement une résultante suivant x
if (reac.ddl.Id_nom() == X1) tr.resultante(1) += reac.ddl.Valeur();
break;
case 2 : // un moment autour de z, et deux composantes de résultante
// le moment est en dim 2, on stocke le moment dans la première composante !!!
switch (reac.ddl.Id_nom())
{ case X1:
{ tr.resultante(1) += reac.ddl.Valeur();
tr.moment(1) -= noe.Valeur_tdt(X2) * reac.ddl.Valeur(); // correspond à z
break;
};
case X2:
{ tr.resultante(2) += reac.ddl.Valeur();
tr.moment(1) += noe.Valeur_tdt(X1) * reac.ddl.Valeur(); // correspond à z
break;
};
default: break;
}
break;
case 3 : // 3 composante de moment et de résultante
switch (reac.ddl.Id_nom())
{ case X1:
{ tr.resultante(1) += reac.ddl.Valeur();
tr.moment(2) += noe.Valeur_tdt(X3) * reac.ddl.Valeur();
tr.moment(3) -= noe.Valeur_tdt(X2) * reac.ddl.Valeur();
break;
};
case X2:
{ tr.resultante(2) += reac.ddl.Valeur();
tr.moment(1) -= noe.Valeur_tdt(X3) * reac.ddl.Valeur();
tr.moment(3) += noe.Valeur_tdt(X1) * reac.ddl.Valeur();
break;
};
case X3:
{ tr.resultante(3) += reac.ddl.Valeur();
tr.moment(1) += noe.Valeur_tdt(X2) * reac.ddl.Valeur();
tr.moment(2) -= noe.Valeur_tdt(X1) * reac.ddl.Valeur();
break;
};
default: break;
}
break;
// les autres cas ne sont pas pris en compte
};
};
// mise en place des conditions linéaires imposées par les données d'entrée
// expression de la raideur et du second membre dans un nouveau repere
// ramène si oui ou non, il y a eu un changement effectué
// vec2 : est un second vecteur éventuel (si != NULL) sur lequel on impose les mêmes CL que vecglob
// mais sans sauvegarde (correspond par exemple à une partie de vecglob)
bool LesCondLim::CoLinCHrepere_int(Mat_abstraite & matglob,Vecteur& vecglob
,const Nb_assemb& nb_casAssemb,Vecteur* vec2)
{
#ifdef UTILISATION_MPI
// cas d'un calcul //, pour l'instant seule la (ou les) matrices du CPU 0 sont concernées
if (ParaGlob::Monde()->rank() != 0)
return true;
#endif
// on boucle sur le tableau de conditions limites linéaires enregistré
// et pour chaque element on impose une condition lineaire
bool modification = false; // init du retour
int tabTaille = tab_CLinApplique.Taille();
for (int i=1;i<= tabTaille; i++)
{int sous_taille = tab_CLinApplique(i).Taille();
for (int j=1; j<= sous_taille; j++)
{ Condilineaire& condi = tab_CLinApplique(i)(j);
//debug
//cout << "\n LesCondLim::CoLinCHrepere_int " << condi;
//fin debug
// on n'intervient que si la condition est exploitable c-a-d Iddl() > -1
if (condi.Iddl() > -1)
{ // calcul des pointeurs d'assemblage
condi.ConditionPourPointeursAssemblage(nb_casAssemb);
// application de la condition
condlim(nb_casAssemb.n).CondlineaireCHRepere
( matglob,vecglob,condi.Pt_t(),condi.Val(),0.,vec2); // ancienne version
// la valeur imposée est systématiquement 0 comme pour le cas des autres conditions bloquée
// car la résolution donnera delta_ddl' qui doit être null pour les ddl imposés
modification=true;
};
};
};
// affichage éventuelle de la matrice de raideur et du second membre
if ((ParaGlob::NiveauImpression() >= 10) && (tabTaille != 0))
{ string entete = " affichage de la matrice apres changements de reperes dus aux conditions lineaires ";
matglob.Affichage_ecran(entete);
entete = " affichage du second membre apres changements de reperes dus aux conditions lineaires ";
vecglob.Affichage_ecran(entete);
};
// retour du fait qu'il y a eu ou non une modification faite
return modification;
};
// effacement du marquage de ddl bloque du au conditions lineaire extérieures (hors du contact par exemple)
void LesCondLim::EffMarque()
{ // préparation
// on boucle sur le tableau des conditions limites linéaires imposées réellement
int tabTaille = tab_CLinApplique.Taille();
for (int icondli=1;icondli<= tabTaille; icondli++)
{ Tableau < Condilineaire > & t_condiAppli = tab_CLinApplique(icondli);
int nbcondi = t_condiAppli.Taille();
// on boucle sur les conditions
for (int ico=1;ico<=nbcondi;ico++)
{ Condilineaire & condi = t_condiAppli(ico); // pour simplifier
// on n'intervient que si la condition est exploitable c-a-d Iddl() > -1
if (condi.Iddl() > -1)
{ // récup du noeud principal
Noeud * noe=condi.Noe();
noe->Change_fixe(condi.Tab_Enum()(1),false);
};
};
};
};
// def de la largeur de bande en fonction des conditions linéaire limite en entrée
// casAssemb : donne le cas d'assemblage en cours
// les condi linéaires ne donnent pas des largeurs de bande sup et inf égales !!!
// demi = la demi largeur de bande ,
// total = le maxi = la largeur sup + la largeur inf +1
// cumule = la somme des maxis, ce qui donnera la largeur finale, due à des multiples multiplications: une par conditions linéaires
// dans le cas où on tiens compte des conditions linéaires par rotation (c-a-d sans multiplicateur ou pénalisation)
// en retour, ramène un booleen qui :
// = true : si la largeur de bande en noeud est supérieure à 1
// = false : si non, ce qui signifie dans ce cas qu'il n'y a pas d'augmentation de la largeur
// en noeud
bool LesCondLim::Largeur_Bande(int& demi,int& total,const Nb_assemb& casAssemb
,LesMaillages * lesMail,LesReferences* lesRef,int& cumule)
{ demi = total = cumule = 0; // initialisation
bool retour = false; // par défaut
int nb_ass = casAssemb.n;
// on boucle sur le tableau et pour chaque condition
int tabTaille = tab_iocondiline.Taille(); // le nombre de condition
for (int icondli=1;icondli<= tabTaille; icondli++)
{I_O_Condilineaire& iocondiline_i = tab_iocondiline(icondli); // pour simplifier
// recup de la reference principal correspondant au mot cle
const ReferenceNE & refp =
((ReferenceNE &) lesRef->Trouve(iocondiline_i.NomRef(),iocondiline_i.NomMaillage()));
int nb_n_princ = refp.Taille();
// recup du tableau des références secondaires associées si elles existent
const Tableau <string>& nomRefassocie = iocondiline_i.ReferenceAssociees();
const Tableau <string > & nomMaillageAsoociees = iocondiline_i.NomMaillageAssociees();
int tailrefasso = nomRefassocie.Taille();
Tableau <const Tableau <int> * > tab_numNoeud_associe(tailrefasso);
Tableau <int> tab_numMail_associe(tailrefasso);
if (tailrefasso != 0)
{retour = true; // comme il y a des ref associés, la largeur en noeud sera > à 1
for (int k=1;k<=tailrefasso;k++)
{const string * nom_maillage=NULL;
if (iocondiline_i.NomMaillage() != NULL) nom_maillage=&nomMaillageAsoociees(k);
const ReferenceNE & refasso =
((ReferenceNE &) lesRef->Trouve(nomRefassocie(k),nom_maillage));
tab_numNoeud_associe(k) = & refasso.Tab_num(); // recup tableau des autres noeuds associés
tab_numMail_associe(k)= refasso.Nbmaille();
};
};
// on boucles sur les noeuds de la ref principale
int tail_t_noe = tailrefasso+1;
Tableau <Noeud *> t_noe(tail_t_noe); // tableau de travail
// dans la boucle qui suit on définit t_noe, c'est à dire l'ensemble des noeuds
// concernés par la condition linéaire.
// puis avec ce tableau, on en déduit la largeur de bande associée
for (int in=1;in<=nb_n_princ;in++)
{ // récup du noeud principal
Noeud & noe=lesMail->Noeud_LesMaille(refp.Nbmaille(),refp.Numero(in));
t_noe(1)= &noe;
// on ne continue que si le type de ddl de la condition limite est actif pour le noeud
// et que c'est une variable, si ce n'est pas une variable on n'en tient pas compte
// on ne test que le premier s'il s'agit d'un vecteur (car a priori tout le type est actif en même temps)
Enum_ddl enu_condline= iocondiline_i.TypeEnu(); // pour simplifier
if (enu_condline==UX) enu_condline = X1; // les ui sont géré avec les xi
if (noe.UneVariable(enu_condline) && noe.En_service(enu_condline))
{// récupération des noeuds associés, on utilise le même indice dans les ref associées que
// dans la ref principale
for (int ia = 1;ia<=tailrefasso;ia++)
t_noe(ia+1) = &(lesMail->Noeud_LesMaille(tab_numMail_associe(ia),(*tab_numNoeud_associe(ia))(in)));
// maintenant on va effectivement pouvoir calculer la largeur de bande correspondant
// aux noeuds du tableau t_noe
// 1) on a par défaut au moins une relation entre les ddl du noeud principal
int diprinc = noe.NB_ddl_actif_casAssemb(nb_ass);
if ( diprinc-1 > demi) demi = diprinc-1;
if ( (2*diprinc-1) > total) total = 2*diprinc-1;
cumule += 2*diprinc-1;
// 2) maintenant on s'occupe de la relation entre les différents noeuds de numéros différencts
int maxiPourLaCondition=0; // stocke le maxi pour chaque condition linéaire
for (int inoe=1; inoe<= tail_t_noe;inoe++)
for ( int jnoe=inoe+1; jnoe<=tail_t_noe;jnoe++)
{ Noeud & nne = *(t_noe(inoe));
Noeud & nno = *(t_noe(jnoe));
int di=0;
if (nne.PosiAssemb(nb_ass) >= nno.PosiAssemb(nb_ass))
{ di = nne.PosiAssemb(nb_ass) - nno.PosiAssemb(nb_ass)
+ nne.NB_ddl_actif_casAssemb(nb_ass);
}
else
{ di = nno.PosiAssemb(nb_ass) - nne.PosiAssemb(nb_ass)
+ nno.NB_ddl_actif_casAssemb(nb_ass);
};
if ( di > demi) demi = di;
if ( di > maxiPourLaCondition) maxiPourLaCondition = di;
if ( di > total) total = di;
// cumule += di;
};
cumule += maxiPourLaCondition;
};
}; // -- fin de la boucle sur les noeuds de la liste principale
}; // -- fin de la boucle sur le tableau des conditions linéaire
// prise en compte de la diagonale
demi += 1; total += 1;
// retour
return retour;
};
// dimensionnement du tableau des torseurs ainsi que des tableaux ttRG et ttorBloq
// en fonction de tabBloq (utilisé plusieurs fois), puis de ttRGCLL en fonction de tab_iocondiline
void LesCondLim::DimensionneTorseurs()
{ // dimensionnement du tableau des torseurs résultants
// 1) on s'occupe tout d'abord des ddl bloqués
int taille = tabBloq.Taille();
ttRG.Change_taille(taille);
int dima = ParaGlob::Dimension();
if(ParaGlob::AxiSymetrie())
// cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
// dimension-1 coordonnées donc on décrémente
dima--;
// on remplit le tableau ttRG
list <Deux_String> li_nomRef; // liste de travail:
list <string> li_nomRef_CL; // idem, mais spécifique aux CL
// sert ensuite pour définir ttRG_noms_ref
int taille_tors=0;
// on en profite pour définir un tableau de nom de ref qui contiendra les infos
// en string nécessaires pour cibler les composantes du torseur, externalisées comme
// grandeurs globales
for (int i=1;i<=taille;i++)
if (tabBloq(i).Existe_ici_un_deplacement())
{// on a un candidat possible, on regarde si la référence n'existe pas
Deux_String candid(tabBloq(i).NomRef(),tabBloq(i).NomRef()); // le premier string ici est pour remplir
string nom_Ref_CL(tabBloq(i).NomRef());
bool avec_nom_maillage=false;
if (tabBloq(i).NomMaillage() != NULL)
{candid.nom1 = *(tabBloq(i).NomMaillage());avec_nom_maillage=true;
nom_Ref_CL = *(tabBloq(i).NomMaillage()) +"_"+ nom_Ref_CL;
};
list <Deux_String>::iterator ili,ilifin=li_nomRef.end();
int it=1; // future position dans le tableau tab_torseurReac
for (ili=li_nomRef.begin();ili!=ilifin;ili++,it++)
if (*ili == candid) break;
if (ili == li_nomRef.end())
{// aucun élément trouvé, on ajoute un nouveau
li_nomRef.push_back(candid);
li_nomRef_CL.push_back(nom_Ref_CL);
taille_tors++; ttRG(i)=taille_tors;
}
else // on a trouvé un élément identique déjà existant de numéro it
{ttRG(i)=it;};
};
// 2) puis on s'occupe des CLL
int taille_tors_CLL=0;
list <string> li_nomRef_CLL; // liste de travail, mais spécifique aux CLL
// sert ensuite pour définir ttRGCLL_noms_ref
// on boucle sur le tableau initiale des conditions lineaires en entrée
int tabCLLTaille = tab_iocondiline.Taille();
ttRGCLL.Change_taille(tabCLLTaille); // premier dimensionnement
// on en profite pour définir un tableau de nom de ref qui contiendra les infos
// en string nécessaires pour cibler les composantes du torseur, externalisées comme
// grandeurs globales
for (int icondli=1;icondli<= tabCLLTaille; icondli++)
{I_O_Condilineaire& iocondiline_i = tab_iocondiline(icondli); // pour simplifier
// on regarde s'il faut considérer la condition linéaire, en fonction de en_ddl
Enum_ddl enu_condline= iocondiline_i.TypeEnu(); // pour simplifier
if ((Meme_famille(enu_condline,UX))||(Meme_famille(enu_condline,X1)))
{// récup des références secondaires éventuelles
const Tableau <string> & tabnomRef = iocondiline_i.ReferenceAssociees();
int tabnomRefTaille = tabnomRef.Taille();
const Tableau <string > & nom_mail_associe = iocondiline_i.NomMaillageAssociees();
// second dimensionnement
ttRGCLL(icondli).Change_taille(tabnomRefTaille+1);
// maintenant on rempli le tableau
// a) tout d'abord la ref principal (on encapsule)
{Deux_String candid(iocondiline_i.NomRef()+"CLL",iocondiline_i.NomRef()+"CLL");
string nom_Ref_CLL(iocondiline_i.NomRef()+"CLL");
bool avec_nom_maillage=false;
if (iocondiline_i.NomMaillage() != NULL)
{candid.nom1 = *(iocondiline_i.NomMaillage());avec_nom_maillage=true;
nom_Ref_CLL = *(iocondiline_i.NomMaillage()) +"_"+ nom_Ref_CLL;
};
// on regarde s'il existe déjà un élément adoc ou s'il faut en ajouter un
list <Deux_String>::iterator ili,ilifin=li_nomRef.end();
int it=1; // future position dans le tableau tab_torseurReac
for (ili=li_nomRef.begin();ili!=ilifin;ili++,it++)
if (*ili == candid) break;
if (ili == li_nomRef.end())
{// aucun élément trouvé, on ajoute un nouveau
li_nomRef.push_back(candid);
li_nomRef_CLL.push_back(nom_Ref_CLL);
taille_tors++; taille_tors_CLL++; ttRGCLL(icondli)(1)=taille_tors;
}
else // on a trouvé un élément identique déjà existant de numéro it
{ttRGCLL(icondli)(1)=it;
};
}; // fin encapsulage
// b) maintenant on regarde les références secondaires
for (int ir=1;ir<=tabnomRefTaille;ir++)
{ Deux_String candid(tabnomRef(ir)+"CLL",tabnomRef(ir)+"CLL");
string nom_Ref_CLL(tabnomRef(ir)+"CLL");
if (iocondiline_i.NomMaillage() != NULL)
{candid.nom1 = nom_mail_associe(ir);
nom_Ref_CLL = nom_mail_associe(ir) +"_"+ nom_Ref_CLL;
};
// on regarde s'il existe déjà un élément adoc ou s'il faut en ajouter un
list <Deux_String>::iterator ili,ilifin=li_nomRef.end();
int it=1; // future position dans le tableau tab_torseurReac
for (ili=li_nomRef.begin();ili!=ilifin;ili++,it++)
if (*ili == candid) break;
if (ili == li_nomRef.end())
{// aucun élément trouvé, on ajoute un nouveau
li_nomRef.push_back(candid);
li_nomRef_CLL.push_back(nom_Ref_CLL);
taille_tors++;taille_tors_CLL++; ttRGCLL(icondli)(ir+1)=taille_tors;
}
else // on a trouvé un élément identique déjà existant de numéro it
{ttRGCLL(icondli)(ir+1)=it;};
}; // fin boucle sur les références secondaires
}; //-- fin du test if ((Meme_famille(enu_condline,UX))||(Meme_famille(enu_condline,X1)))
}; //-- fin de la boucle sur les conditions linéaires
// maintenant on dimensionne le tableau de torseurs
int taille_tors_bloqu = taille_tors - taille_tors_CLL;
tab_torseurReac.Change_taille(taille_tors);
for (int ia=1;ia<=taille_tors;ia++)
{tab_torseurReac(ia).Activation(dima);
// on définit si le torseur correspond à un ddl bloqué ou une CLL
if (ia > taille_tors_bloqu)
{tab_torseurReac(ia).bloque_ou_CLL = false;}
else
{tab_torseurReac(ia).bloque_ou_CLL = true;}
};
// maintenant on dimensionne et rempli ttorBloq
ttorBloq.Change_taille(taille_tors_bloqu);
for (int ib=1;ib<=taille;ib++)
if (ttRG(ib) != 0 )
ttorBloq(ttRG(ib)).push_back(ib); // cas d'une ref qui contient un déplacement
// et ensuite on dimensionne et rempli ttorCLL
ttorCLL.Change_taille(taille_tors);
for (int ib=1;ib<=tabCLLTaille;ib++)
{ int tai = ttRGCLL(ib).Taille();
for (int j=1;j<=tai;j++)
if (ttRGCLL(ib)(j) != 0 )
ttorCLL(ttRGCLL(ib)(j)).push_back(DeuxEntiers(ib,j)); // cas d'une ref qui contient un déplacement
};
// on définit les tableaux ttRG_noms_ref et ttRGCLL_noms_ref
int nb_RG_noms_ref = li_nomRef_CL.size();
ttRG_noms_ref.Change_taille(nb_RG_noms_ref);
{list <string>::iterator ili,ilifin=li_nomRef_CL.end();
int i=1;
for (ili = li_nomRef_CL.begin();ili != ilifin; ili++,i++)
ttRG_noms_ref(i)=(*ili);
};
ttRGCLL_noms_ref.Change_taille(li_nomRef_CLL.size());
{list <string>::iterator ili,ilifin=li_nomRef_CLL.end();
int i=1;
for (ili = li_nomRef_CLL.begin();ili != ilifin; ili++,i++)
ttRGCLL_noms_ref(i)=(*ili);
};
// on va maintenant définir des grandeurs globales qui permettront de récupérer les réactions par
// exemple via des fonctions nD
Ddl_enum_etendu ddl("comp_tors_reaction");
Ddl_etendu v(ddl);
int taille_tors_bloquplus1 = taille_tors_bloqu +1;
{int il = 1;
for (int ia=1;ia<taille_tors_bloquplus1;ia++,il++)
{// cas d'un blocage de ddl
// on va construire la chaine de caractère qui représente la composante
// 1) la résultante
int dimaPlus1 = dima+1;
for (int ic= 1; ic < dimaPlus1; ic++)
{string nom_ref="tors_"+ttRG_noms_ref(il)+"_Re_"+ChangeEntierSTring(ic);
Grandeur_Ddl_etendu grand_courant(v,nom_ref);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(COMP_TORSEUR_REACTION,nom_ref,SCALAIRE_DOUBLE);
// on définit le type quelconque associé
TypeQuelconque typQ(enuType,X1,grand_courant);
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
// si celle-ci n'existe pas déjà
if (ParaGlob::param->GrandeurGlobal(nom_ref) == NULL)
ParaGlob::param->Ajout_grandeur_consultable(&typQ,nom_ref);
}
// 2) le moment
for (int ic= 1; ic < dimaPlus1; ic++)
{string nom_ref="tors_"+ttRG_noms_ref(il)+"_Mo_"+ChangeEntierSTring(ic);
Grandeur_Ddl_etendu grand_courant(v,nom_ref);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(COMP_TORSEUR_REACTION,nom_ref,SCALAIRE_DOUBLE);
// on définit le type quelconque associé
TypeQuelconque typQ(enuType,X1,grand_courant);
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
// si celle-ci n'existe pas déjà
if (ParaGlob::param->GrandeurGlobal(nom_ref) == NULL)
ParaGlob::param->Ajout_grandeur_consultable(&typQ,nom_ref);
}
};
};
// maintenant on s'occupe des conditions concernant les CLL
{int taille_torsPlusUn = taille_tors+1;
int il = 1;
for (int ia=taille_tors_bloquplus1;ia<taille_torsPlusUn;ia++,il++)
{// cas d'un blocage de ddl
// on va construire la chaine de caractère qui représente la composante
// 1) la résultante
int dimaPlus1 = dima+1;
for (int ic= 1; ic < dimaPlus1; ic++)
{string nom_ref="tors_"+ttRGCLL_noms_ref(il)+"_Re_"+ChangeEntierSTring(ic);
Grandeur_Ddl_etendu grand_courant(v,nom_ref);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(COMP_TORSEUR_REACTION,nom_ref,SCALAIRE_DOUBLE);
// on définit le type quelconque associé
TypeQuelconque typQ(enuType,X1,grand_courant);
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
// si celle-ci n'existe pas déjà
if (ParaGlob::param->GrandeurGlobal(nom_ref) == NULL)
ParaGlob::param->Ajout_grandeur_consultable(&typQ,nom_ref);
}
// 2) le moment
for (int ic= 1; ic < dimaPlus1; ic++)
{string nom_ref="tors_"+ttRGCLL_noms_ref(il)+"_Mo_"+ChangeEntierSTring(ic);
Grandeur_Ddl_etendu grand_courant(v,nom_ref);
// on ajoute éventuellement un TypeQuelconque_enum_etendu s'il n'existe pas
// et on récupère un exemplaire
TypeQuelconque_enum_etendu enuType =
TypeQuelconque_enum_etendu::Ajout_un_TypeQuelconque_enum_etendu
(COMP_TORSEUR_REACTION,nom_ref,SCALAIRE_DOUBLE);
// on définit le type quelconque associé
TypeQuelconque typQ(enuType,X1,grand_courant);
// et on ajoute une grandeur globale qui sera indexée par le nom de référence
// si celle-ci n'existe pas déjà
if (ParaGlob::param->GrandeurGlobal(nom_ref) == NULL)
ParaGlob::param->Ajout_grandeur_consultable(&typQ,nom_ref);
}
};
};
//--- débug ---
//cout << "\n " << ttorCLL << endl;
//--- fin débug ---
};
// DdlLim : mise à jour des temps min et temps max, lorsque ceci dépendent de fonction nD
void LesCondLim::Mise_a_jour_t_minmax_ddlLim(Noeud& noe,DdlLim& ddlLim,LesFonctions_nD* lesFonctionsnD)
{// on regarde le temps min
string nom_t_min = ddlLim.Nom_fctnD_tmin();
if (nom_t_min != "")
{ Fonction_nD * fct = lesFonctionsnD->Trouve(nom_t_min); // récup de la fonction
// récup des valeurs au noeud, pour alimenter la fonction
Tableau <double> tab(noe.Valeur_multi_et_Tensorielle
(fct->Li_enu_etendu_scalaire(),fct->Li_equi_Quel_evolue())
);
// appel fonction
Tableau <double> & tab_ret = fct->Valeur_FnD_Evoluee(&tab,&fct->Li_enu_etendu_scalaire(),&fct->Li_equi_Quel_evolue(),NULL,NULL);
ddlLim.Mise_a_jour_tmin(tab_ret(1));
#ifdef MISE_AU_POINT
// on vérifie que la fonction est scalaire
if (tab_ret.Taille() != 1)
{ cout << "\n *** pb dans les parametres de passage pour l'appel de la fonction nD " << nom_t_min
<< " qui gere le temps mini "
<< " elle retourne une grandeur vectorielle "
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n LesCondLim::Mise_a_jour_t_minmax_ddlLim(..."<<endl;
Sortie(1);
};
#endif
}
string nom_t_max = ddlLim.Nom_fctnD_tmax();
if (nom_t_max != "")
{ Fonction_nD * fct = lesFonctionsnD->Trouve(nom_t_max); // récup de la fonction
// récup des valeurs au noeud, pour alimenter la fonction
Tableau <double> tab(noe.Valeur_multi_et_Tensorielle
(fct->Li_enu_etendu_scalaire(),fct->Li_equi_Quel_evolue())
);
// appel fonction
Tableau <double> & tab_ret = fct->Valeur_FnD_Evoluee(&tab,&fct->Li_enu_etendu_scalaire(),&fct->Li_equi_Quel_evolue(),NULL,NULL);
ddlLim.Mise_a_jour_tmax(tab_ret(1));
#ifdef MISE_AU_POINT
// on vérifie que la fonction est scalaire
if (tab_ret.Taille() != 1)
{ cout << "\n *** pb dans les parametres de passage pour l'appel de la fonction nD " << nom_t_max
<< " qui gere le temps maxi "
<< " elle retourne une grandeur vectorielle "
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n LesCondLim::Mise_a_jour_t_minmax_ddlLim(..."<<endl;
Sortie(1);
};
#endif
}
};
// DdlLim général: mise à jour des temps min et temps max, lorsque ceci dépendent de fonction nD
// ici les fct nD doivent dépendre uniquement de grandeur générale
void LesCondLim::Mise_a_jour_t_minmax_ddlLim(DdlLim& ddlLim,LesFonctions_nD* lesFonctionsnD)
{// on regarde le temps min
string nom_t_min = ddlLim.Nom_fctnD_tmin();
if (nom_t_min != "")
{ Fonction_nD * fct = lesFonctionsnD->Trouve(nom_t_min); // récup de la fonction
// appel fonction
Tableau <double> & tab_ret = fct->Valeur_pour_variables_globales();
ddlLim.Mise_a_jour_tmin(tab_ret(1));
#ifdef MISE_AU_POINT
// on vérifie que la fonction est scalaire
if (tab_ret.Taille() != 1)
{ cout << "\n *** pb dans les parametres de passage pour l'appel de la fonction nD " << nom_t_min
<< " qui gere le temps mini "
<< " elle retourne une grandeur vectorielle "
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n LesCondLim::Mise_a_jour_t_minmax_ddlLim(..."<<endl;
Sortie(1);
};
#endif
}
string nom_t_max = ddlLim.Nom_fctnD_tmax();
if (nom_t_max != "")
{ Fonction_nD * fct = lesFonctionsnD->Trouve(nom_t_max); // récup de la fonction
// appel fonction
Tableau <double> & tab_ret = fct->Valeur_pour_variables_globales();
ddlLim.Mise_a_jour_tmax(tab_ret(1));
#ifdef MISE_AU_POINT
// on vérifie que la fonction est scalaire
if (tab_ret.Taille() != 1)
{ cout << "\n *** pb dans les parametres de passage pour l'appel de la fonction nD " << nom_t_max
<< " qui gere le temps maxi "
<< " elle retourne une grandeur vectorielle "
<< " ce n'est pas normal !! , on arrete le calcul "
<< "\n LesCondLim::Mise_a_jour_t_minmax_ddlLim(..."<<endl;
Sortie(1);
};
#endif
}
};
// mise en place de la répercussion sur les noeuds des conditions linéaires, imposées externes (par les données d'entrées),
// ne prend pas en charge par exemple les CL dues aux contacts(gérés par CL)
// pour les paramètres de passage de la méthode: idem méthode MiseAJour_tdt
void LesCondLim::MiseAJour_condilineaire_tdt
(const double& ,LesMaillages * lesMail,const double& deltat,LesReferences* lesRef
,const double& temps,LesCourbes1D* lesCourbes1D,LesFonctions_nD* lesFonctionsnD
,const double& ,bool& ch_statut
,int ,Enum_ddl en_ddl )
{
// //----- debug
// cout << "\n ****1 LesCondLim::MiseAJour_condilineaire_tdt \n temps = " << temps << "\n";
// cout << tab_iocondiline;
// //--- fin debug
tempsCLL.Mise_en_route_du_comptage(); // temps cpu
// préparation
bool tous_les_blocages = true;
if (en_ddl != NU_DDL) tous_les_blocages = false;
// 1--- on boucle sur le tableau et pour chaque element on calcule une condition lineaire
// on n'impose pas la cl (à tdt) à mesure du balayage car, si une condition dépend de noeuds qui eux même font partie
// d'une autre condition, on utiliserait une partie des nouvelles valeurs et une partie des valeurs de l'itérations précédente !! erreur
// il y a une exception: celle des conditions de projection, qui sont effectuées dans l'ordre d'apparition. Cela peut poser des pbs si les surfaces
// de projection vont elles-même être modifiées par les conditions linéaires finales. Mais l'inverse pourrait également être vrai, donc c'est un peu
// inextricable. Donc, on laisse ainsi pour l'instant
int tabTaille = tab_iocondiline.Taille();
for (int icondli=1;icondli<= tabTaille; icondli++)
{I_O_Condilineaire& iocondiline_i = tab_iocondiline(icondli); // pour simplifier
// on regarde s'il faut considérer la condition linéaire, en fonction de en_ddl
bool a_considerer = tous_les_blocages;
Enum_ddl enu_condline= iocondiline_i.TypeEnu(); // pour simplifier
if (enu_condline==UX) enu_condline = X1; // les ui sont géré avec les xi
if (! a_considerer) // cas ou on ne veut que certain blocage, a_bloque est faux
{if (Meme_famille(en_ddl,enu_condline)) a_considerer = true;};
// I) --- un premier passage sur les changements de statut ---
// recup de la reference principal correspondant au mot cle
const ReferenceNE & refp =
((ReferenceNE &) lesRef->Trouve(iocondiline_i.NomRef(),iocondiline_i.NomMaillage()));
int nb_n_princ = refp.Taille();
Tableau < Condilineaire > & t_condiAppli = tab_CLinApplique(icondli);
t_condiAppli.Change_taille(0); // a priori 0 c'est-à-dire qu'il n'y en a pas
// on boucle sur les noeuds de la référence principale
for (int in=1;in<=nb_n_princ;in++)
{ // récup du noeud principal
Noeud & noe=lesMail->Noeud_LesMaille(refp.Nbmaille(),refp.Numero(in));
if (a_considerer)
{ bool actif_pour_le_temps = iocondiline_i.Temps_actif(temps); // pour simplifier
//debug
//cout << "\n LesCondLim::MiseAJour_condilineaire_tdt "
// << " actif_pour_le_temps= "<< actif_pour_le_temps << endl;
//fin debug
if (noe.UneVariable(enu_condline) && noe.En_service(enu_condline))
{ if ((!actif_pour_le_temps) && (iocondiline_i.Etat_validation()))
// cas du temps non actif, mais qui était actif au pas précédent
{ ch_statut = true; }
else if ((actif_pour_le_temps) && (!iocondiline_i.Etat_validation()))
{ ch_statut = true; };
}; //-- fin du test si le noeud est à considérer ou pas
};
}; // fin de la boucle sur les noeuds de la ref principale
// II) ---- un deuxième passage pour le traitement des conditions limites de projection ---
// sur un plan ou une droite
// ** je ne comprends pas pourquoi il faut l'usine à gaz Pas_a_prendre_en_compte( qui fait que si au
// temps précédent c'était actif, alors au temps actuel, même en dehors de l'intervalle c'est également à considérer
// cela conduit à des erreurs donc je supprime et met un cas plus restrictif : Pas_a_prendre_en_compte_dans_intervalle(
// mais il faudrait également changer dans tous les chargement les fct du même type : Pas_a_prendre_en_compte(
// if ((a_considerer) && (!iocondiline_i.Pas_a_prendre_en_compte(temps))
if ((a_considerer) && (!iocondiline_i.Pas_a_prendre_en_compte_dans_intervalle(temps))
&& (iocondiline_i.PlanDroite()))
{// construction des données nécessaires
// on regarde si l'on utilise un noeud rotation
const String_et_entier* mailEtNumCentreNoeud = iocondiline_i.RefNoeudRotation();
if ( mailEtNumCentreNoeud != NULL) // utilisation d'un noeud rotation, on renseigne
{ if (mailEtNumCentreNoeud->nom == "")
// cas par défaut de noeud du premier maillage
{iocondiline_i.ChangeCentreNoeudRotation(&(lesMail->Noeud_LesMaille(1,mailEtNumCentreNoeud->n)));}
else
// sinon il y a un nom de maillage
{int imail = lesMail->NumMaillage(mailEtNumCentreNoeud->nom);
iocondiline_i.ChangeCentreNoeudRotation(&(lesMail->Noeud_LesMaille(imail,mailEtNumCentreNoeud->n)));};
};
// on regarde s'il y a des fonctions de charge si oui on renseigne
int nbfct = iocondiline_i.ExisteFonctionChargeCoef();
if (nbfct)
{Vecteur valfct(nbfct),deltatvalfct(nbfct);
for (int ifct = 1; ifct <= nbfct; ifct++)
{Courbe1D * pt_courbe = lesCourbes1D->Trouve(iocondiline_i.NomFctch(ifct));
valfct(ifct)=pt_courbe->Valeur(temps);
deltatvalfct(ifct)=((pt_courbe->Valeur(temps)) - (pt_courbe->Valeur(temps-deltat)));
};
// on renseigne la condition limite
iocondiline_i.Valeur_fonctionChargeCoef(valfct,deltatvalfct);
// on actualise la direction actuelle ou normale pour plan droite
iocondiline_i.ActualiseDirectionPlanDroite();
};
int dima = ParaGlob::Dimension();
if(ParaGlob::AxiSymetrie())
// cas d'élément axisymétrique, dans ce cas on ne prend en compte que les
// dimension-1 coordonnées donc on décrémente
dima--;
int posi = Id_nom_ddl("X1") -1; // position du ddl X1
// on boucle sur les noeuds de la référence principale pour appliquer la condition
for (int in=1;in<=nb_n_princ;in++)
{ // récup du noeud principal
Noeud & noe=lesMail->Noeud_LesMaille(refp.Nbmaille(),refp.Numero(in));
//si le noeud est par ailleurs bloqué, ce n'est pas possible (sauf cas particulier
// non pris en compte car c'est trop spécifique, il faut utiliser une CL classique à la place
// d'utiliser ce type de condition linéaire, on test donc pour éviter des déconvenues
int indi = 0;
switch (dima)
{ case 3: if (noe.Ddl_fixe(Enum_ddl(posi+3)))
{ indi=3;
if (!iocondiline_i.Coherence_condi_PlanDroite(indi))
{break;}
else {indi = 0;}; // on remet à 0 si c'est cohérent
}
case 2: if (noe.Ddl_fixe(Enum_ddl(posi+2)))
{ indi=2;
if (!iocondiline_i.Coherence_condi_PlanDroite(indi))
{break;}
else {indi = 0;}; // on remet à 0 si c'est cohérent
}
case 1: if (noe.Ddl_fixe(Enum_ddl(posi+1)))
{ indi=1;
if (!iocondiline_i.Coherence_condi_PlanDroite(indi))
{break;}
else {indi = 0;}; // on remet à 0 si c'est cohérent
}
default: break;
};
if (indi)
{ // cas où il existe un blocage sur le noeud, la condition linéaire n'est pas licite
cout << "\n erreur concernant une condition lineaire par projection "
<< ", le noeud : "<<noe.Num_noeud() <<" du maillage "<< noe.Num_Mail() <<", est "
<< " deja bloque suivant la direction "<< indi << " on ne peut pas appliquer "
<< " une condition de projection normale ";
if (tempsCLL.Comptage_en_cours()) tempsCLL.Arret_du_comptage();
Sortie(1);
};
// on ne continue que si le type de ddl de la condition limite est actif pour le noeud
// et que c'est une variable, si ce n'est pas une variable on n'en tient pas compte
// on ne test que le premier s'il s'agit d'un vecteur (car a priori tout le type est actif en même temps)
if (noe.UneVariable(enu_condline) && noe.En_service(enu_condline))
{// on met la condition limite en déplacement sur les coordonnées de la référence
Coordonnee M = noe.Coord2();
iocondiline_i.ProjectionSurPlanDroite_et_calValCondiLin(M);
noe.Change_coord2(M);
// il n'y a pas d'indication de blocage. Ce sera fait lors de la mise en place
// sur le second membre et sur la matrice
}; // -- fin du cas ou c'est une variable et qu'elle est active
}; // -- fin de la boucle sur les noeuds de la ref principal
}; // -- fin du test pour savoir si c'est une condition de projection ou non
// III) --- un troisième passage pour la construction des coeffs actifs pour l'application pratique -----
// de la condition
bool construction_effectuee=false; // pour savoir s'il y a une construction effective ou non
// ** je ne comprends pas pourquoi il faut l'usine à gaz Pas_a_prendre_en_compte( qui fait que si au
// temps précédent c'était actif, alors au temps actuel, même en dehors de l'intervalle c'est également à considérer
// cela conduit à des erreurs donc je supprime et met un cas plus restrictif : Pas_a_prendre_en_compte_dans_intervalle(
// mais il faudrait également changer dans tous les chargement les fct du même type : Pas_a_prendre_en_compte(
// if ((a_considerer) && (!iocondiline_i.Pas_a_prendre_en_compte(temps))
if ((a_considerer) && (!iocondiline_i.Pas_a_prendre_en_compte_dans_intervalle(temps)))
{// construction des données nécessaires à l'appel de ConstructionCondition
// recup du tableau des références secondaires associées si elles existent
const Tableau <string>& nomRefassocie = iocondiline_i.ReferenceAssociees();
const Tableau <string > & nomMaillageAsoociees = iocondiline_i.NomMaillageAssociees();
int tailrefasso = nomRefassocie.Taille();
Tableau <const Tableau <int> * > tab_numNoeud_associe(tailrefasso);
Tableau <int> tab_numMail_associe(tailrefasso);
if (tailrefasso != 0)
{for (int k=1;k<=tailrefasso;k++)
{const string * nom_maillage=NULL;
if (iocondiline_i.NomMaillage() != NULL) nom_maillage=&nomMaillageAsoociees(k);
const ReferenceNE & refasso =
((ReferenceNE &) lesRef->Trouve(nomRefassocie(k),nom_maillage));
tab_numNoeud_associe(k) = & refasso.Tab_num(); // recup tableau des autres noeuds associés
tab_numMail_associe(k)= refasso.Nbmaille();
};
};
// -- maintenant que l'est là, il y a de bonnes raisons de penser que les conditions sont effectives
// on dimensionne correctement le tableau finale
t_condiAppli.Change_taille(nb_n_princ); // mise à jour de la taille au cas où
// éventuellement, due à la non activité des ddl, la condition peut néanmoins ne pas être construite
// par défaut on met le Iddl() en négatif, histoire de rendre par défaut la condition non exploitable
// ceci sera changé durant la construction effective, si elle a lieu. D'autre part au moment de l'utilisation de la condition
// le test sur le Iddl() permettra de savoir si la condition est exploitable ou non
for (int ijk=1;ijk<=nb_n_princ;ijk++)
t_condiAppli(ijk).ChangeIddl()=-1;
// on boucles sur les noeuds de la ref principale
Tableau <Noeud *> t_noe(tailrefasso+1); // tableau de travail
// l'objectif de la boucle qui suit est de définir t_noe, c'est à dire l'ensemble des noeuds
// concernés par la condition linéaire.
for (int in=1;in<=nb_n_princ;in++)
{ // récup du noeud principal
Noeud & noe=lesMail->Noeud_LesMaille(refp.Nbmaille(),refp.Numero(in));
t_noe(1)= &noe;
// on ne continue que si le type de ddl de la condition limite est actif pour le noeud
// et que c'est une variable, si ce n'est pas une variable on n'en tient pas compte
// on ne test que le premier s'il s'agit d'un vecteur (car a priori tout le type est actif en même temps)
if (noe.UneVariable(enu_condline) && noe.En_service(enu_condline))
{// récupération des noeuds associés, on utilise le même indice dans les ref associées que
// dans la ref principale
for (int ia = 1;ia<=tailrefasso;ia++)
t_noe(ia+1) = &(lesMail->Noeud_LesMaille(tab_numMail_associe(ia),(*tab_numNoeud_associe(ia))(in)));
// on commence par voir s'il y a des fonctions de charge si oui on renseigne
int nbfct = iocondiline_i.ExisteFonctionChargeCoef();
if (nbfct)
{Vecteur valfct(nbfct),deltatvalfct(nbfct);
for (int ifct = 1; ifct <= nbfct; ifct++)
{Courbe1D * pt_courbe = lesCourbes1D->Trouve(iocondiline_i.NomFctch(ifct));
valfct(ifct)=pt_courbe->Valeur(temps);
deltatvalfct(ifct)=((pt_courbe->Valeur(temps)) - (pt_courbe->Valeur(temps-deltat)));
};
// on renseigne la condition limite
iocondiline_i.Valeur_fonctionChargeCoef(valfct,deltatvalfct);
};
// on calcul les coefs effectifs de condition limite
Condilineaire & condi = t_condiAppli(in); // pour simplifier
// on constuit la condition et on impose la valeur c-a-d:
// on met en place la condition limite sur le ddl ddl_i du noeud principal
// qui correspond au ddl_i' dans le nouveau repèrere qui recevra la condition bloqué
// en fait ddl_i sera la seul modification de ddl due à la mise en place de la CLL
iocondiline_i.ConstructionCondition(t_noe,condi);
construction_effectuee = true; // on enregistre
}; // -- fin du cas ou c'est une variable et qu'elle est active
}; // -- fin de la boucle sur les noeuds de la ref principal
}; // -- fin du test pour savoir s'il faut considérer la condition linéaire ou pas
}; //-- fin de la boucle sur l'ensemble des conditions linéaire
// 2--- on boucle sur toutes les conditions linéaires effectives, pour imposer les blocages
for (int icondli=1;icondli<= tabTaille; icondli++)
{Tableau < Condilineaire > & t_condiAppli = tab_CLinApplique(icondli);
int taille = t_condiAppli.Taille();
for (int i=1;i<=taille;i++)
{ double Uk_impose = t_condiAppli(i).Val_Uk_impose(); // récup de la valeur a imposer
// dans le cas où c'est une condition de projection, la condition a déjà été effectuée
// donc il ne faut pas la faire ici: le test de Uk_impose, permet de le savoir
if (Uk_impose != ConstMath::tresgrand)
{ Noeud* noe = t_condiAppli(i).Noe(); // pour simplifier
Enum_ddl leEnuAChanger = t_condiAppli(i).Tab_Enum()(1); // le enu a changer
noe->Change_val_tdt(leEnuAChanger,Uk_impose);
};
};
};
tempsCLL.Arret_du_comptage(); // temps cpu
};
// création d'un tableau de condition linéaire, correspondant à toutes les conditions linéaires d'entrées
// qu'elles soient actives ou pas (a priori cette méthode est conçu pour donner des infos relativement à la largeur
// de bandes en noeuds due aux CLL)
// chacune des condition ne contient "d'exploitable" que le tableau de noeuds associés à la CLL,
Tableau <Tableau <Condilineaire> > LesCondLim::ConnectionCLL
(const LesMaillages * lesMail,const LesReferences* lesRef) const
{
// on boucle sur le tableau et pour chaque element on impose une condition lineaire
int tabTaille = tab_iocondiline.Taille();
Tableau <Tableau <Condilineaire> > t_connectionCLL(tabTaille);
for (int icondli=1;icondli<= tabTaille; icondli++)
{I_O_Condilineaire& iocondiline_i = tab_iocondiline(icondli); // pour simplifier
Enum_ddl enu_condline= iocondiline_i.TypeEnu(); // pour simplifier
// recup de la reference principal correspondant au mot cle
const ReferenceNE & refp =
((ReferenceNE &) lesRef->Trouve(iocondiline_i.NomRef(),iocondiline_i.NomMaillage()));
int nb_n_princ = refp.Taille();
Tableau <Condilineaire>& connectionCLL = t_connectionCLL(icondli); // pour simplifier
connectionCLL.Change_taille(nb_n_princ); // mise à jour de la taille
// ---- traitement des conditions limites de projection ---
// sur un plan ou une droite
if (iocondiline_i.PlanDroite())
{Tableau <Noeud *> t_noe(1); // tableau de travail
for (int in=1;in<=nb_n_princ;in++)
{ // récup du noeud principal
t_noe(1)= &lesMail->Noeud_LesMaille(refp.Nbmaille(),refp.Numero(in));
// s'il s'agit d'un ddl de déplacement, il faut le changer en Xi
Enum_ddl enu = enu_condline; // init
if (t_noe(1)->Existe_ici(X1) && (PremierDdlFamille(enu_condline)==UX))
enu = UxyzXi(enu_condline);
// on ne continue que si le type de ddl de la condition limite est une variable
// on ne test que le premier s'il s'agit d'un vecteur (car a priori tout le type est actif en même temps)
if (t_noe(1)->UneVariable(enu))
// on renseigne la condition uniquement sur le tableau de noeud
{ connectionCLL(in).ChangeTabNoeud(t_noe); };
}; // -- fin de la boucle sur les noeuds de la ref principal
}// -- fin du test pour savoir si c'est une condition de projection ou non
// --- cas des conditions linéaires générales ---------
else
{// recup du tableau des références secondaires associées si elles existent
const Tableau <string>& nomRefassocie = iocondiline_i.ReferenceAssociees();
const Tableau <string > & nomMaillageAsoociees = iocondiline_i.NomMaillageAssociees();
int tailrefasso = nomRefassocie.Taille();
Tableau <const Tableau <int> * > tab_numNoeud_associe(tailrefasso);
Tableau <int> tab_numMail_associe(tailrefasso);
if (tailrefasso != 0)
{for (int k=1;k<=tailrefasso;k++)
{const string * nom_maillage=NULL;
if (iocondiline_i.NomMaillage() != NULL) nom_maillage=&nomMaillageAsoociees(k);
const ReferenceNE & refasso =
((ReferenceNE &) lesRef->Trouve(nomRefassocie(k),nom_maillage));
tab_numNoeud_associe(k) = & refasso.Tab_num(); // recup tableau des autres noeuds associés
tab_numMail_associe(k)= refasso.Nbmaille();
};
};
// on boucles sur les noeuds de la ref principale
Tableau <Noeud *> t_noe(tailrefasso+1); // tableau de travail
// l'objectif de la boucle qui suit est de définir t_noe, c'est à dire l'ensemble des noeuds
// concernés par la condition linéaire.
for (int in=1;in<=nb_n_princ;in++)
{ // récup du noeud principal
Noeud & noe=lesMail->Noeud_LesMaille(refp.Nbmaille(),refp.Numero(in));
t_noe(1)= &noe;
Condilineaire& condCLL = connectionCLL(in); // pour simplifier
// s'il s'agit d'un ddl de déplacement, il faut le changer en Xi
Enum_ddl enu = enu_condline; // init
if (t_noe(1)->Existe_ici(X1) && (PremierDdlFamille(enu_condline)==UX))
enu = UxyzXi(enu_condline);
// on ne continue que si le type de ddl de la condition limite est une variable,
// on ne test que le premier s'il s'agit d'un vecteur (car a priori tout le type est actif en même temps)
if (noe.UneVariable(enu) )
{// récupération des noeuds associés, on utilise le même indice dans les ref associées que
// dans la ref principale
for (int ia = 1;ia<=tailrefasso;ia++)
t_noe(ia+1) = &(lesMail->Noeud_LesMaille(tab_numMail_associe(ia),(*tab_numNoeud_associe(ia))(in)));
};
// on renseigne la condition uniquement sur le tableau de noeud
condCLL.ChangeTabNoeud(t_noe);
}; // -- fin du cas ou c'est une variable
}; // -- fin de la boucle sur les noeuds de la ref principal
}; //-- fin de la boucle sur l'ensemble des conditions linéaire
// retour
return t_connectionCLL;
};
// idem ConnectionCLL avec une liste, mais spécifiquement les conditions de type "stricte_egalite" entre ddl de noeud
// correspondant à toutes les conditions linéaires d'entrées actives uniquement
// (a priori cette méthode est conçu pour donner des infos pour condenser les pointeurs d'assemblages:
// LesMaillages::MiseAJourPointeurAssemblage() )
// chacune des condition ne contient "d'exploitable" que le tableau de noeuds associés à la CLL, et le type enumere de ddl
list <Condilineaire> LesCondLim::ConnectionCLL_stricte_egalite
(const LesMaillages * lesMail,const LesReferences* lesRef) const
{
// def de la liste de retour
list <Condilineaire> list_condi;
// on boucle sur le tableau et pour chaque element on analyse la condition lineaire
int tabTaille = tab_iocondiline.Taille();
for (int icondli=1;icondli<= tabTaille; icondli++)
{I_O_Condilineaire& iocondiline_i = tab_iocondiline(icondli); // pour simplifier
Enum_ddl enu_condline= iocondiline_i.TypeEnu(); // pour simplifier
Tableau <Enum_ddl> tab_enu(1); tab_enu(1) = enu_condline; // servira pour construire les Condilineaires
// recup de la reference principal correspondant au mot cle
const ReferenceNE & refp =
((ReferenceNE &) lesRef->Trouve(iocondiline_i.NomRef(),iocondiline_i.NomMaillage()));
int nb_n_princ = refp.Taille();
// --- on ne continue que s'il s'agit d'une condition stricte_egalite et que la condition
// est active pour le temps actuel
if ((iocondiline_i.StricteEgalite())
&& (iocondiline_i.Temps_actif(ParaGlob::Variables_de_temps().TempsCourant())))
{// recup du tableau des références secondaires associées si elles existent
const Tableau <string>& nomRefassocie = iocondiline_i.ReferenceAssociees();
const Tableau <string > & nomMaillageAsoociees = iocondiline_i.NomMaillageAssociees();
int tailrefasso = nomRefassocie.Taille();
Tableau <const Tableau <int> * > tab_numNoeud_associe(tailrefasso);
Tableau <int> tab_numMail_associe(tailrefasso);
if (tailrefasso != 0)
{for (int k=1;k<=tailrefasso;k++)
{const string * nom_maillage=NULL;
if (iocondiline_i.NomMaillage() != NULL) nom_maillage=&nomMaillageAsoociees(k);
const ReferenceNE & refasso =
((ReferenceNE &) lesRef->Trouve(nomRefassocie(k),nom_maillage));
tab_numNoeud_associe(k) = & refasso.Tab_num(); // recup tableau des autres noeuds associés
tab_numMail_associe(k)= refasso.Nbmaille();
};
};
// on boucles sur les noeuds de la ref principale
Tableau <Noeud *> t_noe(tailrefasso+1); // tableau de travail
// l'objectif de la boucle qui suit est de définir t_noe, c'est à dire l'ensemble des noeuds
// concernés par la condition linéaire.
for (int in=1;in<=nb_n_princ;in++)
{ // récup du noeud principal
Noeud & noe=lesMail->Noeud_LesMaille(refp.Nbmaille(),refp.Numero(in));
t_noe(1)= &noe;
// s'il s'agit d'un ddl de déplacement, il faut le changer en Xi
Enum_ddl enu = enu_condline; // init
if (t_noe(1)->Existe_ici(X1) && (PremierDdlFamille(enu_condline)==UX))
enu = UxyzXi(enu_condline);
// on ne continue que si le type de ddl de la condition limite est une variable,
// on ne test que le premier s'il s'agit d'un vecteur (car a priori tout le type est actif en même temps)
if (noe.UneVariable(enu) )
{// récupération des noeuds associés, on utilise le même indice dans les ref associées que
// dans la ref principale
for (int ia = 1;ia<=tailrefasso;ia++)
t_noe(ia+1) = &(lesMail->Noeud_LesMaille(tab_numMail_associe(ia),(*tab_numNoeud_associe(ia))(in)));
};
// on renseigne une condition uniquement sur le tableau de noeud
Condilineaire condi_stric_egal(tab_enu,t_noe);
list_condi.push_back(condi_stric_egal);
}; // -- fin du cas ou c'est une variable
}; // -- fin de la boucle sur les noeuds de la ref principal
}; //-- fin de la boucle sur l'ensemble des conditions linéaire
// retour
return list_condi;
};
// récupération de valeurs à un noeud pour les grandeur enu
// ici il s'agit de grandeur scalaires
Tableau <double> LesCondLim::Valeur_multi_interpoler_ou_calculer
(const Noeud& noe, Enum_dure temps,const List_io<Ddl_enum_etendu>& enu)
{
// recup de l'incrément de temps
double deltat=ParaGlob::Variables_de_temps().IncreTempsCourant();
double unSurDeltat=0;
if (Abs(deltat) >= ConstMath::trespetit)
{unSurDeltat = 1./deltat;}
else // si l'incrément de temps est tres petit on remplace 1/deltat par un nombre tres grand
{ // un pas de temps doit être positif !! or certaine fois il peut y avoir des pb
if (unSurDeltat < 0)
{ cout << "\n le pas de temps est négatif !! "; };
unSurDeltat = ConstMath::tresgrand;
};
// le tableau de retour
Tableau <double> tab_ret (enu.size());
// on balaie la liste des grandeurs à sortir
List_io<Ddl_enum_etendu>::const_iterator ie,iefin=enu.end();
int it; // it est l'indice dans le tableau de retour
for (it=1,ie=enu.begin(); ie!=iefin;ie++,it++)
{ if ((Meme_famille((*ie).Enum(),X1)) && ((*ie).Nom_vide()))
{switch (temps)
{case TEMPS_0 : tab_ret(it)= noe.Coord0()((*ie).Enum() - X1 +1);break;
case TEMPS_t : tab_ret(it)= noe.Coord1()((*ie).Enum() - X1 +1);break;
case TEMPS_tdt : tab_ret(it)= noe.Coord2()((*ie).Enum() - X1 +1);break;
default :
cout << "\nErreur : valeur incorrecte du type Enum_dure !\n";
cout << "\nLesCondLim::Valeur_multi_interpoler_ou_calculer(.. \n";
Sortie(1);
};
}
else if ((Meme_famille((*ie).Enum(),UX)) && ((*ie).Nom_vide()))
{int i_cor = (*ie).Enum() - UX +1; // l'indice de coordonnée
switch (temps)
{case TEMPS_0 : tab_ret(it)= 0.;break;
case TEMPS_t : tab_ret(it)= noe.Coord1()(i_cor)-noe.Coord0()(i_cor);break;
case TEMPS_tdt : tab_ret(it)= noe.Coord2()(i_cor)-noe.Coord0()(i_cor);break;
default :
cout << "\nErreur : valeur incorrecte du type Enum_dure !\n";
cout << "\nLesCondLim::Valeur_multi_interpoler_ou_calculer(.. \n";
Sortie(1);
};
}
// cas particulier de la position à t, indépendamment du temps
else if (Ddl_enum_etendu::PremierDdlEnumEtenduFamille(*ie).Position() == 123)
{tab_ret(it)= noe.Coord1()((*ie).Enum() - X1 +1);
}
// cas particulier de la position à t0, indépendamment du temps
else if (Ddl_enum_etendu::PremierDdlEnumEtenduFamille(*ie).Position() == 126)
{tab_ret(it)= noe.Coord0()((*ie).Enum() - X1 +1);
}
else if ((*ie).Nom_vide())
{// il s'agit d'un ddl pur on le récupère directement
switch (temps)
{case TEMPS_0 : tab_ret(it)= noe.Valeur_0((*ie).Enum());break;
case TEMPS_t : tab_ret(it)= noe.Valeur_t((*ie).Enum());break;
case TEMPS_tdt : tab_ret(it)= noe.Valeur_tdt((*ie).Enum());break;
default :
cout << "\nErreur : valeur incorrecte du type Enum_dure !\n";
cout << "LesCondLim::Valeur_multi_interpoler_ou_calculer(.. \n";
Sortie(1);
};
}
// --- a complèter ----
else
{ tab_ret(it) = 0.;
cout << "\n cas de ddl actuellement non traite "
<< "\n pas de ddl " << (*ie).Nom() << " au noeud "
<< noe.Num_noeud() <<" du maillage "<< noe.Num_Mail()
<< "\n ou cas non implante pour l'instant, on retourne 0"
<< "\n LesCondLim::Valeur_multi_interpoler_ou_calculer(.. ";
};
};// -- fin de la boucle sur la liste de Ddl_enum_etendu
// liberation des tenseurs intermediaires
LibereTenseur();
return tab_ret;
};
// récupération de valeurs à un noeud pour les grandeur enu
// ici il s'agit de grandeurs tensorielles
void LesCondLim::Valeurs_Tensorielles_interpoler_ou_calculer
(const Noeud& noe, Enum_dure temps,List_io<TypeQuelconque>& enu)
{ // ----- def de grandeurs de travail
int dim_espace = ParaGlob::Dimension();
// on initialise ces variables booléennes et les conteneurs
List_io<TypeQuelconque>::iterator ipq,ipqfin=enu.end();
for (ipq=enu.begin();ipq!=ipqfin;ipq++)
{TypeQuelconque_enum_etendu enuq = (*ipq).EnuTypeQuelconque().EnumTQ();
switch (enuq.Position())
{ case POSITION_GEOMETRIQUE :
{Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) ((*ipq).Grandeur_pointee()));
Coordonnee* M = gr.ConteneurCoordonnee();
switch (temps)
{case TEMPS_0 : (*M)= noe.Coord0();break;
case TEMPS_t : (*M)= noe.Coord1();break;
case TEMPS_tdt : (*M)= noe.Coord2();break;
default :
cout << "\nErreur : valeur incorrecte du temps !\n";
cout << "\nLesCondLim::Valeurs_Tensorielles_interpoler_ou_calculer(.. \n";
if (tempsCL.Comptage_en_cours()) tempsCL.Arret_du_comptage();
if (tempsCLL.Comptage_en_cours()) tempsCLL.Arret_du_comptage();
Sortie(1);
};
break;
}
case POSITION_GEOMETRIQUE_t :
{Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) ((*ipq).Grandeur_pointee()));
Coordonnee* M = gr.ConteneurCoordonnee();
(*M)= noe.Coord1();
break;
}
case POSITION_GEOMETRIQUE_t0 :
{Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) ((*ipq).Grandeur_pointee()));
Coordonnee* M = gr.ConteneurCoordonnee();
(*M)= noe.Coord0();
break;
}
case DEPLACEMENT :
{Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) ((*ipq).Grandeur_pointee()));
Coordonnee* M = gr.ConteneurCoordonnee();
switch (temps)
{case TEMPS_0 : M->Zero();break;
case TEMPS_t : (*M)= noe.Coord1()-noe.Coord0();break;
case TEMPS_tdt : (*M)= noe.Coord2()-noe.Coord0();break;
default :
cout << "\nErreur : valeur incorrecte du temps !\n";
cout << "\nLesCondLim::Valeurs_Tensorielles_interpoler_ou_calculer(.. \n";
if (tempsCL.Comptage_en_cours()) tempsCL.Arret_du_comptage();
if (tempsCLL.Comptage_en_cours()) tempsCLL.Arret_du_comptage();
Sortie(1);
};
break;
}
case FORCE_GENE_EXT : case FORCE_GENE_INT : case VECT_PRESSION : case VECT_FORCE_VOLUM :
case VECT_DIR_FIXE : case VECT_SURF_SUIV : case VECT_HYDRODYNA_Fn : case VECT_HYDRODYNA_Ft :
case VECT_HYDRODYNA_T : case VECT_LINE : case VECT_LINE_SUIV : case VECT_REAC : case VECT_REAC_N :
case FORCE_CONTACT : case FORCE_GENE_TOT: case RESIDU_GLOBAL:
{Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) ((*ipq).Grandeur_pointee()));
Coordonnee* F = gr.ConteneurCoordonnee();
// on vérifie l'existante
#ifdef MISE_AU_POINT
if (!(noe.Existe_ici(enuq)))
{cout << "\nErreur : " << enuq.Nom() << " n'existe pas au noeud "
<< noe.Num_noeud() << " du maillage "<< noe.Num_Mail()
<< "\nLesCondLim::Valeurs_Tensorielles_interpoler_ou_calculer(.. \n";
if (tempsCL.Comptage_en_cours()) tempsCL.Arret_du_comptage();
if (tempsCLL.Comptage_en_cours()) tempsCLL.Arret_du_comptage();
Sortie(1);
};
#endif
// récupération de la grandeur quelconque
const TypeQuelconque& toto = noe.Grandeur_quelconque(enuq);
const Grandeur_coordonnee& titi = *((const Grandeur_coordonnee* ) toto.Const_Grandeur_pointee());
(*F) = titi.ConteneurCoordonnee_const(); // ouf
break;
}
case VITESSE :
{Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) ((*ipq).Grandeur_pointee()));
Coordonnee* V = gr.ConteneurCoordonnee();
// on vérifie l'existante
#ifdef MISE_AU_POINT
if (!(noe.Existe_ici(V1)))
{cout << "\nErreur : la vitesse n'existe pas au noeud "
<< noe.Num_noeud() << " du maillage "<< noe.Num_Mail()
<< "\nLesCondLim::Valeurs_Tensorielles_interpoler_ou_calculer(.. \n";
if (tempsCL.Comptage_en_cours()) tempsCL.Arret_du_comptage();
if (tempsCLL.Comptage_en_cours()) tempsCLL.Arret_du_comptage();
Sortie(1);
};
#endif
// récupération de la vitesse
switch (temps)
{ case TEMPS_0 :
{switch (dim_espace)
{case 3: (*V)(3) = noe.Valeur_0(V3);
case 2: (*V)(2) = noe.Valeur_0(V2);
case 1: (*V)(1) = noe.Valeur_0(V1);
break;
default: break;
};
break;
}
case TEMPS_t :
{switch (dim_espace)
{case 3: (*V)(3) = noe.Valeur_t(V3);
case 2: (*V)(2) = noe.Valeur_t(V2);
case 1: (*V)(1) = noe.Valeur_t(V1);
break;
default: break;
};
break;
}
case TEMPS_tdt :
{switch (dim_espace)
{case 3: (*V)(3) = noe.Valeur_tdt(V3);
case 2: (*V)(2) = noe.Valeur_tdt(V2);
case 1: (*V)(1) = noe.Valeur_tdt(V1);
break;
default: break;
};
break;
}
default: break;
};
break;
}
case ACCELERATION :
{Grandeur_coordonnee& gr= *((Grandeur_coordonnee*) ((*ipq).Grandeur_pointee()));
Coordonnee* gamma = gr.ConteneurCoordonnee();
// on vérifie l'existante
#ifdef MISE_AU_POINT
if (!(noe.Existe_ici(GAMMA1)))
{cout << "\nErreur : l'acceleration n'existe pas au noeud "
<< noe.Num_noeud() << " du maillage "<< noe.Num_Mail()
<< "\nLesCondLim::Valeurs_Tensorielles_interpoler_ou_calculer(.. \n";
if (tempsCL.Comptage_en_cours()) tempsCL.Arret_du_comptage();
if (tempsCLL.Comptage_en_cours()) tempsCLL.Arret_du_comptage();
Sortie(1);
};
#endif
// récupération de la vitesse
switch (temps)
{ case TEMPS_0 :
{switch (dim_espace)
{case 3: (*gamma)(3) = noe.Valeur_0(GAMMA3);
case 2: (*gamma)(2) = noe.Valeur_0(GAMMA2);
case 1: (*gamma)(1) = noe.Valeur_0(GAMMA1);
break;
default: break;
};
break;
}
case TEMPS_t :
{switch (dim_espace)
{case 3: (*gamma)(3) = noe.Valeur_t(GAMMA3);
case 2: (*gamma)(2) = noe.Valeur_t(GAMMA2);
case 1: (*gamma)(1) = noe.Valeur_t(GAMMA1);
break;
default: break;
};
break;
}
case TEMPS_tdt :
{switch (dim_espace)
{case 3: (*gamma)(3) = noe.Valeur_tdt(GAMMA3);
case 2: (*gamma)(2) = noe.Valeur_tdt(GAMMA2);
case 1: (*gamma)(1) = noe.Valeur_tdt(GAMMA1);
break;
default: break;
};
break;
}
default: break;
};
break;
}
default :
{// on initialise la grandeur pour éviter d'avoir des valeurs aléatoires
((*ipq).Grandeur_pointee())->InitParDefaut();
if (ParaGlob::NiveauImpression() > 0)
{cout << "\nWarning : attention cas non traite: "
<< (*ipq).EnuTypeQuelconque().NomPlein() << "!\n";
// on initialise la grandeur pour éviter d'avoir des valeurs aléatoires
if (ParaGlob::NiveauImpression() > 5)
cout << "\n LesCondLim::Valeurs_Tensorielles_interpoler_ou_calculer(....";
};
}
};
};
// liberation des tenseurs intermediaires
LibereTenseur();
};