Herezh_dev/herezh_pp/Util/MvtSolide/MvtSolide.cc

597 lines
26 KiB
C++
Executable file

// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.
#include "MvtSolide.h"
#include "ParaGlob.h"
#include <list>
#include "MathUtil.h"
#include "CharUtil.h"
// par défaut
MvtSolide::MvtSolide() :
tab_tcr(), tab_indic(),lis_centre_noeud()
{};
// de copie
MvtSolide::MvtSolide (const MvtSolide& mvt):
tab_tcr(mvt.tab_tcr), tab_indic(mvt.tab_indic)
,lis_centre_noeud(mvt.lis_centre_noeud)
{};
// DESTRUCTEUR :
MvtSolide::~MvtSolide ()
{};
// Affiche les donnees
void MvtSolide::Affiche () const
{ cout << " mouvement_solide_ ";
int taille = tab_tcr.Taille();
list <String_et_entier>::const_iterator il = lis_centre_noeud.begin();
for (int it=1; it<= taille; it++)
{ switch (tab_indic(it))
{ case 1: // cas d'une translation
{ cout << " translation_= " << tab_tcr(it);
break;
}
case 2: // cas d'une nouvelle définition du centre
{ cout << " centre_= " << tab_tcr(it);
break;
}
case 3: // cas d'une rotation
{ cout << " rotation_= " << tab_tcr(it);
break;
}
case 4: // cas d'une rotation
{ cout << " centre_a_un_noeud=_nom_maille " << (*il).nom
<< " numnoeud= " << (*il).n;
il++;
break;
}
case 5: // cas d'une homothétie
{ cout << " homothetie_= " << tab_tcr(it);
break;
}
}; // fin du switch: switch (tab_indic)
};
cout << " ";
};
// Realise l'egalite
MvtSolide& MvtSolide::operator= (const MvtSolide& mvt)
{ tab_tcr = mvt.tab_tcr;
tab_indic = mvt.tab_indic;
lis_centre_noeud = mvt.lis_centre_noeud;
return *this;
};
//Surcharge d'operateur logique
bool MvtSolide::operator == (const MvtSolide& mvt) const
{ return ((tab_tcr == mvt.tab_tcr) && (tab_indic == mvt.tab_indic)
&& (lis_centre_noeud == mvt.lis_centre_noeud));
};
// lecture des mouvements solides si nécessaire
void MvtSolide::Lecture_mouvements_solides(UtilLecture * entreePrinc)
{ if (strstr(entreePrinc->tablcar,MotCleMvtSolide().c_str())!=NULL)
// si on change le mot clé ne pas oublier de changer la fonction MotCleMvtSolide()
{ if (ParaGlob::NiveauImpression() >= 6)
cout << " lecture des mouvements solides " << endl ;
entreePrinc->NouvelleDonnee();
string nom;
int dima = ParaGlob::Dimension();
list <Coordonnee> list_tcr; // liste des translations, centres et rotation
list <int> list_indic; // indic le type de transformation lue: 1 pour translation
// 2 pour centre et 3 pour rotation
while (strstr(entreePrinc->tablcar,"fin_mouvement_solide_")==NULL)
{*(entreePrinc->entree) >> nom;
if (nom == "translation_=")
{ Coordonnee trans(dima);
trans.Lecture(*entreePrinc);
list_tcr.push_back(trans);
list_indic.push_back(1);
};
if (nom == "centre_=")
{ Coordonnee centre(dima);
centre.Lecture(*entreePrinc);
list_tcr.push_back(centre);
list_indic.push_back(2);
};
if (nom == "rotation_=")
{ Coordonnee rot(3); // le vecteur rotation est systématiquement en 3D
rot.Lecture(*entreePrinc);
if (strstr(entreePrinc->tablcar,"en_degre_")!=0)
// on transforme en radian
{ rot *= ConstMath::Pi / 180.;};
list_tcr.push_back(rot);
list_indic.push_back(3);
// on regarde s'il s'agit de degré éventuellement
};//-- fin du cas de la rotation
if (nom == "centre_noeud_=")
{ // cas d'un centre donné par un numero de noeud
String_et_entier nu;
string nom_mail;
*(entreePrinc->entree) >> nom_mail;
if (nom_mail == "nom_mail=")
{ // cas où il y a un nom de maillage
*(entreePrinc->entree) >> nu.nom; // lecture du nom
*(entreePrinc->entree) >> nu.n; // lecture du numero de noeud
}
else
{ // sinon cela veut dire que l'on vient de lire un numéro de noeud du premier maillage
nu.nom = "";
nu.n = ChangeEntier(nom_mail);
};
lis_centre_noeud.push_back(nu);
list_tcr.push_back(Coordonnee()); // un centre par défaut
list_indic.push_back(4);
};
if (nom == "homothetie_=")
{ Coordonnee homothetie(3); // le vecteur homothetie est systématiquement en 3D
// ainsi on peut avoir une dilatation différentielle suivant les 3 axes
homothetie.Lecture(*entreePrinc);
list_tcr.push_back(homothetie);
list_indic.push_back(5);
};//-- fin du cas d'une homothetie
entreePrinc->NouvelleDonnee();
}; //-- fin du while
// on passe le mot clé de fin
*(entreePrinc->entree) >> nom;
// entreePrinc->NouvelleDonnee();
// enregistrement des mouvements solides
int taille = list_tcr.size();
tab_tcr.Change_taille(taille);
tab_indic.Change_taille(taille);
list <Coordonnee>::iterator il,ilfin=list_tcr.end();
list <int>::iterator ii,iifin=list_indic.end();
int i =1; ii=list_indic.begin(); // init pour la boucle qui suit
for (il=list_tcr.begin();il != ilfin; il++,i++,ii++)
{tab_tcr(i)=(*il);
tab_indic(i)=(*ii);
};
}; //-- fin du if indiquant le cas ou il y a des mouvements solides
};
// retour de la première rotation: en fait l'axe de rotation
const Coordonnee& MvtSolide::Premiere_rotation()const
{ Coordonnee axe; // le vecteur de retour
int taille = tab_tcr.Taille();
int dima = ParaGlob::Dimension();
for (int it=1; it<= taille; it++)
{ switch (tab_indic(it))
{ case 3: // cas d'une rotation
{ switch (dima)
{case 1:
{cout << "\n erreur : pas de rotation en 1D !! "
<< "\n MvtSolide::Premiere_rotation(..";
Sortie(1); break;
}
case 2 : case 3: return tab_tcr(it);
}
break;
} // fin du cas 3
}; // fin du switch: switch (tab_indic)
}; // fin de la boucle sur tab_indic : for (int it=1; it<= taille; it++)
// normalement on ne passe pas ici sauf s'il n'y a pas d'axe
return tab_tcr(1); // pour faire taire le compilateur
};
// indique s'il existe seulement une seule rotation
bool MvtSolide::ExisteUneSeuleRotation()const
{ int nb_rot=0;
int taille = tab_tcr.Taille();
int dima = ParaGlob::Dimension();
for (int it=1; it<= taille; it++)
{ switch (tab_indic(it))
{ case 3: // cas d'une rotation
{ switch (dima)
{case 1: break; // on ne fait rien
case 2 : case 3: nb_rot++;
}
break;
} // fin du cas 3
}; // fin du switch: switch (tab_indic)
}; // fin de la boucle sur tab_indic : for (int it=1; it<= taille; it++)
// retour
return (nb_rot == 1);
};
// application des mouvements solides aux points transmis et retour du point
// transformé
Coordonnee & MvtSolide::AppliqueMvtSolide (Coordonnee & M) const
{ // on passe en revue l'ensemble des transformations
int taille = tab_tcr.Taille();
int dima = ParaGlob::Dimension();
#ifdef MISE_AU_POINT
if (list_coor_centre_noeud.size() != lis_centre_noeud.size())
{ cout << "\n erreur : le nombre de centre noeud disponible "
<< list_coor_centre_noeud.size() << " est inferieur au nombre defini par la condition"
<< " lineaire qui est " << lis_centre_noeud.size() << endl;
Sortie(1);
};
#endif
list <Coordonnee>::const_iterator icoor_centre = list_coor_centre_noeud.begin();
Coordonnee centre(dima); // par défaut le centre
for (int it=1; it<= taille; it++)
{ switch (tab_indic(it))
{ case 1: // cas d'une translation
{ M += tab_tcr(it);
break;
}
case 2: // cas d'une nouvelle définition du centre
{ centre += tab_tcr(it);
break;
}
case 3: // cas d'une rotation
{ switch (dima)
{case 1: break; // on ne fait rien
case 2: // on tourne autour de z
{ double theta = tab_tcr(it)(3);
double costheta = cos(theta);
double sintheta = sin(theta);
// le point initial : M , le centre de rotation C
// le point final : Mnew = rotation de CM + les coordonnées du centre
Coordonnee CM(M-centre); // création de CM
M(1)=CM(1)*costheta + CM(2)*sintheta + centre(1);
M(2)=-CM(1)*sintheta + CM(2)*costheta + centre(2);
break;
}
case 3: // on a trois rotation qui sont successivement suivant x puis y puis z
{ Coordonnee& rot = tab_tcr(it); // pour simplifier
// le point initial : M , le centre de rotation C
// le point final : Mnew = rotation de CM + les coordonnées du centre
for (int i=1;i<=3;i++) // on boucle sur les trois directions
// une rotation autour de xi si l'angle est non nulle
if (!(Dabs(rot(i)) <= ConstMath::trespetit))
{ // on définit 3 index fonctions du i
int ix=1; int iy=2; int iz=3;
switch (i) // uniquement pour 2 et 3, le cas 1 étant celui de l'initialisation
// précédente
{ case 2: ix = 2; iy = 1; iz = 3; break;
case 3: ix = 3; iy = 1; iz = 2; break;
};
Coordonnee CM(M-centre); // création de CM
double theta = rot(i);
double costheta = cos(theta);
double sintheta = sin(theta);
// transformation
M(iy)=CM(iy)*costheta + CM(iz)*sintheta + centre(iy);
M(iz)=-CM(iy)*sintheta + CM(iz)*costheta + centre(iz);
M(ix)=CM(ix) + centre(ix);
};
break;
}
}; //-- fin du case sur la dimension: switch (dima)
break;
} // fin du cas 3
case 4: // cas d'un centre définie par une position de noeud
{ centre = (*icoor_centre);
break;
}
case 5: // on fait une homothétie
{ // on se sert du centre pour le centre de l'homothétie
Coordonnee& scale = tab_tcr(it); // pour simplifier
Coordonnee CM(M-centre); // création de CM
switch (dima)
{case 3: M(3) = centre(3) + CM(3) * scale(3);
case 2: M(2) = centre(2) + CM(2) * scale(2);
case 1: M(1) = centre(1) + CM(1) * scale(1);
};
break;
}
}; // fin du switch: switch (tab_indic)
}; // fin de la boucle sur tab_indic : for (int it=1; it<= taille; it++)
// retour du point transformé
return M;
};
// idem que précédemment, mais avec un coefficient d'intensité
// dans le cas d'une translation, celle-ci est multiplié par le coef
// dans le cas d'un nouveau centre, sa position n'est pas affectée par le coef
// dans le cas d'une rotation, celle-ci est multiplié par le coef
// dans le cas d'une homothétie: celle-ci est multiplié par le coef
Coordonnee & MvtSolide::AppliqueMvtSolide (Coordonnee & M, const double& coef) const
{ // on passe en revue l'ensemble des transformations
int taille = tab_tcr.Taille();
int dima = ParaGlob::Dimension();
#ifdef MISE_AU_POINT
if (list_coor_centre_noeud.size() != lis_centre_noeud.size())
{ cout << "\n erreur : le nombre de centre noeud disponible "
<< list_coor_centre_noeud.size() << " est inferieur au nombre defini par la condition"
<< " lineaire qui est " << lis_centre_noeud.size() << endl;
Sortie(1);
};
#endif
list <Coordonnee>::const_iterator icoor_centre = list_coor_centre_noeud.begin();
Coordonnee centre(dima); // par défaut le centre
for (int it=1; it<= taille; it++)
{ switch (tab_indic(it))
{ case 1: // cas d'une translation
{ M += coef * tab_tcr(it) ;
break;
}
case 2: // cas d'une nouvelle définition du centre
{ centre += tab_tcr(it);
break;
}
case 3: // cas d'une rotation
{ switch (dima)
{case 1: break; // on ne fait rien
case 2: // on tourne autour de z
{ double theta = coef * tab_tcr(it)(3);
double costheta = cos(theta);
double sintheta = sin(theta);
// le point initial : M , le centre de rotation C
// le point final : Mnew = rotation de CM + les coordonnées du centre
Coordonnee CM(M-centre); // création de CM
M(1)=CM(1)*costheta + CM(2)*sintheta + centre(1);
M(2)=-CM(1)*sintheta + CM(2)*costheta + centre(2);
break;
}
case 3: // on a trois rotation qui sont successivement suivant x puis y puis z
{ Coordonnee rot = coef * tab_tcr(it); // pour simplifier
// le point initial : M , le centre de rotation C
// le point final : Mnew = rotation de CM + les coordonnées du centre
for (int i=1;i<=3;i++) // on boucle sur les trois directions
// une rotation autour de xi si l'angle est non nulle
if (!(Dabs(rot(i)) <= ConstMath::trespetit))
{ // on définit 3 index fonctions du i
int ix=1; int iy=2; int iz=3;
switch (i) // uniquement pour 2 et 3, le cas 1 étant celui de l'initialisation
// précédente
{ case 2: ix = 2; iy = 1; iz = 3; break;
case 3: ix = 3; iy = 1; iz = 2; break;
};
Coordonnee CM(M-centre); // création de CM
// double rayon0 = CM.Norme();
double theta = rot(i);
double costheta = cos(theta);
double sintheta = sin(theta);
// transformation
M(iy)=CM(iy)*costheta + CM(iz)*sintheta + centre(iy);
M(iz)=-CM(iy)*sintheta + CM(iz)*costheta + centre(iz);
M(ix)=CM(ix) + centre(ix);
// CM = M-centre;
// double rayon1 = CM.Norme();
// if (Dabs(rayon1-rayon0)>= ConstMath::pasmalpetit)
// cout << "\n rayon1= " << rayon1 << " rayon0= " << rayon0;
};
break;
}
}; //-- fin du case sur la dimension: switch (dima)
break;
} // fin du cas 3
case 4: // cas d'un centre définie par une position de noeud
{ centre = (*icoor_centre);
break;
}
case 5: // on fait une homothétie
{ // on se sert du centre pour le centre de l'homothétie
Coordonnee scale = coef * tab_tcr(it); // pour simplifier
Coordonnee CM(M-centre); // création de CM
switch (dima)
{case 3: M(3) = centre(3) + CM(3) * scale(3);
case 2: M(2) = centre(2) + CM(2) * scale(2);
case 1: M(1) = centre(1) + CM(1) * scale(1);
};
break;
}
}; // fin du switch: switch (tab_indic)
}; // fin de la boucle sur tab_indic : for (int it=1; it<= taille; it++)
// retour du point transformé
return M;
};
// affichage et definition interactive des commandes
void MvtSolide::Info_commande_MvtSolide(ostream & sort)
{ // ---------- définition de rotations et translation solide ----------
//On va proposer un menu
string rep=" ";
sort << " mouvement_solide_ ";
while ((Minuscules(rep) != "f")&&(Minuscules(rep) != "0"))
{
try
{
cout
<< "\n (0 ou f) (fin) "
<< "\n (1) translation "
<< "\n (2) rotation "
<< "\n (3) nouveau centre absolu "
<< "\n (4) centre avec un noeud "
<< "\n (5) homothetie "
<< "\n (6 ou ? ) informations "
<< "\n ";
rep = lect_return_defaut(false,"f");
if ((Minuscules(rep) == "f") || (Minuscules(rep) == "0"))// sortie directe
break;
int num = ChangeEntier(rep);
if (Minuscules(rep) == "?")
num = 6;
bool choix_valide=false;
if ((num >= 0)&&(num<=6))
{ choix_valide=true; }
else { cout << "\n Erreur on attendait un entier entre 0 et 6 !!, "
<< "\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: // translation
{ int dim = ParaGlob::Dimension();
Coordonnee trans(dim);
cout << "\n lecture du vecteur deplacement ("<<dim<<" reels) ? ";
trans.Lecture();
sort << "\n translation_= ";
trans.Affiche(sort,dim);
break;
}
case 2: // rotation
{ int dim = 3; // la dimension est systématiquement 3 ParaGlob::Dimension();
Coordonnee trans(dim);
cout << "\n rotation en radian par defaut, \n voulez vous des degres (rep o ou n) ";
string rop = lect_return_defaut(true,"n");
bool deg = false;
if (rop == "o") deg = true;
// on sépare en fonction de la dimension de l'espace
switch (ParaGlob::Dimension())
{ case 1: {cout << "\n pas de rotation possible en dimension 1 ! "; break;}
case 2: // la rotation est uniquement autour de z
{ cout << "\n lecture de l'angle de rotation autour de z: 1 reels) ? ";
trans(3)=lect_double();
break;
}
case 3:
{cout << "\n lecture du vecteur rotation ("<<dim<<" reels) ? ";
trans.Lecture();
sort << "\n rotation_= ";
trans.Affiche(sort,dim);
break;
}
default: break; // a priori il n'y a pas d'autre cas
};
// affichage
sort << "\n rotation_= ";
trans.Affiche(sort,dim);
if (deg)
sort << " en_degre_ ";
break;
}
case 3: // nouveau centre absolu
{ int dim = ParaGlob::Dimension();
Coordonnee trans(dim);
cout << "\n lecture du nouveau centre absolu ("<<dim<<" reels) ? ";
trans.Lecture();
sort << "\n centre_= ";
trans.Affiche(sort,dim);
break;
}
case 4: // centre avec un noeud
{ cout << "\n lecture du nouveau noeud centre (un numero de noeud) ? ";
int num_noeud=0;
num_noeud=(int)lect_double();
cout << "\n un nom de maillage (si aucune rep: \"_\" ) ? ";
string nom_mail="_";
nom_mail=lect_chaine();
sort << "\n centre_noeud_= ";
if (nom_mail != "_")
sort << " nom_mail= "<< nom_mail<< " ";
sort << num_noeud << " ";
break;
}
case 5: // homothétie
{ int dim = ParaGlob::Dimension();
Coordonnee scale(dim);
cout << "\n lecture du vecteur homothetie ("<<dim<<" reels) ? ";
scale.Lecture();
sort << "\n homothetie_= ";
scale.Affiche(sort,dim);
break;
}
case 6: // information
{ cout << "\n informations sur les mouvements solides";
cout << "\n# --- definition optionnelle de mouvements sodides appliquees au solide ---"
<< "\n mouvement_solide_ # mot cle pour definir le debut des mouvements solides "
<< "\n translation_= 1. 0. 0. # exemple d'une translation sur x "
<< "\n rotation_= 0.1 0. 0.3 # rotation selon x de 0.1 radian, puis selon z (selon y nulle) "
<< "\n rotation_= 0.1 0. 0.3 en_degre_ # idem mais en degre "
<< "\n centre_= 0.1 0.1 0.2 # def d'un nouveau centre de rotation pour les rotations a suivre "
<< "\n centre_noeud_= 3 # idem mais ici le centre de rotation sera le noeud 3 "
<< "\n centre_noeud_= nom_mail= trap 3 # idem avec un nom de maillage (trap) "
<< "\n homothetie_= 0.8 1. 1.1 # dilatation -20% sur x, rien sur y, +10% en z "
<< "\n fin_mouvement_solide_ # mot de fin de mouvement solide \n\n"
<< "\n# -- il est possible d'enchainer plusieurs mouvements solides a suivre qui sont dans ce cas execute dans le"
<< "\n# le meme ordre que la declaration\n"
<< "\n# -- concernant les rotations: "
<< "\n# si l'espace est 1D ==> aucune modification du maillage "
<< "\n# si l'espace est 2D ==> la rotation prise en compte est uniquement autour de z "
<< "\n# si l'espace est 3D ==> rotation (si l'angle est non nulle) suivant x puis suivant y puis suivant z ";
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 ";
};
}; //-- fin du while
sort << "\n fin_mouvement_solide_ ";
};
// effacement du mouvement solide actuel
void MvtSolide::EffaceMvtSolide()
{ tab_tcr.Libere(); tab_indic.Libere();
lis_centre_noeud.erase(lis_centre_noeud.begin(),lis_centre_noeud.end());
list_coor_centre_noeud.erase(list_coor_centre_noeud.begin(),list_coor_centre_noeud.end());
};
// surcharge de l'operateur de lecture typée
istream & operator >> (istream & entree, MvtSolide & mvt)
{ // vérification du type
int taille = 0;
string type;
entree >> type;
if (type != "MvtSolide_")
{ cout << "\n erreur en lecture d'un mouvement solide, on a lue " << type
<< " au lieu de MvtSolide_ ";
Sortie(1);
};
// lecture de la taille, on se sert de type pour passer la chaine Taille:
entree >> type >> taille;
mvt.tab_tcr.Change_taille(taille);
mvt.tab_indic.Change_taille(taille);
for (int it=1; it<= taille; it++)
{ entree >> mvt.tab_indic(it) >> mvt.tab_tcr(it);};
return entree;
};
// surcharge de l'operateur d'ecriture typée
ostream & operator << ( ostream & sort,const MvtSolide & mvt)
{ // tout d'abord un indicateur donnant le type
int taille = mvt.tab_tcr.Taille();
sort << " MvtSolide_ taille: " << taille ;
for (int it=1; it<= taille; it++)
{ sort << " " << mvt.tab_indic(it) << " " << mvt.tab_tcr(it) << " ";};
return sort;
};