190 lines
6.3 KiB
C++
Executable file
190 lines
6.3 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 "Cylindre.h"
|
|
#include "MathUtil.h"
|
|
#include "ParaGlob.h"
|
|
|
|
// CONSTRUCTEURS :
|
|
// par defaut
|
|
Cylindre::Cylindre () :
|
|
cercle(3)
|
|
{ if (ParaGlob::Dimension() != 3)
|
|
{ cout << "\nErreur : la dimension est differente de 3 et on veut utiliser un Cylindre ??? ";
|
|
cout << "\nCylindre::Cylindre ()" << endl;
|
|
Sortie(1);
|
|
};
|
|
};
|
|
// avec les datas
|
|
Cylindre::Cylindre ( const Cercle& cer):
|
|
cercle(cer)
|
|
{ if (ParaGlob::Dimension() != 3)
|
|
{ cout << "\nErreur : la dimension est differente de 3 et on veut utiliser un Cylindre ??? ";
|
|
cout << "\nCylindre::Cylindre (.." << endl;
|
|
Sortie(1);
|
|
};
|
|
};
|
|
|
|
// avec la dimension
|
|
Cylindre::Cylindre (int dim):
|
|
cercle(dim)
|
|
{ if (ParaGlob::Dimension() != 3)
|
|
{ cout << "\nErreur : la dimension est differente de 3 et on veut utiliser un Cylindre ??? ";
|
|
cout << "\nCylindre::Cylindre ()" << endl;
|
|
Sortie(1);
|
|
};
|
|
if (dim != 3)
|
|
{ cout << "\nErreur : la dimension demandee est differente de 3 et on veut utiliser un Cylindre ??? ";
|
|
cout << "\nCylindre::Cylindre ()" << endl;
|
|
Sortie(1);
|
|
};
|
|
};
|
|
|
|
// de copie
|
|
Cylindre::Cylindre ( const Cylindre& a):
|
|
cercle(a.cercle)
|
|
{ };
|
|
|
|
// DESTRUCTEUR :
|
|
Cylindre::~Cylindre ()
|
|
{ };
|
|
|
|
// surcharge des operator
|
|
Cylindre& Cylindre::operator = ( const Cylindre & cer)
|
|
{ cercle = cer.cercle;
|
|
return *this;
|
|
};
|
|
|
|
// METHODES PUBLIQUES :
|
|
|
|
// change le cercle du Cylindre
|
|
void Cylindre::Change_cercle( const Cercle& cer)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (cer.CentreCercle().Dimension() != cercle.CentreCercle().Dimension())
|
|
{ cout << "\nErreur : les dimensions du cercle demande n'est pas identique a celle existante !";
|
|
cout <<"\ndim nouveau = " <<cer.CentreCercle().Dimension()
|
|
<<", dim ancien =" << cercle.CentreCercle().Dimension();
|
|
cout << "\nSphere::Cylindre::Change_cercle( const Cercle& cer)" << endl;
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
cercle = cer;
|
|
};
|
|
|
|
// change toutes les donnees
|
|
void Cylindre::change_donnees( const Cercle& cer)
|
|
{
|
|
#ifdef MISE_AU_POINT
|
|
if (cer.CentreCercle().Dimension() != cercle.CentreCercle().Dimension())
|
|
{ cout << "\nErreur : les dimensions du cercle demande n'est pas identique a celle existante !";
|
|
cout <<"\ndim nouveau = " <<cer.CentreCercle().Dimension()
|
|
<<", dim ancien =" << cercle.CentreCercle().Dimension();
|
|
cout << "\nCylindre::change_donnees( const Cercle& cer,const double& haut)" << endl;
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
cercle = cer;
|
|
};
|
|
|
|
// calcul la distance d'un point au Cylindre
|
|
double Cylindre::Distance_au_Cylindre(const Coordonnee& M) const
|
|
{ // on commence par calculer la projection du point sur l'axe
|
|
Coordonnee CM = M-cercle.CentreCercle();
|
|
const Coordonnee& U = (*(cercle.NormaleCercle()));
|
|
double ch = CM * U;
|
|
Coordonnee CB = ch * U; // B = projection de M sur l'axe
|
|
// def de la distance
|
|
return Dabs((CM-CB).Norme() - cercle.RayonCercle());
|
|
};
|
|
|
|
// ramène true si le point est à l'intérieur du cylindre, false sinon
|
|
bool Cylindre::Dedans(const Coordonnee& M)const
|
|
{ // on commence par calculer la projection du point sur l'axe
|
|
Coordonnee CM = M-cercle.CentreCercle();
|
|
const Coordonnee& U = (*(cercle.NormaleCercle()));
|
|
double ch = CM * U;
|
|
Coordonnee CB = ch * U; // B = projection de M sur l'axe
|
|
// calcul de BM
|
|
Coordonnee BM =(CM-CB);
|
|
double dist_axe = BM.Norme();
|
|
return (dist_axe < cercle.RayonCercle()) ;
|
|
};
|
|
|
|
// projection d'un point M sur la parois du cylindre
|
|
// dans le cas où M appartient à l'axe du cylindre, la projection n'est pas
|
|
// possible, dans ce cas projection_ok = false en retour, sinon true
|
|
Coordonnee Cylindre::Projete(const Coordonnee& M,bool& projection_ok) const
|
|
{ // on commence par calculer la projection du point sur l'axe
|
|
Coordonnee CM = M-cercle.CentreCercle();
|
|
const Coordonnee& U = (*(cercle.NormaleCercle()));
|
|
double ch = CM * U;
|
|
Coordonnee CB = ch * U; // B = projection de M sur l'axe
|
|
// calcul du projeté
|
|
Coordonnee BM =(CM-CB);
|
|
double dist_axe = BM.Norme();
|
|
if (dist_axe < ConstMath::pasmalpetit)
|
|
{projection_ok = false;// on signale que la projection n'est pas possible
|
|
Coordonnee toto;
|
|
return (toto);// on ramène un point par défaut
|
|
}
|
|
else
|
|
{projection_ok = true;
|
|
Coordonnee P = cercle.CentreCercle() + BM * (cercle.RayonCercle() / dist_axe );
|
|
return P;
|
|
};
|
|
};
|
|
|
|
// surcharge de l'operateur de lecture
|
|
istream & operator >> (istream & entree, Cylindre & cer)
|
|
{ // vérification du type
|
|
string nom;
|
|
entree >> nom;
|
|
#ifdef MISE_AU_POINT
|
|
if (nom != "_Cylindre_")
|
|
{ cout << "\nErreur, en lecture d'une instance Cylindre "
|
|
<< " on attendait _Cylindre_ et on a lue: " << nom ;
|
|
cout << "istream & operator >> (istream & entree, Cylindre & cer)\n";
|
|
Sortie(1);
|
|
};
|
|
#endif
|
|
// puis lecture des différents éléments
|
|
entree >> nom >> cer.cercle ;
|
|
return entree;
|
|
};
|
|
|
|
// surcharge de l'operateur d'ecriture
|
|
ostream & operator << ( ostream & sort,const Cylindre & cer)
|
|
{ // tout d'abord un indicateur donnant le type
|
|
sort << " _Cylindre_ " ;
|
|
// puis les différents éléments
|
|
sort << "\n Cercle= " << cer.cercle << " ";
|
|
return sort;
|
|
};
|