+++ /dev/null
-# ifndef INTERPOLATION_HXX
-# define INTERPOLATION_HXX
-
-//template < class T> class FIELD;
-//template < int > class Wrapper_Nuage;
-//template < int > class Wrapper_Noeud;
-//template <class ,class ,int ,int > class dTree;
-
-#include <vector>
-#include "utilities.h"
-#include "MEDMEM_Exception.hxx"
-#include "MEDMEM_define.hxx"
-
-#include "MEDMEM_InterpolationHighLevelObjects.hxx"
-#include "MEDMEM_Mesh.hxx"
-#include "MEDMEM_Field.hxx"
-
-namespace MEDMEM {
-class MESH;
-
-template <int DIMENSION=3> class INTERPOLATION
-{
-protected:
-
- FIELD<double> * _fromField;
- FIELD<double> * _toField;
- MESH * _fromMesh;
- MESH * _toMesh;
-
- Meta_Wrapper<DIMENSION> * _fromWrapper;
- Meta_Wrapper<DIMENSION> * _toWrapper;
-
- Meta_Mapping <DIMENSION> * _mapping;
-
-// only used when multi timestep are interpolated
-// but always coherent
- int _iType;
- int _isConvexFromMesh;
-
-public :
-
- void init();
-
- // Initialize INTERPOLATION in order to get :
- // 1- the node number in the MESH <fromMesh> which
- // is the nearest from a given one ( use method : getNearestNode( double * node ) );
- // 2- the cell number (if exists) in the MESH <fromMesh> which
- // contains a specified node ( use method : getContainingCell ( double * node) )
- INTERPOLATION(const MESH & fromMesh );
- // Initialize INTERPOLATION in order to get :
- // 1- the complete mapping ( use methode : getMapping() )
- // 2- the functionalities above
- INTERPOLATION(const MESH & fromMesh,const MESH & toMesh );
- // Initialize INTERPOLATION in order to get the interpolation of <field> on <toMesh>
- // Moreover, all the others functionalities are so available
- INTERPOLATION(const FIELD<double> & fromField, const MESH & toMesh);
-
- ~INTERPOLATION( );
-
- // Get the node number in the MESH <fromMesh> which is the nearest from a given one
- int getNearestNode ( double * node );
- // Get the cell number (if exists) in the MESH <fromMesh> which contains a specified node
- int getContainingCell ( double * node , int beginingCell=0, int flagIsConvexMesh=0 );
- // Get the complete mapping, defaultly, fromMesh is supposed to be non-convex, if it is false, set flagIsConvexMesh to 1
- vector<int> getMapping ( int flagIsConvexMesh=0 );
- // Get the interpolated field toField
- FIELD<double> * interpolate( /*med_interpolation_type*/ int itype,int flagIsConvexFromMesh=0);
- // reset the <from> parameters in order not to redo the mapping (if the mesh are identical)
- // and then get the interpoated field toField
- // this method is specifictly used on multi-timestep (or order number) fields
- // it has only to be used after the first step, the interpolation paramaters are the same for every step
- FIELD<double> * interpolateNextStep(const FIELD <double> &nextFromField ,int & flagNewMapping);
-
-};
-
-template <int DIMENSION> void INTERPOLATION<DIMENSION>::init() {
-
- const char * LOC = "INTERPOLATION::init(): ";
-
- BEGIN_OF(LOC);
- _fromField = ( FIELD<double> * ) NULL;
- _toField = ( FIELD<double> * ) NULL;
- _fromMesh = ( MESH * ) NULL;
- _toMesh = ( MESH * ) NULL;
- _fromWrapper = ( Meta_Wrapper<DIMENSION> * ) NULL;
- _toWrapper = ( Meta_Wrapper<DIMENSION> * ) NULL;
- _mapping = ( Meta_Mapping<DIMENSION> * ) NULL;
- _iType = UNDEFINED ;
- _isConvexFromMesh = UNDEFINED ;
- END_OF(LOC);
-}
-
-
-template <int DIMENSION> INTERPOLATION<DIMENSION>::INTERPOLATION(const MESH & fromMesh ) {
-
- const char * LOC = "INTERPOLATION::INTERPOLATION(MESH * fromMesh ) : ";
- BEGIN_OF(LOC);
-
- init();
-
- _fromMesh=const_cast<MESH * > (&fromMesh);
-
- if (! _fromMesh ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"fromMesh is a NULL pointer !")) ;
-
- int spaceDimension = _fromMesh->getSpaceDimension();
- if (spaceDimension != DIMENSION ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"The spaceDimension of mesh |" << _fromMesh->getName() << "| is |" << spaceDimension << "| and should be |" << DIMENSION << "|" << endl)) ;
-
- _fromWrapper = new Meta_Wrapper<DIMENSION>(_fromMesh->getNumberOfNodes(),
- const_cast<double *> (_fromMesh->getCoordinates(MED_FULL_INTERLACE)),
- const_cast<CONNECTIVITY *> (_fromMesh->getConnectivityptr())
- );
-
- _mapping = new Meta_Mapping<DIMENSION> (_fromWrapper);
-
- END_OF(LOC);
-};
-
-template <int DIMENSION> INTERPOLATION<DIMENSION>::INTERPOLATION(const MESH & fromMesh,const MESH & toMesh ) {
-
- const char * LOC = "INTERPOLATION::INTERPOLATION(MESH * fromMesh,,const MESH & toMesh) : ";
- BEGIN_OF(LOC);
-
- init();
-
- _fromMesh = const_cast<MESH * > ( &fromMesh );
- _toMesh = const_cast<MESH * > ( &toMesh );
-
- if (! _fromMesh ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"fromMesh is a NULL pointer !")) ;
- if (! _toMesh ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"toMesh is a NULL pointer !")) ;
-
- int fromSpaceDimension = _fromMesh->getSpaceDimension();
- int toSpaceDimension = _toMesh->getSpaceDimension();
-
- if (fromSpaceDimension != DIMENSION ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"The spaceDimension of mesh |" << _fromMesh->getName() << "| is |" << spaceDimension << "| and should be |" << DIMENSION << "|" << endl)) ;
- if ( toSpaceDimension != DIMENSION ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"The spaceDimension of mesh |" << _toMesh->getName() << "| is |" << spaceDimension << "| and should be |" << DIMENSION << "|" << endl)) ;
-
- _fromWrapper = new Meta_Wrapper<DIMENSION>(_fromMesh->getNumberOfNodes(),
- const_cast<double *> (_fromMesh->getCoordinates(MED_FULL_INTERLACE)),
- const_cast<CONNECTIVITY *> (_fromMesh->getConnectivityptr())
- );
-
- _toWrapper = new Meta_Wrapper<DIMENSION>(_toMesh->getNumberOfNodes(),
- const_cast<double *> (_toMesh->getCoordinates(MED_FULL_INTERLACE))
- );
-
- _mapping = new Meta_Mapping<DIMENSION> (_fromWrapper);
-
- END_OF(LOC);
-};
-
-template <int DIMENSION> INTERPOLATION<DIMENSION>::INTERPOLATION(const FIELD<double> & fromField,const MESH & toMesh) {
-
- const char * LOC = "INTERPOLATION(const FIELD<double> & field,const MESH & toMesh) : ";
- BEGIN_OF(LOC);
-
- init();
-
- _toMesh = const_cast<MESH *>(&toMesh);
- _fromField = const_cast<FIELD<double> *>(&fromField);
-
- if ( ! _toMesh ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"toMesh is a NULL pointer !")) ;
- if ( ! _fromField ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"field is a NULL pointer !")) ;
-
- _fromMesh = _fromField->getSupport()->getMesh();
-
- if ( ! _fromMesh ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"fromMesh is a NULL pointer !")) ;
-
- _fromWrapper = new Meta_Wrapper<DIMENSION>(_fromMesh->getNumberOfNodes(),
- const_cast<double *> (_fromMesh->getCoordinates(MED_FULL_INTERLACE)),
- const_cast<CONNECTIVITY *> (_fromMesh->getConnectivityptr()),
- const_cast<FIELD<double> *>(_fromField)
- );
-
-
- _toWrapper = new Meta_Wrapper<DIMENSION>(_toMesh->getNumberOfNodes(),
- const_cast<double *> (_toMesh->getCoordinates(MED_FULL_INTERLACE))
- );
-
-
- _mapping = new Meta_Mapping<DIMENSION> (_fromWrapper);
-
-
- END_OF(LOC);
-};
-
-template <int DIMENSION> INTERPOLATION<DIMENSION>::~INTERPOLATION()
-{
- if ( _fromWrapper ) delete _fromWrapper ;
- if ( _toWrapper ) delete _toWrapper ;
- if ( _mapping ) delete _mapping ;
-};
-
-template <int DIMENSION> int INTERPOLATION<DIMENSION>::getNearestNode( double * node ) {
-
- const char * LOC = "INTERPOLATION::getNearestNode( double * node ) ";
-
- BEGIN_OF(LOC);
-
- if ( ! _mapping ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"mapping is a NULL pointer !")) ;
-
- return _mapping->Donne_dTree()->trouve_plus_proche_point(Wrapper_Noeud<DIMENSION > (node) );
-
- END_OF(LOC);
-
-};
-
-template <int DIMENSION> int INTERPOLATION<DIMENSION>::getContainingCell ( double * node , int beginingCell, int flagIsConvexMesh ) {
-
- const char * LOC = "INTERPOLATION::getContainingCell( double * node ) ";
-
- BEGIN_OF(LOC);
-
- if ( ! _mapping ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"mapping is a NULL pointer !")) ;
-
- _isConvexFromMesh=flagIsConvexMesh;
-
- _mapping->Cree_Mapping(_toWrapper,_isConvexFromMesh);
-
- return _mapping->Trouve_Maille_Contenant_Noeud(node,beginingCell,flagIsConvexMesh);
-
- END_OF(LOC);
-
-};
-
-template <int DIMENSION> vector<int> INTERPOLATION<DIMENSION>::getMapping ( int flagIsConvexMesh ) {
-
- const char * LOC = "INTERPOLATION::getMapping( ) ";
-
- BEGIN_OF(LOC);
-
- if ( ! _mapping ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"mapping is a NULL pointer !")) ;
- if ( ! _toWrapper ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"toWrapper is a NULL pointer !")) ;
-
- _isConvexFromMesh=flagIsConvexMesh;
-
- _mapping->Cree_Mapping(_toWrapper,_isConvexFromMesh);
-
- return _mapping->Get_Mapping();
-
- END_OF(LOC);
-
-};
-
-template <int DIMENSION> FIELD<double> * INTERPOLATION<DIMENSION>::interpolate(int itype,int flagIsConvexFromMesh) {
-
- const char * LOC = "INTERPOLATION::interpolate(int itype,int flagIsConvexFromMesh) ";
-
- BEGIN_OF(LOC);
-
- if ( ! _mapping ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"mapping is a NULL pointer !")) ;
- if ( ! _toWrapper ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"toWrapper is a NULL pointer !")) ;
- if ( ! _fromField ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"fromField is a NULL pointer !")) ;
-
- _iType=itype;
-
- _isConvexFromMesh=flagIsConvexFromMesh;
-
- _mapping->Cree_Mapping(_toWrapper,_isConvexFromMesh);
-
- Wrapper_Nuage_Noeud<DIMENSION> * toNodes = _toWrapper->Get_Nuage_Noeuds();
-
- Wrapper_MED_Field resultat;
-
- /*
- cout<<"Mapping"<<endl;
- _mapping->affiche();
- cout<<"Mailles"<<endl;
- _fromWrapper->Get_Maillage()->DONNE_POINTEUR_NUAGEMAILLE()->affiche();
- cout<<"Noeuds"<<endl;
- _fromWrapper->Get_Nuage_Noeuds()->affiche();
- */
-
- switch (_iType)
- {
- case 0 : // INTERPOLATION P0
- cout<<"Avant ="<<endl;
- resultat=Meta_Interpolateur< Meta_Calcul_Interpolation_P0<DIMENSION>,DIMENSION >(_mapping,_fromWrapper).Perform_Interpolation(toNodes);
- break;
- case 1 : // INTERPOLATION P-Hybride (Interpole avec la fonction d'interpolation naturelle de la maille contenant le point)
- resultat=Meta_Interpolateur< Meta_Calcul_Interpolation_Hybride<DIMENSION>,DIMENSION >(_mapping,_fromWrapper).Perform_Interpolation(toNodes);
- break;
- case 2 : // INTERPOLATION (P/Q) 1 forcée (Interpole avec la fonction élément fini de la maille de degré 1 -meme si la maille est de degré supérieur-)
- resultat=Meta_Interpolateur< Meta_Calcul_Interpolation_Hybride_P1<DIMENSION>, DIMENSION >(_mapping,_fromWrapper).Perform_Interpolation(toNodes);
- break;
- default :
- throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Interpolation type "<<itype<<" not yet implemented !")) ;
- }
-
- cout<<"On a fini l'interpolation"<<endl;
-
- _toField = new FIELD<double>;
-
- _toField->setName ( _fromField->getName() );
- _toField->setDescription ( _fromField->getDescription() );
- _toField->setNumberOfComponents ( _fromField->getNumberOfComponents() );
- _toField->setNumberOfValues ( _toMesh ->getNumberOfNodes() );
- _toField->setComponentsNames ( _fromField->getComponentsNames() );
- _toField->setComponentsDescriptions ( _fromField->getComponentsDescriptions() );
- _toField->setMEDComponentsUnits ( _fromField->getMEDComponentsUnits() );
- _toField->setIterationNumber ( _fromField->getIterationNumber() );
- _toField->setTime ( _fromField->getTime() );
- _toField->setOrderNumber ( _fromField->getOrderNumber() );
- _toField->setValueType ( MED_EN::MED_REEL64 );
-
- SUPPORT * mySupport(new SUPPORT(_toMesh,"support",MED_NODE));
- _toField->setSupport(mySupport);
-
- _toField->allocValue(_toField->getNumberOfComponents(),_toField->getNumberOfValues());
-
- _toField->setValue(MED_FULL_INTERLACE,resultat.Get_Valeurs());
-
- _toWrapper->Construit_Wrapper_Champ(_toField);
-
- return _toField;
-
- END_OF(LOC);
-
-};
-
-template <int DIMENSION> FIELD<double> * INTERPOLATION<DIMENSION>::interpolateNextStep(const FIELD <double> & nextFromField, int & flagNewMapping) {
-
- const char * LOC = "INTERPOLATION::interpolateNextStep(int itype,int flagIsConvexFromMesh) ";
-
- BEGIN_OF(LOC);
-
- if ( ! _mapping ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"mapping is a NULL pointer !" ));
- if ( ! _toWrapper ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"toWrapper is a NULL pointer !" )) ;
- if ( ! _fromWrapper ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"fromWrapper is a NULL pointer !" )) ;
- if ( ! _fromField ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"fromField is a NULL pointer !" )) ;
-
-
- if ( ! _toField ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"toField is a NULL pointer, wrong use of interpolateNextStep" )) ;
- if ( _iType==UNDEFINED ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"_iType is not defined, wrong use of interpolateNextStep" )) ;
- if ( _isConvexFromMesh==UNDEFINED ) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"_isConvexFromMesh is not defined, wrong use of interpolateNextStep" )) ;
-
- // delete _toField; ????????????????????????????
-
- // if the mesh are identical, the mapping is the same, if not, the mapping has to be re-calculated
- if (nextFromField.getSupport()->getMesh()->getName()!=_fromMesh->getName())
- {
-
- flagNewMapping=1;
-
- delete _mapping;
- delete _fromWrapper;
-
- _fromField = const_cast<FIELD<double> *>(&nextFromField);
-
- _fromMesh = _fromField->getSupport()->getMesh();
-
- _fromWrapper = new Meta_Wrapper<DIMENSION>(_fromMesh->getNumberOfNodes(),
- const_cast<double *> (_fromMesh->getCoordinates(MED_FULL_INTERLACE)),
- const_cast<CONNECTIVITY *> (_fromMesh->getConnectivityptr()),
- const_cast<FIELD<double> *>(_fromField)
- );
- _mapping = new Meta_Mapping<DIMENSION> (_fromWrapper);
-
- _mapping->Cree_Mapping(_toWrapper,_isConvexFromMesh);
-
- }
- else
- {
-
- flagNewMapping=0;
-
- _fromField = const_cast<FIELD<double> *>(&nextFromField);
- _fromWrapper->Change_Champ(const_cast<FIELD<double> *>(_fromField));
- }
-
- return interpolate(_iType,_isConvexFromMesh);
-
-};
-
-};
-
-#endif
-
-
+++ /dev/null
-#ifndef MEDMEM_INTERPOLATION_HIGHLEVEL_OBJECTS_HXX
-#define MEDMEM_INTERPOLATION_HIGHLEVEL_OBJECTS_HXX
-
-#include "MEDMEM_Connectivity.hxx"
-#include "MEDMEM_WrapperConnectivity.hxx"
-#include "MEDMEM_dTree.hxx"
-#include "MEDMEM_WrapperNodes.hxx"
-#include "MEDMEM_WrapperMesh.hxx"
-#include "MEDMEM_WrapperCells.hxx"
-#include "MEDMEM_Mapping.hxx"
-#include "MEDMEM_WrapperField.hxx"
-#include "MEDMEM_InterpolationTools.hxx"
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// DECLARATIONS ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-template <int DIMENSION> class Meta_Wrapper;
-
-/*********************************************************/
-/* */
-/* Meta_dTree */
-/* */
-/*********************************************************/
-
-template <int DIMENSION> class Meta_dTree : public dTree<Wrapper_Noeud<DIMENSION>,Wrapper_Nuage_Noeud<DIMENSION>,DIMENSION>
-{
-protected :
- // PATCH
- Wrapper_Nuage_Noeud<DIMENSION> * noeuds;
- // FIN PATCH
-public :
- // PATCH
- Meta_dTree():noeuds(NULL) {}
- ~Meta_dTree() {if (noeuds) delete noeuds;}
- Meta_dTree(int nbr_noeuds,double *coord):dTree<Wrapper_Noeud<DIMENSION>,Wrapper_Nuage_Noeud<DIMENSION>,DIMENSION>(noeuds=new Wrapper_Nuage_Noeud<DIMENSION>(nbr_noeuds,coord)) {}
- inline int trouve_plus_proche_point_bourrin(double *node);
- // FIN PATCH
- inline int trouve_plus_proche_point(double * node);
-};
-
-/*********************************************************/
-/* */
-/* Meta_Nuage_Maille */
-/* */
-/*********************************************************/
-
-
-class Meta_Nuage_Maille : public Wrapper_Nuage_Maille<Wrapper_Med_Connectivity>
-{
-protected :
- Wrapper_Med_Connectivity * connectivite_med;
-public :
- Meta_Nuage_Maille(CONNECTIVITY * connmed);
- Meta_Nuage_Maille():connectivite_med(NULL) {}
- ~Meta_Nuage_Maille() {if (connectivite_med) delete connectivite_med;}
-};
-
-/*********************************************************/
-/* */
-/* Meta_Maillage */
-/* */
-/*********************************************************/
-
-
-typedef Wrapper_Maillage<Meta_Nuage_Maille> Meta_Maillage;
-
-/*********************************************************/
-/* */
-/* Meta_Mapping */
-/* */
-/*********************************************************/
-
-template <int DIMENSION> class Meta_Mapping : public Mapping<Meta_Maillage,Meta_Nuage_Maille,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,DIMENSION>
-{
-public :
- Meta_Mapping(Meta_Wrapper<DIMENSION> * MW):Mapping<Meta_Maillage,Meta_Nuage_Maille,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,DIMENSION>(MW->Get_Maillage(),MW->Get_Nuage_Noeuds(),NULL) {}
- Meta_Mapping(Meta_Wrapper<DIMENSION> * MW,Meta_Wrapper<DIMENSION> * TWB):Mapping<Meta_Maillage,Meta_Nuage_Maille,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,DIMENSION>(MW->Get_Maillage(),MW->Get_Nuage_Noeuds(),TWB->Get_Nuage_Noeuds()) {}
- // PATCH
- inline void Cree_Mapping(Meta_Wrapper<DIMENSION> * MWB, int flag_convexe) {Mapping<Meta_Maillage,Meta_Nuage_Maille,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,DIMENSION>::Cree_Mapping(MWB->Get_Nuage_Noeuds(),flag_convexe);}
- inline void Cree_Mapping(int flag_convexe) {Mapping<Meta_Maillage,Meta_Nuage_Maille,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,DIMENSION>::Cree_Mapping(flag_convexe);}
- inline vector<int> & Get_Mapping() {return Mapping<Meta_Maillage,Meta_Nuage_Maille,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,DIMENSION>::Get_Mapping();}
- //FIN PATCH
- inline int Trouve_Maille_Contenant_Noeud(double * node,int num_maille, int flag_convexe=0);
-};
-
-/*********************************************************/
-/* */
-/* Meta_Wrapper */
-/* */
-/*********************************************************/
-
-
-template <int DIMENSION> class Meta_Wrapper
-{
-protected :
- Wrapper_Nuage_Noeud<DIMENSION> * noeuds ;
- Meta_Nuage_Maille * mailles ;
- Meta_Maillage * maillage ;
- Wrapper_MED_Field * champ ;
-
- void init( ){noeuds=NULL;mailles=NULL;maillage=NULL;champ=NULL;}
-public :
- Meta_Wrapper():noeuds(NULL),mailles(NULL),maillage(NULL),champ(NULL){}
- ~Meta_Wrapper();
- inline void Construit_Wrapper_Nuage_Noeud ( int nn, double * nodes );
- inline void Construit_Wrapper_Nuage_Maille ( CONNECTIVITY * connmed );
- inline void Construit_Wrapper_Maillage ( void );
- inline void Construit_Wrapper_Champ ( const FIELD<double> * medfield );
- Meta_Wrapper(int nn,double *nodes,CONNECTIVITY *connmed, int flag_maillage=1);
- Meta_Wrapper(int nn,double *nodes);
- // defaultly, the connectivity (neighbouhood and so like) is built,
- // Set flag_mesh to 0 if you don't want these informations to be built
- Meta_Wrapper(int nn,double *nodes,CONNECTIVITY *connmed, const FIELD<double> * c,int flag_mesh=1);
- // fonctions d'acces sures
- inline Wrapper_Nuage_Noeud<DIMENSION> * Get_Nuage_Noeuds ( void );
- inline Meta_Nuage_Maille * Get_Nuage_Mailles ( void );
- inline Meta_Maillage * Get_Maillage ( void );
- inline Wrapper_MED_Field * Get_Champ ( void );
- inline void Change_Champ ( const FIELD<double> * medfield );
-};
-
-/*********************************************************/
-/* */
-/* Meta_Calcul_Interpolation_Hybride */
-/* */
-/*********************************************************/
-
-template <int DIMENSION> class Meta_Calcul_Interpolation_Hybride : public Calcul_Hybride<Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>
-{
-public :
- Meta_Calcul_Interpolation_Hybride(Meta_Wrapper<DIMENSION> * MW):Calcul_Hybride<Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>(MW->Get_Nuage_Noeuds(),MW->Get_Nuage_Mailles(),MW->Get_Champ()) {}
- Valeur<double> operator() (Wrapper_Noeud<DIMENSION> & node, int num_maille){return Calcul_Hybride<Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>::operator()(node,num_maille);}
- Valeur<double> operator() (double * node, int num_maille)
- {
- static Wrapper_Noeud<DIMENSION> tmp;
- tmp.positionne(node);
- return Calcul_Hybride<Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>(tmp,num_maille);
- }
-};
-
-/*********************************************************/
-/* */
-/* Meta_Calcul_Interpolation_Hybride_P1 */
-/* */
-/*********************************************************/
-
-template <int DIMENSION> class Meta_Calcul_Interpolation_Hybride_P1 : public Calcul_Hybride<Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>
-{
-public :
- Meta_Calcul_Interpolation_Hybride_P1(Meta_Wrapper<DIMENSION> * MW)
- {
-
- Wrapper_Nuage_Noeud<DIMENSION> * nn = MW->Get_Nuage_Noeuds();
- Meta_Nuage_Maille * nm = MW->Get_Nuage_Mailles();
- Wrapper_MED_Field * c = MW->Get_Champ();
-
- mailles=nm;
-
- fonctions[MED_TRIA3 ]=new Calcul_Interpolation_Tria3 <Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>(nn,nm,c);
- fonctions[MED_QUAD4 ]=new Calcul_Interpolation_Quad4 <Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>(nn,nm,c);
- fonctions[MED_TETRA4 ]=new Calcul_Interpolation_Tetra4 <Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>(nn,nm,c);
- fonctions[MED_HEXA8 ]=new Calcul_Interpolation_Hexa8 <Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>(nn,nm,c);
- fonctions[MED_PENTA6 ]=new Calcul_Interpolation_Penta6 <Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>(nn,nm,c);
- fonctions[MED_PYRA5 ]=new Calcul_Interpolation_Pyra5 <Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>(nn,nm,c);
- fonctions[MED_TRIA6 ]=fonctions[MED_TRIA3 ];
- fonctions[MED_QUAD8 ]=fonctions[MED_QUAD4 ];
- fonctions[MED_TETRA10]=fonctions[MED_TETRA4 ];
- fonctions[MED_HEXA20 ]=fonctions[MED_HEXA8 ];
- fonctions[MED_PENTA15]=fonctions[MED_PENTA6 ];
- fonctions[MED_PYRA13 ]=fonctions[MED_PYRA5 ];
- }
- Valeur<double> operator() (Wrapper_Noeud<DIMENSION> & node, int num_maille){return Calcul_Hybride<Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>::operator()(node,num_maille);}
- Valeur<double> operator() (double * node, int num_maille)
- {
- static Wrapper_Noeud<DIMENSION> tmp;
- tmp.positionne(node);
- return Calcul_Hybride<Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>(tmp,num_maille);
- }
-};
-
-/*********************************************************/
-/* */
-/* Meta_Calcul_Interpolation_P0 */
-/* */
-/*********************************************************/
-
-template <int DIMENSION> class Meta_Calcul_Interpolation_P0 : public Calcul_Interpolation_P0<Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>
-{
-public :
- Meta_Calcul_Interpolation_P0(Meta_Wrapper<DIMENSION> * MW):Calcul_Interpolation_P0<Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>(MW->Get_Nuage_Noeuds(),MW->Get_Nuage_Mailles(),MW->Get_Champ()) {}
- Valeur<double> operator() (Wrapper_Noeud<DIMENSION> & node, int num_maille){return Calcul_Interpolation_P0<Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>::operator()(node,num_maille);}
- Valeur<double> operator() (double * node, int num_maille)
- {
- static Wrapper_Noeud<DIMENSION> tmp;
- tmp.positionne(node);
- return Calcul_Interpolation_P0<Wrapper_MED_Field,Valeur<double>,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,Meta_Nuage_Maille>(tmp,num_maille);
- }
-};
-
-/*********************************************************/
-/* */
-/* Meta_Interpolateur */
-/* */
-/*********************************************************/
-
-template <class FONCTEUR, int DIMENSION> class Meta_Interpolateur
-{
-protected :
- FONCTEUR * fct;
- Meta_Mapping<DIMENSION> * mapping;
- Meta_Wrapper<DIMENSION> * fromWrapper;
-public :
- Meta_Interpolateur():fct(NULL),mapping(NULL),fromWrapper(NULL) {}
- Meta_Interpolateur(Meta_Mapping<DIMENSION> * map, Meta_Wrapper<DIMENSION> * mw):mapping(map),fromWrapper(mw),fct(new FONCTEUR(mw)){}
- ~Meta_Interpolateur() {if (fct) delete fct;}
- Wrapper_MED_Field Perform_Interpolation(Wrapper_Nuage_Noeud<DIMENSION> * toNodes)
- {
- int i;
-
- int ni=0;
- int ne=0;
-
- int nbr_composantes = fromWrapper->Get_Champ()->Get_Nbr_Composantes();
- int nbr_valeurs = toNodes->SIZE();
-
- double * valeurs=new double[nbr_valeurs*nbr_composantes];
-
- Wrapper_MED_Field resultat(nbr_valeurs,nbr_composantes,valeurs);
-
- int nlpp,nmc;
-
- for (i=0;i<nbr_valeurs;i++)
- {
- //cout<<"Interpolation du noeud "<<i<<flush;
- nmc = (*mapping)[i];
- //cout<<" | mappé dans la maille "<<nmc<<flush;
- //cout<<" | coordonnées = "<<flush<<(*toNodes)[i]<<flush;
- if (nmc>=0)
- {
- //cout<<" | valeurs qui va etre assignée = "<<flush<<(*fct)((*toNodes)[i],nmc)<<flush;
- resultat[i]=(*fct)((*toNodes)[i],nmc);
- ni++;
- }
- else
- {
- nlpp = mapping->Get_Noeud_Le_Plus_Proche(i);
- //cout<<" | et dont le point le plus proche a pour numéro : "<<nlpp<<flush;
- //cout<<" | valeurs qui va etre assignée = "<<(*fromWrapper->Get_Champ())[nlpp]<<flush;
- if (nlpp!=UNDEFINED)
- {
- resultat[i]=(*fromWrapper->Get_Champ())[nlpp];
- ne++;
- }
- else
- {
- cerr<<"Meta_Interpolateur : Le noeud "<<i+1<<" n'a ni maille contenante, ni point le plus proche"<<flush;
- exit(-1);
- }
- }
- //cout<<" | => OK ! "<<endl;
- }
-
- cout<<"Résultat de l'interpolation : "<<endl;
- cout<<"Nombre de noeuds intérieurs = "<<ni<<endl;
- cout<<"Nombre de noeuds extérieurs = "<<ne<<endl;
-
- return resultat;
-
- }
-};
-
-
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// CODE ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-/*********************************************************/
-/* */
-/* Meta_dTree */
-/* */
-/*********************************************************/
-
-template <int DIMENSION> inline int Meta_dTree<DIMENSION>::trouve_plus_proche_point(double *node)
- {
- static Wrapper_Noeud<DIMENSION> nodetmp;
- nodetmp.positionne(node);
- return dTree<Wrapper_Noeud<DIMENSION>,Wrapper_Nuage_Noeud<DIMENSION>,DIMENSION>::trouve_plus_proche_point(Wrapper_Noeud<DIMENSION>(nodetmp));
- }
-// PATCH
-template <int DIMENSION> inline int Meta_dTree<DIMENSION>::trouve_plus_proche_point_bourrin(double *node)
- {
- static Wrapper_Noeud<DIMENSION> nodetmp;
- nodetmp.positionne(node);
- return dTree<Wrapper_Noeud<DIMENSION>,Wrapper_Nuage_Noeud<DIMENSION>,DIMENSION>::trouve_plus_proche_point_bourrin(Wrapper_Noeud<DIMENSION>(nodetmp));
- }
-/*********************************************************/
-/* */
-/* Meta_Nuage_Maille */
-/* */
-/*********************************************************/
-
-Meta_Nuage_Maille::Meta_Nuage_Maille(CONNECTIVITY * conmed):Wrapper_Nuage_Maille<Wrapper_Med_Connectivity>(connectivite_med=new Wrapper_Med_Connectivity(conmed))
- {
- }
-
-/*********************************************************/
-/* */
-/* Meta_Mapping */
-/* */
-/*********************************************************/
-
-template <int DIMENSION> inline int Meta_Mapping<DIMENSION>::Trouve_Maille_Contenant_Noeud(double * node,int num_maille,int flag_convexe)
- {
- int interdit=num_maille;
- int max_loop=100;
- int nme=0;
- static Wrapper_Noeud<DIMENSION> nodetmp;
- nodetmp.positionne(node);
- return Mapping<Meta_Maillage,Meta_Nuage_Maille,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,DIMENSION>::Trouve_Maille_Contenant_Point_Mth_Co(nodetmp,num_maille,interdit,max_loop,nme,flag_convexe);
- }
-
-/*********************************************************/
-/* */
-/* Meta_Wrapper */
-/* */
-/*********************************************************/
-
-template <int DIMENSION> Meta_Wrapper<DIMENSION>::~Meta_Wrapper()
- {
- if ( noeuds ) delete noeuds ;
- if ( mailles ) delete mailles ;
- if ( maillage ) delete maillage ;
- if ( champ ) delete champ ;
- }
-template <int DIMENSION> inline void Meta_Wrapper<DIMENSION>::Construit_Wrapper_Nuage_Noeud ( int nn, double * nodes )
- {
- if (nodes) noeuds=new Wrapper_Nuage_Noeud<DIMENSION>(nn,nodes);
- else
- {
- cerr<<"Meta_Wrapper : Nuage MED_FULL_INTERLACE vide passé en argument au constructeur"<<endl;
- exit(-1);
- }
- }
-template <int DIMENSION> inline void Meta_Wrapper<DIMENSION>::Construit_Wrapper_Nuage_Maille ( CONNECTIVITY * connmed )
- {
- if (connmed) mailles=new Meta_Nuage_Maille(connmed);
- else
- {
- cerr<<"Meta_Wrapper : CONNECTIVITY vide passée en argument au constructeur"<<endl;
- exit(-1);
- }
- }
-template <int DIMENSION> inline void Meta_Wrapper<DIMENSION>::Construit_Wrapper_Maillage ( void )
- {
- if (mailles==NULL)
- {
- cerr<<"Meta_Wrapper : Le nuage de maille n'a pas été initialisé !"<<endl;
- exit(-1);
- }
- if (noeuds==NULL)
- {
- cerr<<"Meta_Wrapper : Le nuage de noeuds n'a pas été initialisé !"<<endl;
- exit(-1);
- }
- maillage=new Meta_Maillage(mailles,noeuds->SIZE());
- }
-template <int DIMENSION> inline void Meta_Wrapper<DIMENSION>::Construit_Wrapper_Champ ( const FIELD<double> * medfield )
- {
- if (medfield) champ=new Wrapper_MED_Field(medfield);
- else
- {
- cerr<<"Meta_Wrapper : FIELD MED vide passé en argument au constructeur"<<endl;
- exit(-1);
- }
- }
-template <int DIMENSION> inline void Meta_Wrapper<DIMENSION>::Change_Champ ( const FIELD<double> * medfield )
- {
- if (medfield)
- {
- if (champ) delete champ;
- champ=new Wrapper_MED_Field(medfield);
- }
- else
- {
- cerr<<"Meta_Wrapper : FIELD MED vide passé en argument Change_Champ"<<endl;
- exit(-1);
- }
- }
-template <int DIMENSION> Meta_Wrapper<DIMENSION>::Meta_Wrapper(int nn,double *nodes,CONNECTIVITY *connmed, int flag_maillage)
- {
- init();
- Construit_Wrapper_Nuage_Noeud(nn,nodes);
- Construit_Wrapper_Nuage_Maille(connmed);
- if (flag_maillage) Construit_Wrapper_Maillage();
- }
-template <int DIMENSION> Meta_Wrapper<DIMENSION>::Meta_Wrapper(int nn,double *nodes,CONNECTIVITY *connmed, const FIELD<double> * c,int flag_maillage)
- {
- init();
- Construit_Wrapper_Nuage_Noeud(nn,nodes);
- Construit_Wrapper_Nuage_Maille(connmed);
- if (flag_maillage) Construit_Wrapper_Maillage();
- Construit_Wrapper_Champ(c);
- }
-template <int DIMENSION> Meta_Wrapper<DIMENSION>::Meta_Wrapper(int nn,double *nodes)
- {
- init();
- Construit_Wrapper_Nuage_Noeud(nn,nodes);
- }
-template <int DIMENSION> inline Wrapper_Nuage_Noeud<DIMENSION> * Meta_Wrapper<DIMENSION>::Get_Nuage_Noeuds ( void )
- {
- if (noeuds) return noeuds;
- else
- {
- cerr<<"Meta_Wrapper : Nuage noeuds demandé alors qu'il n'est pas construit !"<<endl;
- exit(-1);
- }
- }
-template <int DIMENSION> inline Meta_Nuage_Maille * Meta_Wrapper<DIMENSION>::Get_Nuage_Mailles ( void )
- {
- if (mailles) return mailles ;
- else
- {
- cerr<<"Meta_Wrapper : Nuage mailles demandé alors qu'il n'est pas construit !"<<endl;
- exit(-1);
- }
- }
-template <int DIMENSION> inline Meta_Maillage * Meta_Wrapper<DIMENSION>::Get_Maillage ( void )
- {
- if (maillage) return maillage ;
- else
- {
- cerr<<"Meta_Wrapper : Connectivitée maillage demandée alors qu'elle n'est pas construite !"<<endl;
- exit(-1);
- }
- }
-
-template <int DIMENSION> inline Wrapper_MED_Field * Meta_Wrapper<DIMENSION>::Get_Champ ( void )
- {
- if (champ) return champ;
- else
- {
- cerr<<"Meta_Wrapper : Champ demandé alors qu'il n'est pas construit !"<<endl;
- exit(-1);
- }
- }
-
-#endif
+++ /dev/null
-#ifndef MEDMEM_INTERPOLATION_HIGHLEVEL_OBJECTS_HXX
-
-#define MEDMEM_INTERPOLATION_HIGHLEVEL_OBJECTS_HXX
-#include "MEDMEM_Connectivity.hxx"
-#include "MEDMEM_WrapperConnectivity.hxx"
-#include "MEDMEM_dTree.hxx"
-#include "MEDMEM_WrapperNodes.hxx"
-#include "MEDMEM_WrapperMesh.hxx"
-#include "MEDMEM_WrapperCells.hxx"
-#include "MEDMEM_Mapping.hxx"
-
-// DECLARATIONS
-
-template <int DIMENSION> class Meta_dTree : public dTree<Wrapper_Noeud<DIMENSION>,Wrapper_Nuage_Noeud<DIMENSION>,DIMENSION>
-{
-protected :
- Wrapper_Nuage_Noeud<DIMENSION> * nuagetmp;
-public :
- Meta_dTree(int nn,double * fullinterlace);
- ~Meta_dTree() {if ((etat==DTREE_RACINE)&&(nuagetmp)) delete nuagetmp;}
- inline int trouve_plus_proche_point(double *node);
-};
-
-class Meta_Nuage_Maille : public Wrapper_Nuage_Maille<Wrapper_Med_Connectivity>
-{
-protected :
- Wrapper_Med_Connectivity * connectivite_med;
-public :
- Meta_Nuage_Maille(CONNECTIVITY * connmed);
- Meta_Nuage_Maille():Wrapper_Nuage_Maille<Wrapper_Med_Connectivity>(connectivite_med=new Wrapper_Med_Connectivity) {}
- ~Meta_Nuage_Maille() {if (connectivite_med) delete connectivite_med;}
-};
-
-
-typedef Wrapper_Maillage<Meta_Nuage_Maille> Meta_Maillage;
-
-template <int DIMENSION> class Meta_Mapping : public Mapping<Meta_Maillage,Meta_Nuage_Maille,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,DIMENSION>
-{
-protected :
- Wrapper_Nuage_Noeud<DIMENSION> * wrapping_nuage_source;
- Wrapper_Nuage_Noeud<DIMENSION> * wrapping_nuage_cible;
-public :
- Meta_Mapping(Meta_Maillage * mb,double * noeudssource,int ns,double * noeudscible,int nc);
- ~Meta_Mapping() {if (wrapping_nuage_source) delete wrapping_nuage_source;if (wrapping_nuage_cible) delete wrapping_nuage_cible;}
- inline int Trouve_Maille_Contenant_Noeud(double * node,int num_maille, int flag_convexe=0);
- double donne_valeur_interpolee_P1(double * node,vector<double> vals);
-};
-
-// CODE
-
-template <int DIMENSION> Meta_dTree<DIMENSION>::Meta_dTree(int nn,double * fullinterlace)
-:dTree<Wrapper_Noeud<DIMENSION>,Wrapper_Nuage_Noeud<DIMENSION>,DIMENSION>
-(nuagetmp=new Wrapper_Nuage_Noeud<DIMENSION>(nn,fullinterlace))
- {
- }
-
-template <int DIMENSION> inline int Meta_dTree<DIMENSION>::trouve_plus_proche_point(double *node)
- {
- static Wrapper_Noeud<DIMENSION> nodetmp;
- nodetmp.positionne(node);
- return dTree<Wrapper_Noeud<DIMENSION>,Wrapper_Nuage_Noeud<DIMENSION>,DIMENSION>::trouve_plus_proche_point(Wrapper_Noeud<DIMENSION>(nodetmp));
- }
-
-//*
-Meta_Nuage_Maille::Meta_Nuage_Maille(CONNECTIVITY * conmed):Wrapper_Nuage_Maille<Wrapper_Med_Connectivity>(connectivite_med=new Wrapper_Med_Connectivity(conmed))
- {
- }
-//*/
-
-template <int DIMENSION> Meta_Mapping<DIMENSION>::Meta_Mapping(Meta_Maillage * mb,double * noeudssource,int ns,double * noeudscible,int nc)
-:Mapping<Meta_Maillage,Meta_Nuage_Maille,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,DIMENSION>
-(mb,
-wrapping_nuage_source=new Wrapper_Nuage_Noeud<DIMENSION>(ns,noeudssource),
-wrapping_nuage_cible=new Wrapper_Nuage_Noeud<DIMENSION>(nc,noeudscible))
- {
- }
-
-template <int DIMENSION> inline int Meta_Mapping<DIMENSION>::Trouve_Maille_Contenant_Noeud(double * node,int num_maille,int flag_convexe)
- {
- int interdit=num_maille;
- int max_loop=100;
- int nme=0;
- static Wrapper_Noeud<DIMENSION> nodetmp;
- nodetmp.positionne(node);
- return Mapping<Meta_Maillage,Meta_Nuage_Maille,Wrapper_Nuage_Noeud<DIMENSION>,Wrapper_Noeud<DIMENSION>,DIMENSION>::Trouve_Maille_Contenant_Point_Mth_Co(nodetmp,num_maille,interdit,max_loop,nme,flag_convexe);
- }
-template <int DIMENSION> double Meta_Mapping<DIMENSION>::donne_valeur_interpolee_P1(double * node,vector<double> vals)
- {
- int num_maille_contenant=Trouve_Maille_Contenant_Noeud(node,0);
- double valeur_interpol=0;
- vector<double> valeurs=CB->Calcule_Coord_Baryc(num_maille_contenant,node);
- int i;
- int num_som;
- for (i=0;i<valeurs.size();i++)
- {
- cout<<"Lambda(M):"<<i<<" = "<<valeurs[i]<<endl;
- num_som=mailles_back->DONNE_SOMMET_MAILLE(num_maille_contenant,i);
- valeur_interpol+=vals[num_som]*valeurs[i];
- }
-
- return valeur_interpol;
- }
-
-#endif
+++ /dev/null
-#ifndef MEDMEM_INTERPOLATION_TOOLS_HXX
-#define MEDMEM_INTERPOLATION_TOOLS_HXX
-
-#include "MEDMEM_define.hxx"
-
-#define _TEMPLATE_ template <class CHAMP,class VALEURCHAMP,class NUAGENOEUD, class NOEUD, class NUAGEMAILLE>
-#define _PARAM_ CHAMP,VALEURCHAMP,NUAGENOEUD,NOEUD,NUAGEMAILLE
-
-// ces macros définissent pour une face carrée plane la fonction projection sur cette face, non normalisée, la numérotation est dans le cas d'un hexaedre
-#define face2367(x,y,z) ((x6*(-y2 + y3) + x3*(y2 - y6) + x2*(-y3 + y6))*z - x6*y3*z2 + x3*y6*z2 + x6*y2*z3 - x2*y6*z3 - x3*y2*z6 + x2*y3*z6 + y*(x6*(z2 - z3) + x2*(z3 - z6) + x3*(-z2 + z6)) + x*(y6*(-z2 + z3) + y3*(z2 - z6) + y2*(-z3 + z6)))
-#define face4567(x,y,z) ((x6*(-y4 + y5) + x5*(y4 - y6) + x4*(-y5 + y6))*z - x6*y5*z4 + x5*y6*z4 + x6*y4*z5 - x4*y6*z5 - x5*y4*z6 + x4*y5*z6 + y*(x6*(z4 - z5) + x4*(z5 - z6) + x5*(-z4 + z6)) + x*(y6*(-z4 + z5) + y5*(z4 - z6) + y4*(-z5 + z6)))
-#define face1256(x,y,z) ((x5*(-y1 + y2) + x2*(y1 - y5) + x1*(-y2 + y5))*z - x5*y2*z1 + x2*y5*z1 + x5*y1*z2 - x1*y5*z2 - x2*y1*z5 + x1*y2*z5 + y*(x5*(z1 - z2) + x1*(z2 - z5) + x2*(-z1 + z5)) + x*(y5*(-z1 + z2) + y2*(z1 - z5) + y1*(-z2 + z5)))
-#define face0347(x,y,z) ((x4*(-y0 + y3) + x3*(y0 - y4) + x0*(-y3 + y4))*z - x4*y3*z0 + x3*y4*z0 + x4*y0*z3 - x0*y4*z3 - x3*y0*z4 + x0*y3*z4 + y*(x4*(z0 - z3) + x0*(z3 - z4) + x3*(-z0 + z4)) + x*(y4*(-z0 + z3) + y3*(z0 - z4) + y0*(-z3 + z4)))
-#define face0145(x,y,z) ((x4*(-y0 + y1) + x1*(y0 - y4) + x0*(-y1 + y4))*z - x4*y1*z0 + x1*y4*z0 + x4*y0*z1 - x0*y4*z1 - x1*y0*z4 + x0*y1*z4 + y*(x4*(z0 - z1) + x0*(z1 - z4) + x1*(-z0 + z4)) + x*(y4*(-z0 + z1) + y1*(z0 - z4) + y0*(-z1 + z4)))
-#define face0123(x,y,z) ((x2*(-y0 + y1) + x1*(y0 - y2) + x0*(-y1 + y2))*z - x2*y1*z0 + x1*y2*z0 + x2*y0*z1 - x0*y2*z1 - x1*y0*z2 + x0*y1*z2 + y*(x2*(z0 - z1) + x0*(z1 - z2) + x1*(-z0 + z2)) + x*(y2*(-z0 + z1) + y1*(z0 - z2) + y0*(-z1 + z2)))
-// des macros définissent pour une face triangulaire orientée vers l'extérieur de la maille la fonction de projection, non normalisée ( =(12^13).1M )
-#define face(x1,y1,z1,x2,y2,z2,x3,y3,z3,x,y,z) ( ((y2-y1)*(z3-z1)-(z2-z1)*(y3-y1))*(x-x1)+((z2-z1)*(x3-x1)-(x2-x1)*(z3-z1))*(y-y1)+((x2-x1)*(y3-y1)-(y2-y1)*(x3-x1))*(z-z1) )
-#define projection(x1,y1,z1,x2,y2,z2,x3,y3,z3,x0,y0,z0,x,y,z) (face(x1,y1,z1,x2,y2,z2,x3,y3,z3,x,y,z)/face(x1,y1,z1,x2,y2,z2,x3,y3,z3,x0,y0,z0))
-
-// DECLARATION
-
-_TEMPLATE_ class Calcul_Interpolation
-{
-protected :
- NUAGENOEUD * noeuds;
- NUAGEMAILLE * mailles;
- CHAMP * champ;
-public :
- Calcul_Interpolation():noeuds(NULL),mailles(NULL),champ(NULL) {}
- Calcul_Interpolation(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):noeuds(nn),mailles(nm),champ(c) {}
- ~Calcul_Interpolation() {}
- virtual VALEURCHAMP operator() (const NOEUD & n, int num_maille) {cerr<<"APPEL OPERATOR() DE LA CLASSE MERE CALCUL_INTERPOLATION => EXIT(-1)"<<endl;exit(-1);}
-};
-
-_TEMPLATE_ class Calcul_Interpolation_P0;
-
-_TEMPLATE_ class Calcul_Interpolation_Tria3;
-_TEMPLATE_ class Calcul_Interpolation_Tria6;
-_TEMPLATE_ class Calcul_Interpolation_Quad4;
-_TEMPLATE_ class Calcul_Interpolation_Quad8;
-_TEMPLATE_ class Calcul_Interpolation_Tetra4;
-_TEMPLATE_ class Calcul_Interpolation_Tetra10;
-_TEMPLATE_ class Calcul_Interpolation_Hexa8;
-_TEMPLATE_ class Calcul_Interpolation_Hexa20;
-_TEMPLATE_ class Calcul_Interpolation_Penta6;
-_TEMPLATE_ class Calcul_Interpolation_Penta15;
-_TEMPLATE_ class Calcul_Interpolation_Pyra5;
-_TEMPLATE_ class Calcul_Interpolation_Pyra13;
-
-_TEMPLATE_ class Calcul_Hybride
-{
-protected :
- NUAGEMAILLE * mailles;
- map<int,Calcul_Interpolation<_PARAM_> *> fonctions;
-public :
- Calcul_Hybride():mailles(NULL) {}
- Calcul_Hybride(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c);
- ~Calcul_Hybride() {}
- VALEURCHAMP operator() (const NOEUD & n, int num_maille);
-};
-
-//CODE
-
-_TEMPLATE_ Calcul_Hybride<_PARAM_>::Calcul_Hybride(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):mailles(nm)
- {
- fonctions[MED_TRIA3 ]=new Calcul_Interpolation_Tria3 <_PARAM_>(nn,nm,c);
- fonctions[MED_TRIA6 ]=new Calcul_Interpolation_Tria6 <_PARAM_>(nn,nm,c);
- fonctions[MED_QUAD4 ]=new Calcul_Interpolation_Quad4 <_PARAM_>(nn,nm,c);
- fonctions[MED_QUAD8 ]=new Calcul_Interpolation_Quad8 <_PARAM_>(nn,nm,c);
- fonctions[MED_TETRA4 ]=new Calcul_Interpolation_Tetra4 <_PARAM_>(nn,nm,c);
- fonctions[MED_TETRA10]=new Calcul_Interpolation_Tetra10<_PARAM_>(nn,nm,c);
- fonctions[MED_HEXA8 ]=new Calcul_Interpolation_Hexa8 <_PARAM_>(nn,nm,c);
- fonctions[MED_HEXA20 ]=new Calcul_Interpolation_Hexa20 <_PARAM_>(nn,nm,c);
- fonctions[MED_PENTA6 ]=new Calcul_Interpolation_Penta6 <_PARAM_>(nn,nm,c);
- fonctions[MED_PENTA15]=new Calcul_Interpolation_Penta15<_PARAM_>(nn,nm,c);
- fonctions[MED_PYRA5 ]=new Calcul_Interpolation_Pyra5 <_PARAM_>(nn,nm,c);
- fonctions[MED_PYRA13 ]=new Calcul_Interpolation_Pyra13 <_PARAM_>(nn,nm,c);
- }
-
-_TEMPLATE_ VALEURCHAMP Calcul_Hybride<_PARAM_>::operator() (const NOEUD & n, int num_maille)
- {
- return fonctions[(*mailles)[num_maille].DONNE_TYPE_MED_MAILLE()]->operator()(n,num_maille);
- }
-
-_TEMPLATE_ class Calcul_Interpolation_P0 : public Calcul_Interpolation<_PARAM_>
-{
-public : Calcul_Interpolation_P0(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):Calcul_Interpolation<_PARAM_>(nn,nm,c) {}
-public : VALEURCHAMP operator() (const NOEUD & n, int num_maille)
- {
- return (*champ)[num_maille];
- }
-};
-_TEMPLATE_ class Calcul_Interpolation_Tria3 : public Calcul_Interpolation<_PARAM_>
-{
-public : Calcul_Interpolation_Tria3(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):Calcul_Interpolation<_PARAM_>(nn,nm,c) {}
-public : VALEURCHAMP operator() (const NOEUD & n, int num_maille)
- {
- int num0=(*mailles)[num_maille][0];
- int num1=(*mailles)[num_maille][1];
- int num2=(*mailles)[num_maille][2];
-
- double x0=(*noeuds)[num0][0];
- double y0=(*noeuds)[num0][1];
- double x1=(*noeuds)[num1][0];
- double y1=(*noeuds)[num1][1];
- double x2=(*noeuds)[num2][0];
- double y2=(*noeuds)[num2][1];
-
- VALEURCHAMP v0=(*champ)[num0];
- VALEURCHAMP v1=(*champ)[num1];
- VALEURCHAMP v2=(*champ)[num2];
-
- double x=n[0];
- double y=n[1];
-
- double lambda0=(y1-y2)*x+(x2-x1)*y+(x1*y2-x2*y1);
- double lambda1=(y2-y0)*x+(x0-x2)*y+(x2*y0-x0*y2);
- double lambda2=(y0-y1)*x+(x1-x0)*y+(x0*y1-x1*y0);
-
- double delta = (x2-x1)*y0+(x0-x2)*y1+(x1-x0)*y2;
-
- VALEURCHAMP retour(v0.SIZE());
-
- retour=(1/delta)*(lambda0*v0+lambda1*v1+lambda2*v2);
-
- return retour; //
- }
-};
-_TEMPLATE_ class Calcul_Interpolation_Tria6 : public Calcul_Interpolation<_PARAM_>
-{
-public : Calcul_Interpolation_Tria6(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):Calcul_Interpolation<_PARAM_>(nn,nm,c) {}
-public : VALEURCHAMP operator() (const NOEUD & n, int num_maille)
- {
- // ON SUPPOSE IMPLICITEMENT QUE LES NOEUDS SUPPLEMENTAIRES SONT BIEN DES NOEUDS MILIEUX
- int num0 =(*mailles)[num_maille][0];
- int num1 =(*mailles)[num_maille][1];
- int num2 =(*mailles)[num_maille][2];
- int num01=(*mailles)[num_maille][3];
- int num12=(*mailles)[num_maille][4];
- int num20=(*mailles)[num_maille][5];
-
- double x0=(*noeuds)[num0][0];
- double y0=(*noeuds)[num0][1];
- double x1=(*noeuds)[num1][0];
- double y1=(*noeuds)[num1][1];
- double x2=(*noeuds)[num2][0];
- double y2=(*noeuds)[num2][1];
-
- VALEURCHAMP v0=(*champ)[num0];
- VALEURCHAMP v1=(*champ)[num1];
- VALEURCHAMP v2=(*champ)[num2];
- VALEURCHAMP v01=(*champ)[num01];
- VALEURCHAMP v12=(*champ)[num12];
- VALEURCHAMP v20=(*champ)[num20];
-
- double x=n[0];
- double y=n[1];
-
- double lambda0=(y1-y2)*x+(x2-x1)*y+(x1*y2-x2*y1);
- double lambda1=(y2-y0)*x+(x0-x2)*y+(x2*y0-x0*y2);
- double lambda2=(y0-y1)*x+(x1-x0)*y+(x0*y1-x1*y0);
-
- double delta = (x2-x1)*y0+(x0-x2)*y1+(x1-x0)*y2;
-
-
- // VALEURCHAMP retour(v0.SIZE()); //
-
- return 2*(lambda0*lambda0*v0+
- lambda1*lambda1*v1+
- lambda2*lambda2*v2+
- 2*(lambda0*lambda1*v01+
- lambda1*lambda2*v12+
- lambda2*lambda0*v20))/(delta*delta)+
- (lambda0*v0+lambda1*v1+lambda2*v2)/(-delta);
-
- // return retour; //
- }
-};
-_TEMPLATE_ class Calcul_Interpolation_Quad4 : public Calcul_Interpolation<_PARAM_>
-{
-public : Calcul_Interpolation_Quad4(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):Calcul_Interpolation<_PARAM_>(nn,nm,c) {}
-public : VALEURCHAMP operator() (const NOEUD & n, int num_maille)
- {
- int num0=(*mailles)[num_maille][0];
- int num1=(*mailles)[num_maille][1];
- int num2=(*mailles)[num_maille][2];
- int num3=(*mailles)[num_maille][3];
-
- double x0=(*noeuds)[num0][0];
- double y0=(*noeuds)[num0][1];
- double x1=(*noeuds)[num1][0];
- double y1=(*noeuds)[num1][1];
- double x2=(*noeuds)[num2][0];
- double y2=(*noeuds)[num2][1];
- double x3=(*noeuds)[num3][0];
- double y3=(*noeuds)[num3][1];
-
- VALEURCHAMP v0=(*champ)[num0];
- VALEURCHAMP v1=(*champ)[num1];
- VALEURCHAMP v2=(*champ)[num2];
- VALEURCHAMP v3=(*champ)[num3];
-
- double x=n[0];
- double y=n[1];
-
-
- double mu0=-((x3*(y1-y2)+x1*(y2-y3)+x2*(y3-y1))*x*y+(x2*y2*(y1-y3)+x3*(-y1+y2)*y3+x1*y1*(y3-y2))*x+(x2*x3*(y2-y3)+x1*(x2*(y1-y2)+x3*(y3-y1)))*y+(x2*x3*y1*(y3-y2)+x1*(x3*y2*(y1-y3)+x2*(y2-y1)*y3)));
- double mu1=(x0*(y2-y3)+x2*(y3-y0)+x3*(y0-y2))*x*y+(x3*y3*(y2-y0)+x0*(-y2+y3)*y0+x2*y2*(y0-y3))*x+(x3*x0*(y3-y0)+x2*(x3*(y2-y3)+x0*(y0-y2)))*y+(x2*x0*y2*(y0-y2)+x2*(x0*y2*(y2-y0)+x3*(y3-y2)*y0));
- double mu2=-((x1*(y3-y0)+x3*(y0-y1)+x0*(y1-y3))*x*y+(x0*y0*(y3-y1)+x1*(-y3+y0)*y1+x3*y3*(y1-y0))*x+(x0*x1*(y0-y1)+x3*(x0*(y3-y0)+x1*(y1-y3)))*y+(x3*x1*y3*(y1-y2)+x3*(x1*y2*(y3-y1)+x0*(y0-y3)*y1)));
- double mu3=(x2*(y0-y1)+x0*(y1-y2)+x1*(y2-y0))*x*y+(x1*y1*(y0-y2)+x2*(-y0+y1)*y2+x0*y0*(y2-y1))*x+(x1*x2*(y1-y2)+x0*(x1*(y0-y1)+x2*(y2-y0)))*y+(x0*x2*y0*(y2-y2)+x0*(x2*y2*(y0-y2)+x1*(y1-y0)*y2));
-
- double delta=(y0-y2)*(y1-y3)*(x0*x2+x1*x3)-(x1*x2+x0*x3)*(y1-y2)*(y0-y3)-(x0*x1+x2*x3)*(y0-y1)*(y2-y3);
-
- /*
- cout<<" ### Pour ( "<<x<<" , "<<y<<" )"<<endl;
- cout<<" ### delta = "<<delta<<endl;
- cout<<" ### Mu0 = "<<mu0<<endl;
- cout<<" ### Mu1 = "<<mu1<<endl;
- cout<<" ### Mu2 = "<<mu2<<endl;
- cout<<" ### Mu3 = "<<mu3<<endl;
- //*/
- VALEURCHAMP retour(v0.SIZE()); //
-
- retour=(mu0*v0+mu1*v1+mu2*v2+mu3*v3)/delta;
-
- return retour; //
- }
-};
-_TEMPLATE_ class Calcul_Interpolation_Quad8 : public Calcul_Interpolation<_PARAM_>
-{
-public : Calcul_Interpolation_Quad8(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):Calcul_Interpolation<_PARAM_>(nn,nm,c) {}
-public : VALEURCHAMP operator() (const NOEUD & n, int num_maille)
- {
- cerr<<"Interpolation Q2 pas encore implémentée"<<endl;
- exit(-1);
- }
-};
-_TEMPLATE_ class Calcul_Interpolation_Tetra4 : public Calcul_Interpolation<_PARAM_>
-{
-public : Calcul_Interpolation_Tetra4(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):Calcul_Interpolation<_PARAM_>(nn,nm,c) {}
-public : VALEURCHAMP operator() (const NOEUD & n, int num_maille)
- {
- int num0=(*mailles)[num_maille][0];
- int num1=(*mailles)[num_maille][1];
- int num2=(*mailles)[num_maille][2];
- int num3=(*mailles)[num_maille][3];
-
- double x0=(*noeuds)[num0][0];
- double y0=(*noeuds)[num0][1];
- double z0=(*noeuds)[num0][2];
- double x1=(*noeuds)[num1][0];
- double y1=(*noeuds)[num1][1];
- double z1=(*noeuds)[num1][2];
- double x2=(*noeuds)[num2][0];
- double y2=(*noeuds)[num2][1];
- double z2=(*noeuds)[num2][2];
- double x3=(*noeuds)[num3][0];
- double y3=(*noeuds)[num3][1];
- double z3=(*noeuds)[num3][2];
-
- VALEURCHAMP v0=(*champ)[num0];
- VALEURCHAMP v1=(*champ)[num1];
- VALEURCHAMP v2=(*champ)[num2];
- VALEURCHAMP v3=(*champ)[num3];
-
- double x=n[0];
- double y=n[1];
- double z=n[2];
-
- double lambda0=face(x1,y1,z1,x2,y2,z2,x3,y3,z3,x,y,z)/face(x1,y1,z1,x2,y2,z2,x3,y3,z3,x0,y0,z0);
- double lambda1=face(x0,y0,z0,x2,y2,z2,x3,y3,z3,x,y,z)/face(x0,y0,z0,x2,y2,z2,x3,y3,z3,x1,y1,z1);
- double lambda2=face(x1,y1,z1,x0,y0,z0,x3,y3,z3,x,y,z)/face(x1,y1,z1,x0,y0,z0,x3,y3,z3,x2,y2,z2);
- double lambda3=face(x1,y1,z1,x2,y2,z2,x0,y0,z0,x,y,z)/face(x1,y1,z1,x2,y2,z2,x0,y0,z0,x3,y3,z3);
-
- VALEURCHAMP retour(v0.SIZE()); //
-
- retour=(lambda0*v0+lambda1*v1+lambda2*v2+lambda3*v3);
-
- return retour; //
- }
-};
-_TEMPLATE_ class Calcul_Interpolation_Tetra10 : public Calcul_Interpolation<_PARAM_>
-{
-public : Calcul_Interpolation_Tetra10(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):Calcul_Interpolation<_PARAM_>(nn,nm,c) {}
-public : VALEURCHAMP operator() (const NOEUD & n, int num_maille)
- {
- // ON SUPPOSE IMPLICITEMENT QUE LES NOEUDS SUPPLEMENTAIRES SONT BIEN DES NOEUDS MILIEUX
- int num0 =(*mailles)[num_maille][0];
- int num1 =(*mailles)[num_maille][1];
- int num2 =(*mailles)[num_maille][2];
- int num3 =(*mailles)[num_maille][3];
- int num01=(*mailles)[num_maille][4];
- int num02=(*mailles)[num_maille][6];
- int num03=(*mailles)[num_maille][7];
- int num12=(*mailles)[num_maille][5];
- int num13=(*mailles)[num_maille][8];
- int num23=(*mailles)[num_maille][9];
-
- double x0=(*noeuds)[num0][0];double y0=(*noeuds)[num0][1];double z0=(*noeuds)[num0][2];
- double x1=(*noeuds)[num1][0];double y1=(*noeuds)[num1][1];double z1=(*noeuds)[num1][2];
- double x2=(*noeuds)[num2][0];double y2=(*noeuds)[num2][1];double z2=(*noeuds)[num2][2];
- double x3=(*noeuds)[num3][0];double y3=(*noeuds)[num3][1];double z3=(*noeuds)[num3][2];
-
- VALEURCHAMP v0=(*champ)[num0];
- VALEURCHAMP v1=(*champ)[num1];
- VALEURCHAMP v2=(*champ)[num2];
- VALEURCHAMP v3=(*champ)[num3];
- VALEURCHAMP v01=(*champ)[num01];
- VALEURCHAMP v02=(*champ)[num02];
- VALEURCHAMP v03=(*champ)[num03];
- VALEURCHAMP v12=(*champ)[num12];
- VALEURCHAMP v13=(*champ)[num13];
- VALEURCHAMP v23=(*champ)[num23];
-
- double x=n[0];
- double y=n[1];
- double z=n[2];
-
- double lambda0=face(x1,y1,z1,x2,y2,z2,x3,y3,z3,x,y,z)/face(x1,y1,z1,x2,y2,z2,x3,y3,z3,x0,y0,z0);
- double lambda1=face(x0,y0,z0,x2,y2,z2,x3,y3,z3,x,y,z)/face(x0,y0,z0,x2,y2,z2,x3,y3,z3,x1,y1,z1);
- double lambda2=face(x1,y1,z1,x0,y0,z0,x3,y3,z3,x,y,z)/face(x1,y1,z1,x0,y0,z0,x3,y3,z3,x2,y2,z2);
- double lambda3=face(x1,y1,z1,x2,y2,z2,x0,y0,z0,x,y,z)/face(x1,y1,z1,x2,y2,z2,x0,y0,z0,x3,y3,z3);
-
- /*
- cout<<" ### Pour ( "<<x<<" , "<<y<<" , "<<z<<" )"<<endl;
- cout<<" ### Lambda0 = "<<lambda0<<endl;
- cout<<" ### Lambda1 = "<<lambda1<<endl;
- cout<<" ### Lambda2 = "<<lambda2<<endl;
- cout<<" ### Lambda3 = "<<lambda3<<endl;
- cout<<" ### Controle = "<<(lambda0+lambda1+lambda2+lambda3)<<endl;
- //*/
-
- VALEURCHAMP retour(v0.SIZE()); //
-
- retour=2*(lambda0*lambda0*v0+
- lambda1*lambda1*v1+
- lambda2*lambda2*v2+
- lambda3*lambda3*v3+
- 2*(lambda0*lambda1*v01+
- lambda0*lambda2*v02+
- lambda0*lambda3*v03+
- lambda1*lambda2*v12+
- lambda1*lambda3*v13+
- lambda2*lambda3*v23))+
- (-1.0)*(lambda0*v0+lambda1*v1+lambda2*v2+lambda3*v3);
-
- return retour; //
- }
-};
-_TEMPLATE_ class Calcul_Interpolation_Hexa8 : public Calcul_Interpolation<_PARAM_>
-{
-public : Calcul_Interpolation_Hexa8(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):Calcul_Interpolation<_PARAM_>(nn,nm,c) {}
-public : VALEURCHAMP operator() (const NOEUD & n, int num_maille)
- {
-
- // Tres probablement numériquement mauvais, à revoir
-
- int num0=(*mailles)[num_maille][0];
- int num1=(*mailles)[num_maille][1];
- int num2=(*mailles)[num_maille][2];
- int num3=(*mailles)[num_maille][3];
- int num4=(*mailles)[num_maille][4];
- int num5=(*mailles)[num_maille][5];
- int num6=(*mailles)[num_maille][6];
- int num7=(*mailles)[num_maille][7];
-
-
- double x0=(*noeuds)[num0][0];double y0=(*noeuds)[num0][1];double z0=(*noeuds)[num0][2];
- double x1=(*noeuds)[num1][0];double y1=(*noeuds)[num1][1];double z1=(*noeuds)[num1][2];
- double x2=(*noeuds)[num2][0];double y2=(*noeuds)[num2][1];double z2=(*noeuds)[num2][2];
- double x3=(*noeuds)[num3][0];double y3=(*noeuds)[num3][1];double z3=(*noeuds)[num3][2];
- double x4=(*noeuds)[num4][0];double y4=(*noeuds)[num4][1];double z4=(*noeuds)[num4][2];
- double x5=(*noeuds)[num5][0];double y5=(*noeuds)[num5][1];double z5=(*noeuds)[num5][2];
- double x6=(*noeuds)[num6][0];double y6=(*noeuds)[num6][1];double z6=(*noeuds)[num6][2];
- double x7=(*noeuds)[num7][0];double y7=(*noeuds)[num7][1];double z7=(*noeuds)[num7][2];
-
-
- VALEURCHAMP v0=(*champ)[num0];
- VALEURCHAMP v1=(*champ)[num1];
- VALEURCHAMP v2=(*champ)[num2];
- VALEURCHAMP v3=(*champ)[num3];
- VALEURCHAMP v4=(*champ)[num4];
- VALEURCHAMP v5=(*champ)[num5];
- VALEURCHAMP v6=(*champ)[num6];
- VALEURCHAMP v7=(*champ)[num7];
-
- double x=n[0];
- double y=n[1];
- double z=n[2];
-
- // double mu0=face1256(x,y,z)*face2367(x,y,z)*face4567(x,y,z)/(face1256(x0,y0,z0)*face2367(x0,y0,z0)*face4567(x0,y0,z0));
- // double mu1=face0347(x,y,z)*face2367(x,y,z)*face4567(x,y,z)/(face0347(x1,y1,z1)*face2367(x1,y1,z1)*face4567(x1,y1,z1));
- // double mu2=face0347(x,y,z)*face0145(x,y,z)*face4567(x,y,z)/(face0347(x2,y2,z2)*face0145(x2,y2,z2)*face4567(x2,y2,z2));
- // double mu3=face1256(x,y,z)*face0145(x,y,z)*face4567(x,y,z)/(face1256(x3,y3,z3)*face0145(x3,y3,z3)*face4567(x3,y3,z3));
- // double mu4=face1256(x,y,z)*face2367(x,y,z)*face0123(x,y,z)/(face1256(x4,y4,z4)*face2367(x4,y4,z4)*face0123(x4,y4,z4));
- // double mu5=face0347(x,y,z)*face2367(x,y,z)*face0123(x,y,z)/(face0347(x5,y5,z5)*face2367(x5,y5,z5)*face0123(x5,y5,z5));
- // double mu6=face0347(x,y,z)*face0145(x,y,z)*face0123(x,y,z)/(face0347(x6,y6,z6)*face0145(x6,y6,z6)*face0123(x6,y6,z6));
- // double mu7=face1256(x,y,z)*face0145(x,y,z)*face0123(x,y,z)/(face1256(x7,y7,z7)*face0145(x7,y7,z7)*face0123(x7,y7,z7));
-
- double mu0=projection(x1,y1,z1,x2,y2,z2,x6,y6,z6,x0,y0,z0,x,y,z)*projection(x2,y2,z2,x3,y3,z3,x7,y7,z7,x0,y0,z0,x,y,z)*projection(x4,y4,z4,x5,y5,z5,x6,y6,z6,x0,y0,z0,x,y,z);
- double mu1=projection(x0,y0,z0,x3,y3,z3,x7,y7,z7,x1,y1,z1,x,y,z)*projection(x2,y2,z2,x3,y3,z3,x7,y7,z7,x1,y1,z1,x,y,z)*projection(x4,y4,z4,x5,y5,z5,x6,y6,z6,x1,y1,z1,x,y,z);
- double mu2=projection(x0,y0,z0,x3,y3,z3,x7,y7,z7,x2,y2,z2,x,y,z)*projection(x0,y0,z0,x1,y1,z1,x5,y5,z5,x2,y2,z2,x,y,z)*projection(x4,y4,z4,x5,y5,z5,x6,y6,z6,x2,y2,z2,x,y,z);
- double mu3=projection(x1,y1,z1,x2,y2,z2,x6,y6,z6,x3,y3,z3,x,y,z)*projection(x0,y0,z0,x1,y1,z1,x5,y5,z5,x3,y3,z3,x,y,z)*projection(x4,y4,z4,x6,y6,z6,x7,y7,z7,x3,y3,z3,x,y,z);
- double mu4=projection(x2,y2,z2,x6,y6,z6,x5,y5,z5,x4,y4,z4,x,y,z)*projection(x2,y2,z2,x3,y3,z3,x7,y7,z7,x4,y4,z4,x,y,z)*projection(x0,y0,z0,x1,y1,z1,x2,y2,z2,x4,y4,z4,x,y,z);
- double mu5=projection(x3,y3,z3,x7,y7,z7,x4,y4,z4,x5,y5,z5,x,y,z)*projection(x2,y2,z2,x3,y3,z3,x6,y6,z6,x5,y5,z5,x,y,z)*projection(x0,y0,z0,x1,y1,z1,x2,y2,z2,x5,y5,z5,x,y,z);
- double mu6=projection(x3,y3,z3,x7,y7,z7,x4,y4,z4,x6,y6,z6,x,y,z)*projection(x1,y1,z1,x5,y5,z5,x4,y4,z4,x6,y6,z6,x,y,z)*projection(x0,y0,z0,x1,y1,z1,x2,y2,z2,x6,y6,z6,x,y,z);
- double mu7=projection(x2,y2,z2,x6,y6,z6,x5,y5,z5,x7,y7,z7,x,y,z)*projection(x1,y1,z1,x5,y5,z5,x4,y4,z4,x7,y7,z7,x,y,z)*projection(x0,y0,z0,x1,y1,z1,x3,y3,z3,x7,y7,z7,x,y,z);
-
- VALEURCHAMP retour(v0.SIZE()); //
-
- retour=(mu0*v0+mu1*v1+mu2*v2+mu3*v3+mu4*v4+mu5*v5+mu6*v6+mu7*v7);
-
- return retour; //
- }
-};
-_TEMPLATE_ class Calcul_Interpolation_Hexa20 : public Calcul_Interpolation<_PARAM_>
-{
-public : Calcul_Interpolation_Hexa20(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):Calcul_Interpolation<_PARAM_>(nn,nm,c) {}
-public : VALEURCHAMP operator() (const NOEUD & n, int num_maille)
- {
- cerr<<"Interpolation H2 pasencore implémentée"<<endl;
- exit(-1);
- }
-};
-_TEMPLATE_ class Calcul_Interpolation_Penta6 : public Calcul_Interpolation<_PARAM_>
-{
-public : Calcul_Interpolation_Penta6(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):Calcul_Interpolation<_PARAM_>(nn,nm,c) {}
-public : VALEURCHAMP operator() (const NOEUD & n, int num_maille)
- {
- int num0=(*mailles)[num_maille][0];
- int num1=(*mailles)[num_maille][1];
- int num2=(*mailles)[num_maille][2];
- int num3=(*mailles)[num_maille][3];
- int num4=(*mailles)[num_maille][4];
- int num5=(*mailles)[num_maille][5];
-
- double x0=(*noeuds)[num0][0];double y0=(*noeuds)[num0][1];double z0=(*noeuds)[num0][2];
- double x1=(*noeuds)[num1][0];double y1=(*noeuds)[num1][1];double z1=(*noeuds)[num1][2];
- double x2=(*noeuds)[num2][0];double y2=(*noeuds)[num2][1];double z2=(*noeuds)[num2][2];
- double x3=(*noeuds)[num3][0];double y3=(*noeuds)[num3][1];double z3=(*noeuds)[num3][2];
- double x4=(*noeuds)[num4][0];double y4=(*noeuds)[num4][1];double z4=(*noeuds)[num4][2];
- double x5=(*noeuds)[num5][0];double y5=(*noeuds)[num5][1];double z5=(*noeuds)[num5][2];
-
- VALEURCHAMP v0=(*champ)[num0];
- VALEURCHAMP v1=(*champ)[num1];
- VALEURCHAMP v2=(*champ)[num2];
- VALEURCHAMP v3=(*champ)[num3];
- VALEURCHAMP v4=(*champ)[num4];
- VALEURCHAMP v5=(*champ)[num5];
-
- double x=n[0];
- double y=n[1];
- double z=n[2];
-
- double mu0=face(x1,y1,z1,x2,y2,z2,x5,y5,z5,x,y,z)*face(x3,y3,z3,x4,y4,z4,x5,y5,z5,x,y,z)/(face(x1,y1,z1,x2,y2,z2,x5,y5,z5,x0,y0,z0)*face(x3,y3,z3,x4,y4,z4,x5,y5,z5,x0,y0,z0));
- double mu1=face(x0,y0,z0,x2,y2,z2,x5,y5,z5,x,y,z)*face(x3,y3,z3,x4,y4,z4,x5,y5,z5,x,y,z)/(face(x0,y0,z0,x2,y2,z2,x5,y5,z5,x1,y1,z1)*face(x3,y3,z3,x4,y4,z4,x5,y5,z5,x1,y1,z1));
- double mu2=face(x0,y0,z0,x1,y1,z1,x4,y4,z4,x,y,z)*face(x3,y3,z3,x4,y4,z4,x5,y5,z5,x,y,z)/(face(x0,y0,z0,x1,y1,z1,x4,y4,z4,x2,y2,z2)*face(x3,y3,z3,x4,y4,z4,x5,y5,z5,x2,y2,z2));
- double mu3=face(x1,y1,z1,x2,y2,z2,x5,y5,z5,x,y,z)*face(x0,y0,z0,x1,y1,z1,x2,y2,z2,x,y,z)/(face(x1,y1,z1,x2,y2,z2,x5,y5,z5,x3,y3,z3)*face(x0,y0,z0,x1,y1,z1,x2,y2,z2,x3,y3,z3));
- double mu4=face(x0,y0,z0,x2,y2,z2,x5,y5,z5,x,y,z)*face(x0,y0,z0,x1,y1,z1,x2,y2,z2,x,y,z)/(face(x0,y0,z0,x2,y2,z2,x5,y5,z5,x4,y4,z4)*face(x0,y0,z0,x1,y1,z1,x2,y2,z2,x4,y4,z4));
- double mu5=face(x0,y0,z0,x1,y1,z1,x4,y4,z4,x,y,z)*face(x0,y0,z0,x1,y1,z1,x2,y2,z2,x,y,z)/(face(x0,y0,z0,x1,y1,z1,x4,y4,z4,x5,y5,z5)*face(x0,y0,z0,x1,y1,z1,x2,y2,z2,x5,y5,z5));
-
- VALEURCHAMP retour(v0.SIZE()); //
-
- retour=(mu0*v0+mu1*v1+mu2*v2+mu3*v3+mu4*v4+mu5*v5);
-
- return retour; //
- }
-};
-_TEMPLATE_ class Calcul_Interpolation_Penta15 : public Calcul_Interpolation<_PARAM_>
-{
-public : Calcul_Interpolation_Penta15(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):Calcul_Interpolation<_PARAM_>(nn,nm,c) {}
-public : VALEURCHAMP operator() (const NOEUD & n, int num_maille)
- {
- cerr<<"Interpolation Pe2 pasencore implémentée"<<endl;
- exit(-1);
- }
-};
-_TEMPLATE_ class Calcul_Interpolation_Pyra5 : public Calcul_Interpolation<_PARAM_>
-{
-public : Calcul_Interpolation_Pyra5(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):Calcul_Interpolation<_PARAM_>(nn,nm,c) {}
-public : VALEURCHAMP operator() (const NOEUD & n, int num_maille)
- {
- // NON TESTE
- int num0=(*mailles)[num_maille][0];
- int num1=(*mailles)[num_maille][1];
- int num2=(*mailles)[num_maille][2];
- int num3=(*mailles)[num_maille][3];
- int num4=(*mailles)[num_maille][4];
-
- double x0=(*noeuds)[num0][0];double y0=(*noeuds)[num0][1];double z0=(*noeuds)[num0][2];
- double x1=(*noeuds)[num1][0];double y1=(*noeuds)[num1][1];double z1=(*noeuds)[num1][2];
- double x2=(*noeuds)[num2][0];double y2=(*noeuds)[num2][1];double z2=(*noeuds)[num2][2];
- double x3=(*noeuds)[num3][0];double y3=(*noeuds)[num3][1];double z3=(*noeuds)[num3][2];
- double x4=(*noeuds)[num4][0];double y4=(*noeuds)[num4][1];double z4=(*noeuds)[num4][2];
-
- VALEURCHAMP v0=(*champ)[num0];
- VALEURCHAMP v1=(*champ)[num1];
- VALEURCHAMP v2=(*champ)[num2];
- VALEURCHAMP v3=(*champ)[num3];
- VALEURCHAMP v4=(*champ)[num4];
-
- double x=n[0];
- double y=n[1];
- double z=n[2];
-
- double mu0=face(x1,y1,z1,x2,y2,z2,x4,y4,z4,x,y,z)*face(x2,y2,z2,x3,y3,z3,x4,y4,z4,x,y,z)/(face(x1,y1,z1,x2,y2,z2,x4,y4,z4,x0,y0,z0)*face(x2,y2,z2,x3,y3,z3,x4,y4,z4,x0,y0,z0));
- double mu1=face(x0,y0,z0,x3,y3,z3,x4,y4,z4,x,y,z)*face(x2,y2,z2,x3,y3,z3,x4,y4,z4,x,y,z)/(face(x0,y0,z0,x3,y3,z3,x4,y4,z4,x1,y1,z1)*face(x2,y2,z2,x3,y3,z3,x4,y4,z4,x1,y1,z1));
- double mu2=face(x0,y0,z0,x1,y1,z1,x4,y4,z4,x,y,z)*face(x0,y0,z0,x3,y3,z3,x4,y4,z4,x,y,z)/(face(x0,y0,z0,x1,y1,z1,x4,y4,z4,x2,y2,z2)*face(x0,y0,z0,x3,y3,z3,x4,y4,z4,x2,y2,z2));
- double mu3=face(x0,y0,z0,x1,y1,z1,x4,y4,z4,x,y,z)*face(x1,y1,z1,x2,y2,z2,x4,y4,z4,x,y,z)/(face(x0,y0,z0,x1,y1,z1,x4,y4,z4,x3,y3,z3)*face(x1,y1,z1,x2,y2,z2,x4,y4,z4,x3,y3,z3));
- double mu4=face(x0,y0,z0,x1,y1,z1,x2,y2,z2,x,y,z)/face(x0,y0,z0,x1,y1,z1,x2,y2,z2,x4,y4,z4);
-
- VALEURCHAMP retour(v0.SIZE()); //
-
- retour=(mu0*v0+mu1*v1+mu2*v2+mu3*v3+mu4*v4);
-
- return retour; //
- }
-};
-_TEMPLATE_ class Calcul_Interpolation_Pyra13 : public Calcul_Interpolation<_PARAM_>
-{
-public : Calcul_Interpolation_Pyra13(NUAGENOEUD * nn,NUAGEMAILLE * nm,CHAMP * c):Calcul_Interpolation<_PARAM_>(nn,nm,c) {}
-public : VALEURCHAMP operator() (const NOEUD & n, int num_maille)
- {
- cerr<<"Interpolation Py2 pasencore implémentée"<<endl;
- exit(-1);
- }
-};
-
-#undef _TEMPLATE_
-#undef _PARAM_
-
-#endif
+++ /dev/null
-#ifndef MEDMEM_MAPPING_HXX
-#define MEDMEM_MAPPING_HXX
-
-#include "MEDMEM_MappingTools.hxx"
-#include "MEDMEM_dTree.hxx"
-
-#define NBR_MAX_MAILLES_EXAMINEES 100
-
-#ifndef NBR_FACES_MAX
-#define NBR_FACES_MAX 6
-#endif
-
-#define _TEMPLATE_ template <class MAILLAGE, class NUAGEMAILLE, class NUAGENOEUD, class NOEUD, int DIMENSION>
-#define _MAPPING_ Mapping<MAILLAGE,NUAGEMAILLE,NUAGENOEUD,NOEUD,DIMENSION>
-
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// DECLARATIONS ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-/*********************************************************/
-/* */
-/* Classe Mapping */
-/* */
-/*********************************************************/
-
-// ATTENTION LE NUAGE DE NOEUD EST SUPPOSE NON REDONDANT ET AUCUNE VERIFICATION N'EST FAITE !
-
-template <class MAILLAGE, class NUAGEMAILLE, class NUAGENOEUD, class NOEUD, int DIMENSION> class Mapping
-{
-protected :
- MAILLAGE * maillage_back;
- NUAGEMAILLE * mailles_back;
- NUAGENOEUD * noeuds_back;
- NUAGENOEUD * noeuds_front;
- Coordonnees_Barycentriques<NUAGEMAILLE,NUAGENOEUD,NOEUD,DIMENSION> * CB;
- dTree<NOEUD,NUAGENOEUD,DIMENSION> * my_dTree;
- vector<int> resultat_mapping;
- vector<int> point_le_plus_proche;
-
-public :
-
- Mapping():maillage_back(NULL),mailles_back(NULL),noeuds_back(NULL),noeuds_front(NULL),CB(NULL),my_dTree(NULL) {}
- Mapping(MAILLAGE * mb,NUAGENOEUD * nb,NUAGENOEUD * nf); // le dTree est crée à l'initialisation, par contre, le mapping lui meme doit etre invoqué
- ~Mapping() {if (CB) delete CB;if (my_dTree) delete my_dTree;}
- dTree<NOEUD,NUAGENOEUD,DIMENSION> * Donne_dTree() {return my_dTree;}
- int Donne_Directions(int num_maille,const NOEUD &n,int etat_face[NBR_FACES_MAX]);
- // Méthode interne de localisation
- int Trouve_Maille_Contenant_Point_Mth_Co(const NOEUD &n,int num_maille,int num_maille_interdit,int max_loop,int &nbr_mailles_examinees,int flag_convexe);
- void Cree_Mapping(int flag_convexe=0); // SUPPOSE NON CONVEXE PAR DEFAUT
- void Cree_Mapping(NUAGENOEUD * nf, int flag_convexe=0); // SUPPOSE NON CONVEXE PAR DEFAUT
- inline int operator[](int i) const {return resultat_mapping[i];} // Renvoie la valeur mappé, si le mapping a été fait, sinon, n'importe quoi
- inline vector<int> & Get_Mapping() {return resultat_mapping;} // Renvoie le vector contenant le mapping
- inline int Get_Noeud_Le_Plus_Proche(int i) const {return point_le_plus_proche[i];} // Invoque la méthode de d-Tree qui donne le noeud le plus proche
- inline int Exist_dTree() const {return (my_dTree);} // Teste si le dTree existe
- void affiche()
- {
- for (int i=0;i<resultat_mapping.size();i++) cout<<"Noeud "<<i<<" de noeud plus proche "<<point_le_plus_proche[i]<<" mappé dans maille "<<resultat_mapping[i]<<endl;
- }
-};
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// CODE ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-_TEMPLATE_ void _MAPPING_::Cree_Mapping(NUAGENOEUD * nf, int flag_convexe)
- {
- noeuds_front=nf;
- Cree_Mapping(flag_convexe);
- }
-
-_TEMPLATE_ void _MAPPING_::Cree_Mapping(int flag_convexe)
- {
-
- if (resultat_mapping.size()==0)
- {
- if (!noeuds_front)
- {
- cerr<<"Mapping : Pas de noeuds à mapper !"<<endl;
- exit(-1);
- }
-
- int i,j,k;
- int nbr_noeuds=noeuds_front->SIZE();
- int num_maille_depart;
- int nma=0;
- resultat_mapping = vector<int>(nbr_noeuds,UNDEFINED);
- point_le_plus_proche = vector<int>(nbr_noeuds,UNDEFINED);
-
- // noeuds_back->affiche();
-
- for (i=0;i<nbr_noeuds;i++)
- {
- point_le_plus_proche[i]=my_dTree->trouve_plus_proche_point((*noeuds_front)[i]);
- num_maille_depart=maillage_back->DONNE_PREMIERE_MAILLE_CONTENANT(point_le_plus_proche[i]);
- resultat_mapping[i]=Trouve_Maille_Contenant_Point_Mth_Co((*noeuds_front)[i],num_maille_depart,num_maille_depart,NBR_MAX_MAILLES_EXAMINEES,nma,flag_convexe);
- }
- }
-
- else
- {
- cout<<"Le mapping semble déja existé, interrogation sur l'existant"<<endl;
- }
-
- }
-_TEMPLATE_ _MAPPING_::Mapping(MAILLAGE * mb,NUAGENOEUD * nb,NUAGENOEUD * nf):maillage_back(mb),noeuds_back(nb),noeuds_front(nf),my_dTree(NULL)
- {
-
- if (!maillage_back)
- {
- cerr<<"Mapping : constructeur appelé avec Maillage Vide"<<endl;
- exit(-1);
- }
-
- if (!noeuds_back)
- {
- cerr<<"Mapping : constructeur appelé avec Nuage Noeuds Vide"<<endl;
- exit(-1);
- }
-
- mailles_back=maillage_back->DONNE_POINTEUR_NUAGEMAILLE();
-
- CB=new Coordonnees_Barycentriques<NUAGEMAILLE,NUAGENOEUD,NOEUD,DIMENSION>(mailles_back,noeuds_back);
-
- // TEST REDONDANCE
- /*
- int nnb=noeuds_back->SIZE();
- if (nnb<20000)
- {
- cout<<"MAPPING : VERIFICATION REDONDANCES DANS NUAGE NOEUD BACK"<<endl;
- noeuds_back->affiche();
- int i,j;
- vector<int> redondance(nnb,0);
- for (i=0;i<nnb;i++)
- {
- for (j=i+1;j<nnb;j++) if ((*noeuds_back)[i]==(*noeuds_back)[j])
- {
- cerr<<"Le Noeud "<<j<<" est identique au Noeud "<<i<<endl;
- exit(-1);
- }
- }
- cout<<"FIN TEST VERIFICATION REDONDANCES"<<endl;
- }
- // FIN TEST */
-
- my_dTree=new dTree<NOEUD,NUAGENOEUD,DIMENSION>(noeuds_back);
-
- }
-// Renvoie :
-// 1 si le point est intérieur
-// -1 si le point est extérieur à la maille via uniquement des faces qui ne sont pas au bord
-// -2 si le point est extérieur à la maille par au moins une face de bord
-// Et modifie etat_face de telle sorte que :
-// etat_face[i] = -1 s'il n'existe pas de voisin via la face i
-// etat_face[i] = 0 si le point est intérieur via la face i et que le voisin i existe
-// etat_face[i] = 1 si le point est extérieur via la face i et que le voisin i existe
-_TEMPLATE_ int _MAPPING_::Donne_Directions(int num_maille,const NOEUD &n,int etat_face[NBR_FACES_MAX])
- {
- vector<double> ef=CB->Donne_Pseudo_Coord_Baryc(num_maille,n);
- int etat_int=VRAI;
- int etat_ext_bord=FAUX;
- int tf,tv,tb;
- int nbr_faces=(*mailles_back)[num_maille].DONNE_NBR_FACES();
- for (int i=0;i<nbr_faces;i++)
- {
- tf=(ef[i]<0);
- tv=(maillage_back->DONNE_VOISIN_DE_MAILLE(num_maille,i)==UNDEFINED);
- tb=(maillage_back->EST_AU_BORD_FACE_DE_MAILLE(num_maille,i));
- if (tf)
- {
- etat_int=FAUX;
- if (tb) etat_ext_bord=VRAI;
- }
- if (tv) etat_face[i]=-1;
- else
- {
- if (tf) etat_face[i]=1;
- else etat_face[i]=0;
- }
- }
- if (etat_int) return 1;
- if (etat_ext_bord) return -2;
- return -1;
- }
-_TEMPLATE_ int _MAPPING_::Trouve_Maille_Contenant_Point_Mth_Co(const NOEUD &n,int num_maille,int num_maille_interdit,int max_loop,int &nbr_mailles_examinees,int flag_convexe)
- {
-
- int etat_face[NBR_FACES_MAX];
- int i,tmp,nbr_rnd;
- int indirection[NBR_FACES_MAX];
- int ind_reel;
- int num_reel;
- int new_num=UNDEFINED;
-
- int test=Donne_Directions(num_maille,n,etat_face);
-
- int nbr_faces=maillage_back->DONNE_NBR_FACES_MAILLE(num_maille);
-
- for (i=0;i<nbr_faces;i++) indirection[i]=i;
-
- nbr_mailles_examinees=0;
-
- while (nbr_mailles_examinees<max_loop)
- {
- if (test==1)
- {
- return num_maille;
- }
- if ((test==-2)&&(flag_convexe))
- {
- return 2*UNDEFINED;
- }
- nbr_mailles_examinees++;
- for (i=0;i<nbr_faces;i++)
- {
- tmp=indirection[i];
- nbr_rnd=rand()%nbr_faces;
- indirection[i]=indirection[nbr_rnd];
- indirection[nbr_rnd]=tmp;
- }
- for (i=0;(i<nbr_faces)&&(new_num==UNDEFINED);i++)
- {
- ind_reel=indirection[i];
- num_reel=maillage_back->DONNE_VOISIN_DE_MAILLE(num_maille,ind_reel);
- if ((etat_face[ind_reel]==1)&&(num_reel!=num_maille_interdit))
- {
- new_num=num_reel;
- }
- }
- for (i=0;(i<nbr_faces)&&(new_num==UNDEFINED);i++)
- {
- ind_reel=indirection[i];
- num_reel=maillage_back->DONNE_VOISIN_DE_MAILLE(num_maille,ind_reel);
- if ((etat_face[ind_reel]==0)&&(num_reel!=num_maille_interdit))
- {
- new_num=num_reel;
- }
- }
- if (new_num==UNDEFINED)
- {
- new_num=num_maille_interdit;
- }
- num_maille_interdit=num_maille;
- num_maille=new_num;
- new_num=UNDEFINED;
- test=Donne_Directions(num_maille,n,etat_face);
- }
- return UNDEFINED;
- }
-
-#undef _TEMPLATE_
-#undef _MAPPING_
-
-#endif
+++ /dev/null
-#ifndef COORDONNEES_BARYCENTRIQUES_HPP
-#define COORDONNEES_BARYCENTRIQUES_HPP
-
-#define _TEMPLATE_SPE_ template <class NUAGEMAILLE, class NUAGENOEUD, class NOEUD>
-#define _COORDBARYC_ Coordonnees_Barycentriques<NUAGEMAILLE,NUAGENOEUD,NOEUD,DIMENSION>
-#define _COORDBARY_2D_ Coordonnees_Barycentriques<NUAGEMAILLE,NUAGENOEUD,NOEUD,2>
-#define _COORDBARY_3D_ Coordonnees_Barycentriques<NUAGEMAILLE,NUAGENOEUD,NOEUD,3>
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// DECLARATIONS ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-/*********************************************************/
-/* */
-/* Classe Coordonnees_Barycentriques */
-/* */
-/*********************************************************/
-
-// C'est la définition de la classe générique template qui n'est utilisée qu'à travers ses spécialisations
-// vu que le nombre de spécialisations a faire est petit (nombre de dimensions utilisée, 3 pour MED)
-// et vu que l'acces a ces classes doit etre rapide, car ce sont des classes de calcul
-// la technique de spécialisation, plus lourde, mais plus rapide, a été préférée aux techniques d'héritage
-
-template <class NUAGEMAILLE, class NUAGENOEUD, class NOEUD, int DIMENSION> class Coordonnees_Barycentriques
-{
-// TEMPLATE GENERIQUE VIDE OBLIGE DE PASSER PAR UNE SPECIALISATION
-};
-
-/*********************************************************/
-/* */
-/* Spécialisation 2D */
-/* */
-/*********************************************************/
-
-_TEMPLATE_SPE_ class _COORDBARY_2D_
-{
-protected :
- NUAGEMAILLE * mailles;
- NUAGENOEUD * sommets;
-
- vector<int> etat_coord_baryc;
- vector< vector< vector<double> > > coord_baryc;
-
-public :
-
- Coordonnees_Barycentriques():mailles(NULL),sommets(NULL) {}
- Coordonnees_Barycentriques(NUAGEMAILLE * m, NUAGENOEUD *n);
- ~Coordonnees_Barycentriques() {}
- // donne les pseudos coordonnées barycentriques de M dans ma maille de numéro global num_maille dans mailles
- // la pseudo coordonnées barycentrique par rapport a une face est la distance normalisée a cette face,
- // dans le cas d'une face triangulaire, c'est la coordonnées ba
- vector<double> Donne_Pseudo_Coord_Baryc(int num_maille,const NOEUD &M);
- vector<double> Calcule_Base_Coord_Baryc(const vector<int> &simplexe_base);
- vector<double> Calcule_Coord_Baryc(int num_maille, const NOEUD & M);
-};
-
-/*********************************************************/
-/* */
-/* Spécialisation 3D */
-/* */
-/*********************************************************/
-
-
-_TEMPLATE_SPE_ class _COORDBARY_3D_
-{
-protected :
- NUAGEMAILLE * mailles;
- NUAGENOEUD * sommets;
-
- vector<int> etat_coord_baryc;
- vector< vector< vector<double> > > coord_baryc;
-
-public :
-
- Coordonnees_Barycentriques():mailles(NULL),sommets(NULL) {}
- Coordonnees_Barycentriques(NUAGEMAILLE * m, NUAGENOEUD *n);
- ~Coordonnees_Barycentriques() {}
- vector<double> Donne_Pseudo_Coord_Baryc(int num_maille,const NOEUD &M);
- vector<double> Calcule_Base_Coord_Baryc(const vector<int> &simplexe_base);
- vector<double> Calcule_Coord_Baryc(int num_maille, const NOEUD & M);
-};
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// CODE ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-_TEMPLATE_SPE_ _COORDBARY_2D_::Coordonnees_Barycentriques(NUAGEMAILLE * m, NUAGENOEUD *n):mailles(m),sommets(n)
- {
- cout<<"Creation des Coordonnées Barycentriques : "<<flush;
- int nbr_mailles=mailles->SIZE();
- etat_coord_baryc=vector<int>(nbr_mailles,FAUX);
- coord_baryc=vector< vector< vector<double> > >(nbr_mailles);
- cout<<"OK ! "<<endl;
- }
-
-_TEMPLATE_SPE_ vector<double> _COORDBARY_2D_::Donne_Pseudo_Coord_Baryc(int num_maille,const NOEUD &M)
- {
- int i,j,nbr_faces;
- if (etat_coord_baryc[num_maille]==FAUX)
- {
- nbr_faces=(*mailles).DONNE_NBR_FACES();
-
- coord_baryc[num_maille]=vector< vector<double> >(nbr_faces);
-
- for (i=0;i<nbr_faces;i++)
- {
- vector<int> simplexe_base=(*mailles).DONNE_SIMPLEXE_BASE(i);
- coord_baryc[num_maille][i]=Calcule_Base_Coord_Baryc(simplexe_base);
- etat_coord_baryc[num_maille]=VRAI;
- }
- }
- return Calcule_Coord_Baryc(num_maille,M);
- }
-
-_TEMPLATE_SPE_ vector<double> _COORDBARY_2D_::Calcule_Base_Coord_Baryc(const vector<int> &simplexe_base)
- {
- const vector<int> &ref=simplexe_base;
- vector<double> retour(3);
- int i,j;
-
- double x0=(*sommets)[ref[0]][0];
- double y0=(*sommets)[ref[0]][1];
- double x1=(*sommets)[ref[1]][0];
- double y1=(*sommets)[ref[1]][1];
- double x2=(*sommets)[ref[2]][0];
- double y2=(*sommets)[ref[2]][1];
-
- double delta=(x1*y2-x2*y1)+(x2*y0-x0*y2)+(x0*y1-x1*y0);
-
- retour[0]=(y1-y2)/delta;
- retour[1]=(x2-x1)/delta;
- retour[2]=(x1*y2-x2*y1)/delta;
-
- return retour;
- }
-
-_TEMPLATE_SPE_ vector<double> _COORDBARY_2D_::Calcule_Coord_Baryc(int num_maille, const NOEUD & M)
- {
- int i,j;
- vector<double> coord_baryc_M(3,0);
- for (i=0;i<3;i++)
- {
- for (j=0;j<2;j++) coord_baryc_M[i]+=coord_baryc[num_maille][i][j]*M[j];
- coord_baryc_M[i]+=coord_baryc[num_maille][i][2];
- }
- return coord_baryc_M;
- }
-
-_TEMPLATE_SPE_ _COORDBARY_3D_::Coordonnees_Barycentriques(NUAGEMAILLE * m, NUAGENOEUD *n):mailles(m),sommets(n)
- {
- cout<<"Creation des Coordonnées Barycentriques : "<<flush;
- int nbr_mailles=mailles->SIZE();
- etat_coord_baryc=vector<int>(nbr_mailles,FAUX);
- coord_baryc=vector< vector< vector<double> > >(nbr_mailles);
- cout<<"OK ! "<<endl;
- }
-
-_TEMPLATE_SPE_ vector<double> _COORDBARY_3D_::Donne_Pseudo_Coord_Baryc(int num_maille,const NOEUD &M)
- {
- int i,j,nbr_faces;
- if (etat_coord_baryc[num_maille]==FAUX)
- {
- nbr_faces=(*mailles)[num_maille].DONNE_NBR_FACES();
-
- coord_baryc[num_maille]=vector< vector<double> >(nbr_faces);
-
- type_retour simplexe_base;
-
- for (i=0;i<nbr_faces;i++)
- {
- (*mailles)[num_maille].DONNE_SIMPLEXE_BASE(i,simplexe_base);
- coord_baryc[num_maille][i]=Calcule_Base_Coord_Baryc(vector<int>(&simplexe_base.quoi[0],&simplexe_base.quoi[simplexe_base.combien]));
- etat_coord_baryc[num_maille]=VRAI;
- }
- }
- return Calcule_Coord_Baryc(num_maille,M);
- }
-
-
-_TEMPLATE_SPE_ vector<double> _COORDBARY_3D_::Calcule_Base_Coord_Baryc(const vector<int> &simplexe_base)
- {
- const vector<int> &ref=simplexe_base;
- vector<double> retour(4);
- int i,j;
-
- double x0=(*sommets)[ref[0]][0];
- double y0=(*sommets)[ref[0]][1];
- double z0=(*sommets)[ref[0]][2];
- double x1=(*sommets)[ref[1]][0];
- double y1=(*sommets)[ref[1]][1];
- double z1=(*sommets)[ref[1]][2];
- double x2=(*sommets)[ref[2]][0];
- double y2=(*sommets)[ref[2]][1];
- double z2=(*sommets)[ref[2]][2];
- double x3=(*sommets)[ref[3]][0];
- double y3=(*sommets)[ref[3]][1];
- double z3=(*sommets)[ref[3]][2];
-
- double delta1=((y2-y1)*(z3-z1)-(z2-z1)*(y3-y1));
- double delta2=((x3-x1)*(z2-z1)-(x2-x1)*(z3-z1));
- double delta3=((x2-x1)*(y3-y1)-(x3-x1)*(y2-y1));
-
- double delta=delta1*(x0-x1)+delta2*(y0-y1)+delta3*(z0-z1);
-
- retour[0]=delta1/delta;
- retour[1]=delta2/delta;
- retour[2]=delta3/delta;
- retour[3]=-(delta1*x1+delta2*y1+delta3*z1)/delta;
-
- return retour;
- }
-
-_TEMPLATE_SPE_ vector<double> _COORDBARY_3D_::Calcule_Coord_Baryc(int num_maille, const NOEUD & M)
- {
- int i,j;
- int nbr_faces=coord_baryc[num_maille].size();
- vector<double> coord_baryc_M(nbr_faces,0);
- for (i=0;i<nbr_faces;i++)
- {
- for (j=0;j<3;j++) coord_baryc_M[i]+=coord_baryc[num_maille][i][j]*M[j];
- coord_baryc_M[i]+=coord_baryc[num_maille][i][3];
- }
- return coord_baryc_M;
- }
-
-//*/
-
-#undef _TEMPLATE_SPE_
-// template <class NUAGEMAILLE, class NUAGENOEUD, class NOEUD, int DIMENSION>
-#undef _COORDBARYC_
-// Coordonnees_Barycentriques<NUAGEMAILLE,NUAGENOEUD,NOEUD,DIMENSION>
-#undef _COORDBARY_2D_
-// Coordonnees_Barycentriques<NUAGEMAILLE,NUAGENOEUD,NOEUD,2>
-#undef _COORDBARY_3D_
-// Coordonnees_Barycentriques<NUAGEMAILLE,NUAGENOEUD,NOEUD,3>
-
-#endif
+++ /dev/null
-#ifndef WRAPPERS_CELLS_HXX
-#define WRAPPERS_CELLS_HXX
-
-#include "stdio.h"
-#include "stdlib.h"
-
-#include <typeinfo>
-
-#include <vector>
-#include <map>
-
-#ifndef FAUX
-#define FAUX 0
-#endif
-
-#ifndef VRAI
-#define VRAI 1
-#endif
-
-#ifndef UNDEFINED
-#define UNDEFINED -1
-#endif
-
-#include "MEDMEM_define.hxx"
-
-#define MAXNBR 10
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// DECLARATIONS ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-/*********************************************************/
-/* */
-/* Equivalence num modele local => MED */
-/* */
-/*********************************************************/
-
-#define NBR_MODELES_MAILLES_DEFINIS 15
-int Equivalence_Local_MED[NBR_MODELES_MAILLES_DEFINIS] = { MED_POINT1 ,
- MED_SEG2 , MED_SEG3,
- MED_TRIA3 , MED_TRIA6 , MED_QUAD4 , MED_QUAD8 ,
- MED_TETRA4 , MED_TETRA10 , MED_HEXA8 , MED_HEXA20 , MED_PYRA5 , MED_PYRA13 , MED_PENTA6 , MED_PENTA15 };
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Base */
-/* */
-/*********************************************************/
-
-// classe mere des connectivités cannoniques
-// N'a aucune méthode virtuelle pour éviter les pertes de temps
-// Ce sont les constructeurs des classes dérivées qui renseignent les attributs spécifiques
-// un simplexe de base est constitué par un sommet de la maille qui n'est pas contenu dans la face démandée et par trois points de cette face
-// Ce simplexe est utilisé dans le calcul des fonctions barycentriques
-// LES MAILLES SONT DONC ET PAR CONSEQUENT DES MAILLES A FACES PLANES
-// Une face est une face P1, c'est a dire contenant uniquement les sommets, par les noeuds milieux
-// Ces faces sont utilisées pour le calcul de connexité
-
-
-class Connectivite_Canonique_Base
-{
-protected :
- int type ;
- int nbr_noeuds ;
- int nbr_faces ;
- vector<int> premier_noeud ;
- vector< vector<int> > simplexe_base ;
- vector< vector<int> > face ;
-public :
- inline int DONNE_NBR_NOEUDS() const { return nbr_noeuds; }
- inline int DONNE_NBR_FACES() const { return nbr_faces; }
- inline const vector<int> & DONNE_SIMPLEXE_BASE(int num_face) const { return simplexe_base[num_face]; }
- inline const vector<int> & DONNE_FACE(int num_face) const { return face[num_face]; }
- inline int DONNE_PREMIER_NOEUD_DE_FACE(int num_face) const { return premier_noeud[num_face]; }
- friend class Wrapper_Maille;
-};
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_* */
-/* */
-/*********************************************************/
-
-// définies dans la partie CODE
-// les constructeurs construisent tous les tableaux de connectivités nécessaires en fonction du MODELE MED
-
-//class Connectivite_Canonique_Point1 : public Connectivite_Canonique_Base;
-//class Connectivite_Canonique_Seg2 : public Connectivite_Canonique_Base;
-//class Connectivite_Canonique_Seg3 : public Connectivite_Canonique_Base;
-//class Connectivite_Canonique_Tria3 : public Connectivite_Canonique_Base;
-//class Connectivite_Canonique_Tria6 : public Connectivite_Canonique_Base;
-//class Connectivite_Canonique_Quad4 : public Connectivite_Canonique_Base;
-//class Connectivite_Canonique_Quad8 : public Connectivite_Canonique_Base;
-//class Connectivite_Canonique_Tetra4 : public Connectivite_Canonique_Base;
-//class Connectivite_Canonique_Tetra10 : public Connectivite_Canonique_Base;
-//class Connectivite_Canonique_Hexa8 : public Connectivite_Canonique_Base;
-//class Connectivite_Canonique_Hexa20 : public Connectivite_Canonique_Base;
-//class Connectivite_Canonique_Pyra5 : public Connectivite_Canonique_Base;
-//class Connectivite_Canonique_Pyra13 : public Connectivite_Canonique_Base;
-//class Connectivite_Canonique_Penta6 : public Connectivite_Canonique_Base;
-//class Connectivite_Canonique_Penta15 : public Connectivite_Canonique_Base;
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Generale */
-/* */
-/*********************************************************/
-
-// Cette classe contient toutes les connectivités canoniques, elle est utilisée dans Wrapper_Nuage_Maille
-
-class Connectivite_Generale
-{
-protected :
- vector<Connectivite_Canonique_Base *> AllConn;
-public :
- Connectivite_Generale();
- ~Connectivite_Generale();
- // Renvoie la connectivite locale de la maille de numero local de modele i, dont l'equivalent MED est Equivalence_Local_MED[i]
- Connectivite_Canonique_Base * operator[](int i) const {return AllConn[i];}
-};
-
-/*********************************************************/
-/* */
-/* Structure type_retour */
-/* */
-/*********************************************************/
-
-// c'est une structure de type petit tableau statique, pour accelerer les acces et eviter les allocations dynamiques
-
-struct type_retour
- {
- int quoi[MAXNBR];
- int combien;
- };
-
-/*********************************************************/
-/* */
-/* Fonction Comparaison_Informe(...) */
-/* */
-/*********************************************************/
-
-// renvoie vrai si v1 et v2 contiennent la meme chose et sont de meme tailles, faux sinon
-
-int Comparaison_Informe(const type_retour &v1,const type_retour &v2);
-
-/*********************************************************/
-/* */
-/* Classe Wrapper_Maille */
-/* */
-/*********************************************************/
-
-// c'est le wrapper maille sur int[]
-// cette classe n'est pas dérivée, tous les types de mailles sont stockées sous cette forme
-// la variable qui définit les type est la Connectivité_Canonique_Base, qui est toujours polymorphée en un type spécifique
-
-
-class Wrapper_Maille
-{
-protected :
-
- // la référence du premier sommet
- int * sommets;
- // la connectivité canonique, toujours polymorphée
- Connectivite_Canonique_Base * modele;
-
-public :
- Wrapper_Maille():sommets(NULL) {}
- ~Wrapper_Maille() {}
-
- // sorte de transtypeur, cette méthode prend une référence vers un premier sommet et un modele canonique et renvoie *this en tant que wrapper sur ces données
- inline const Wrapper_Maille & positionne(int * pos, Connectivite_Canonique_Base * mod){sommets=pos;modele=mod;return *this;}
- // méthodes de la politique (les numéros renvoyés sont des numéros GLOBAUX, calculés à partir de l'indirection fournie par la connectivité canonique
- // par contre les numéros de face fournis sont des numéros locaux
- // renvoie le numéro global du sommet de numéro local i
- inline int operator[](int i) const {return sommets[i];}
- inline int DONNE_NBR_NOEUDS() const;
- inline int DONNE_NBR_FACES() const;
- inline void DONNE_SIMPLEXE_BASE(int num_face,type_retour & simplexe) const;
- inline void DONNE_FACE(int num_face,type_retour & face) const;
- inline int DONNE_PREMIER_NOEUD_DE_FACE(int num_face) const;
- // pour une face, donne, s'il existe, le numéro local de face équivalente, -1 sinon
- inline int DONNE_NUM_LOC_FACE_EGALE_A_FORMANT(const type_retour & sommets_face) const;
- // donne le numéro local de modele
- inline int DONNE_TYPE_MAILLE() const;
- // donne le numéro MED de modele
- inline int DONNE_TYPE_MED_MAILLE() const;
-};
-
-
-/*********************************************************/
-/* */
-/* Classe Wrapper_Nuage_Maille */
-/* */
-/*********************************************************/
-
-// Classe de Wrapping sur un nuage de maille donné sous forme SKYLINE
-// voir la classe Wrapper_Med_Connectivity dans MEDMEM_Wrapper_Connectivity.hxx pour la politique de classe
-
-template <class FORME_SKYLINE> class Wrapper_Nuage_Maille
-{
-protected :
- // pointeur sur une forme skyline
- FORME_SKYLINE * mailles;
- // toutes les connectivités canoniques
- Connectivite_Generale ConnGen;
- int nbr_mailles;
- // ATTENTION, c'est le type en numero local de modele, pour éviter une map, le numéro de modele MED correponsdant est donné par Equivalence_Local_MED
- vector<int> types;
- // pointeur dans mailles du premier sommet de chaque maille (évite les calculs du au nombres éventuellement différents de sommets par maille)
- vector< int * > premier_pointeur;
- // maille_courante, est un Wrapper_Maille déja instancié utilisé par l'opérateur [] pour accelerer les acces
- Wrapper_Maille maille_courante;
-public :
- Wrapper_Nuage_Maille():mailles(NULL) {}
- // le constructeur renseigne types et premier_pointeur, instantie ConnGenn et positionne maille_courante sur la premiere maille
- Wrapper_Nuage_Maille(FORME_SKYLINE * fs);
- ~Wrapper_Nuage_Maille() {}
- // Méthodes de la politique
- // positionne maille_courante sur la maille de numéro global i et renvoie maille_courante
- inline const Wrapper_Maille & operator[](int i);
- inline int SIZE() {return nbr_mailles;}
- void affiche();
-};
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// CODE ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-/*********************************************************/
-/* */
-/* Fonction Comparaison_Informe(...) */
-/* */
-/*********************************************************/
-
-// effectue le test (v1 et v2 ont meme taille)&&(chaque élément de v1 est dans v2)
-// c'est une égalité forte si on est sur que v1 et v2 n'ont pas de doublets,
-// ce qui est le cas pour les mailles et les simplexes
-
-int Comparaison_Informe(const type_retour &v1,const type_retour &v2)
- {
- int t1=v1.combien;
- int t2=v2.combien;
- if (t1!=t2) return FAUX;
- int i1,i2;
- int test;
- for (i1=0;i1<t1;i1++)
- {
- test=1;
- for (i2=0;(i2<t2)&&(test);i2++)
- {
- if (v1.quoi[i1]==v2.quoi[i2]) test=0;
- }
- if (test) return FAUX;
- }
- return VRAI;
- }
-
-/*********************************************************/
-/* */
-/* Classe Wrapper_Maille */
-/* */
-/*********************************************************/
-
-inline int Wrapper_Maille::DONNE_NBR_NOEUDS() const
- {
- return modele->DONNE_NBR_NOEUDS();
- }
-inline int Wrapper_Maille::DONNE_NBR_FACES() const
- {
- return modele->DONNE_NBR_FACES();
- }
-inline void Wrapper_Maille::DONNE_SIMPLEXE_BASE(int num_face,type_retour & simplexe) const
- {
- const vector<int> & simplexelocal=modele->DONNE_SIMPLEXE_BASE(num_face);
- simplexe.combien=simplexelocal.size();
- for (int i=0;i<simplexe.combien;i++) simplexe.quoi[i]=sommets[simplexelocal[i]];
- }
-inline void Wrapper_Maille::DONNE_FACE(int num_face,type_retour & face) const
- {
- const vector<int> & facelocal=modele->DONNE_FACE(num_face);
- face.combien=facelocal.size();
- for (int i=0;i<face.combien;i++) face.quoi[i]=sommets[facelocal[i]];
- }
-inline int Wrapper_Maille::DONNE_PREMIER_NOEUD_DE_FACE(int num_face) const
- {
- return sommets[modele->DONNE_PREMIER_NOEUD_DE_FACE(num_face)];
- }
-inline int Wrapper_Maille::DONNE_NUM_LOC_FACE_EGALE_A_FORMANT(const type_retour & sommets_face) const
- {
- type_retour face_loc;
- int num_face;
- int taille_face_exam;
- int test=FAUX;
- for (num_face=0;num_face<DONNE_NBR_FACES();num_face++)
- {
- DONNE_FACE(num_face,face_loc);
- if (Comparaison_Informe(face_loc,sommets_face)) return num_face;
- }
- return UNDEFINED;
- }
-inline int Wrapper_Maille::DONNE_TYPE_MAILLE() const
- {
- return modele->type;
- }
-inline int Wrapper_Maille::DONNE_TYPE_MED_MAILLE() const
- {
- return Equivalence_Local_MED[modele->type];
- }
-
-
-/*********************************************************/
-/* */
-/* Classe Wrapper_Nuage_Maille */
-/* */
-/*********************************************************/
-
-template <class FORME_SKYLINE> Wrapper_Nuage_Maille<FORME_SKYLINE>::Wrapper_Nuage_Maille(FORME_SKYLINE * fs):mailles(fs)
- {
- int i;
- map<int,int> Equivalence_MED_Local;
- // calcule la map de convertion des types med en numéro local, pour accelerer l'acces
- for (i=0;i<NBR_MODELES_MAILLES_DEFINIS;i++) Equivalence_MED_Local[Equivalence_Local_MED[i]]=i;
- nbr_mailles=mailles->SIZE();
- types.resize(nbr_mailles);
- premier_pointeur.resize(nbr_mailles);
- for (i=0;i<nbr_mailles;i++)
- {
- types[i]=Equivalence_MED_Local[mailles->DONNE_TYPE_MAILLE(i)];
- premier_pointeur[i]=mailles->DONNE_PREMIER_POINTEUR(i);
- }
- maille_courante.positionne(premier_pointeur[0],ConnGen[types[0]]);
- }
-template <class FORME_SKYLINE> const Wrapper_Maille & Wrapper_Nuage_Maille<FORME_SKYLINE>::operator[](int i)
- {
- return maille_courante.positionne(premier_pointeur[i],ConnGen[types[i]]);
- }
-template <class FORME_SKYLINE> void Wrapper_Nuage_Maille<FORME_SKYLINE>::affiche()
- {
- int i,j;
- for (i=0;i<nbr_mailles;i++)
- {
- cout<<"Maille "<<i<<" MED "<<Equivalence_Local_MED[types[i]]<<" : "<<flush;
- for (j=0;j<(*this)[i].DONNE_NBR_NOEUDS();j++) cout<<(*this)[i][j]<<" "<<flush;
- cout<<endl;
- }
- }
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Point1 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Point1 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Point1()
- {
-
- type=0;
-
- nbr_noeuds = 1;
- nbr_faces = 0;
-
- premier_noeud = vector<int>(0);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- }
- ~Connectivite_Canonique_Point1() {}
-};
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Seg2 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Seg2 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Seg2()
- {
-
- type=1;
-
- int pn[2] = {0,1};
- int sb[4] = {1,0,0,1};
- int fa[2] = {0,1};
- int po[3] = {0,1,2};
-
- nbr_noeuds = 2;
- nbr_faces = 2;
-
-
- premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- int i;
-
- for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[2*i],&sb[2*(i+1)]);
- for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
-
- }
- ~Connectivite_Canonique_Seg2() {}
-};
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Seg3 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Seg3 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Seg3()
- {
-
- type=2;
-
- int pn[2] = {0,1};
- int sb[4] = {1,0,0,1};
- int fa[2] = {0,1};
- int po[3] = {0,1,2};
-
- nbr_noeuds = 3;
- nbr_faces = 2;
-
-
- premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- int i;
-
- for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[2*i],&sb[2*(i+1)]);
- for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
-
- }
- ~Connectivite_Canonique_Seg3() {}
-};
-
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Tria3 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Tria3 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Tria3()
- {
-
- type=3;
-
- int pn[3] = {0,1,2};
- int sb[9] = {2,0,1,0,1,2,1,2,0};
- int fa[6] = {0,1,1,2,2,0};
- int po[4] = {0,2,4,6};
- nbr_noeuds = 3;
- nbr_faces = 3;
-
-
- premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- int i;
-
- for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[3*i],&sb[3*(i+1)]);
- for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
-
- }
- ~Connectivite_Canonique_Tria3() {}
-};
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Tria6 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Tria6 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Tria6()
- {
-
- type=4;
-
- int pn[3] = {0,1,2};
- int sb[9] = {2,0,1,0,1,2,1,2,0};
- int fa[6] = {0,1,1,2,2,0};
- int po[4] = {0,2,4,6};
- nbr_noeuds = 6;
- nbr_faces = 3;
-
-
- premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- int i;
-
- for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[3*i],&sb[3*(i+1)]);
- for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
-
- }
- ~Connectivite_Canonique_Tria6() {}
-};
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Quad4 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Quad4 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Quad4()
- {
-
- type=5;
-
- int pn[4] = {0,1,2,3};
- int sb[12] = {2,0,1,3,1,2,0,2,3,1,0,2};
- int fa[8] = {0,1,1,2,2,3,3,0};
- int po[5] = {0,2,4,6,8};
- nbr_noeuds = 4;
- nbr_faces = 4;
-
-
- premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- int i;
-
- for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[3*i],&sb[3*(i+1)]);
- for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
-
- }
- ~Connectivite_Canonique_Quad4() {}
-};
-
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Quad8 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Quad8 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Quad8()
- {
-
- type=6;
-
- int pn[4] = {0,1,2,3};
- int sb[12] = {2,0,1,3,1,2,0,2,3,1,0,2};
- int fa[8] = {0,1,1,2,2,3,3,0};
- int po[5] = {0,2,4,6,8};
- nbr_noeuds = 8;
- nbr_faces = 4;
-
-
- premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- int i;
-
- for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[3*i],&sb[3*(i+1)]);
- for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
-
- }
- ~Connectivite_Canonique_Quad8() {}
-};
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Tetra4 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Tetra4 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Tetra4()
- {
-
- type=7;
-
- int pn[4] = {0,0,1,2};
- int sb[16] = {3,0,1,2,2,0,3,1,0,1,3,2,1,2,3,0};
- int fa[12] = {0,1,2,0,3,1,1,3,2,2,3,0};
- int po[5] = {0,3,6,9,12};
- nbr_noeuds = 4;
- nbr_faces = 4;
-
-
- premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- int i;
-
- for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
- for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
-
- }
- ~Connectivite_Canonique_Tetra4() {}
-};
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Tetra10 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Tetra10 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Tetra10()
- {
-
- type=8;
-
- int pn[4] = {0,0,1,2};
- int sb[16] = {3,0,1,2,2,0,3,1,0,1,3,2,1,2,3,0};
- int fa[12] = { 0,1,2, 0,3,1, 1,3,2, 2,3,0};
- int po[5] = {0,3,6,9,12};
-
- nbr_noeuds = 10;
- nbr_faces = 4;
-
-
- premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- int i;
-
- for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
- for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
-
- }
- ~Connectivite_Canonique_Tetra10() {}
-};
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Hexa8 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Hexa8 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Hexa8()
- {
-
- type=9;
-
- int pn[6] = {0,4,0,1,2,3};
- int sb[24] = {5,0,1,2,0,7,6,5,3,0,4,5,4,1,5,6,1,2,6,3,2,3,7,0};
- int fa[24] = {0,1,2,3,4,5,6,7,0,4,5,1,1,5,6,2,2,6,7,3,3,7,4,0};
- int po[7] = {0,4,8,12,16,20,24};
- nbr_noeuds = 8;
- nbr_faces = 6;
-
-
- premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- int i;
-
- for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
- for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
-
- }
- ~Connectivite_Canonique_Hexa8() {}
-};
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Hexa20 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Hexa20 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Hexa20()
- {
-
- type=10;
-
- int pn[6] = {0,4,0,1,2,3};
- int sb[24] = {5,0,1,2,0,7,6,5,3,0,4,5,4,1,5,6,1,2,6,3,2,3,7,0};
- int fa[24] = {0,1,2,3,4,5,6,7,0,4,5,1,1,5,6,2,2,6,7,3,3,7,4,0};
- int po[7] = {0,4,8,12,16,20,24};
- nbr_noeuds = 20;
- nbr_faces = 6;
-
-
- premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- int i;
-
- for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
- for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
-
- }
- ~Connectivite_Canonique_Hexa20() {}
-};
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Pyra5 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Pyra5 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Pyra5()
- {
-
- type=11;
-
- int pn[5] = {0,0,1,2,3};
- int sb[20] = {4,0,1,2,3,0,4,1,0,1,4,2,1,2,4,3,2,0,3,4};
- int fa[16] = {0,1,2,3,0,4,1,1,4,2,2,4,3,3,4,0};
- int po[6] = {0,4,7,10,13,16};
- nbr_noeuds = 5;
- nbr_faces = 5;
-
-
- premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- int i;
-
- for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
- for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
-
- }
- ~Connectivite_Canonique_Pyra5() {}
-};
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Pyra13 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Pyra13 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Pyra13()
- {
-
- type=12;
-
- int pn[5] = {0,0,1,2,3};
- int sb[20] = {4,0,1,2,3,0,4,1,0,1,4,2,1,2,4,3,2,0,3,4};
- int fa[16] = {0,1,2,3,0,4,1,1,4,2,2,4,3,3,4,0};
- int po[6] = {0,4,7,10,13,16};
- nbr_noeuds = 13;
- nbr_faces = 5;
-
-
- premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- int i;
-
- for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
- for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
-
- }
- ~Connectivite_Canonique_Pyra13() {}
-};
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Penta6 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Penta6 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Penta6()
- {
-
- type=13;
-
- int pn[5] = {0,3,0,1,2};
- int sb[20] = {3,0,1,2,2,3,4,5,5,0,3,1,0,1,4,2,1,2,5,0};
- int fa[18] = {0,1,2,3,4,5,0,3,4,1,1,4,5,2,2,5,3,1};
- int po[6] = {0,3,6,10,14,18};
- nbr_noeuds = 6;
- nbr_faces = 5;
-
-
- premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- int i;
-
- for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
- for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
-
- }
- ~Connectivite_Canonique_Penta6() {}
-};
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Canonique_Penta15 */
-/* */
-/*********************************************************/
-
-class Connectivite_Canonique_Penta15 : public Connectivite_Canonique_Base
-{
-public :
- Connectivite_Canonique_Penta15()
- {
-
- type=14;
-
- int pn[5] = {0,3,0,1,2};
- int sb[20] = {3,0,1,2,2,3,4,5,5,0,3,1,0,1,4,2,1,2,5,0};
- int fa[18] = {0,1,2,3,4,5,0,3,4,1,1,4,5,2,2,5,3,1};
- int po[6] = {0,3,6,10,14,18};
- nbr_noeuds = 15;
- nbr_faces = 5;
-
-
- premier_noeud = vector<int>(&pn[0],&pn[nbr_faces]);
-
- simplexe_base = vector< vector<int> >(nbr_faces);
- face = vector< vector<int> >(nbr_faces);
-
- int i;
-
- for (i=0;i<nbr_faces;i++) simplexe_base[i]=vector<int>(&sb[4*i],&sb[4*(i+1)]);
- for (i=0;i<nbr_faces;i++) face[i]=vector<int>(&fa[po[i]],&fa[po[i+1]]);
-
- }
- ~Connectivite_Canonique_Penta15() {}
-};
-
-/*********************************************************/
-/* */
-/* Classe Connectivite_Generale */
-/* */
-/*********************************************************/
-
-Connectivite_Generale::Connectivite_Generale():AllConn(NBR_MODELES_MAILLES_DEFINIS)
- {
- // l'ordre est important, il dépend de la relation entre numéro local et modele et numéro MED
- AllConn[ 0]=new Connectivite_Canonique_Point1 ();
- AllConn[ 1]=new Connectivite_Canonique_Seg2 ();
- AllConn[ 2]=new Connectivite_Canonique_Seg3 ();
- AllConn[ 3]=new Connectivite_Canonique_Tria3 ();
- AllConn[ 4]=new Connectivite_Canonique_Tria6 ();
- AllConn[ 5]=new Connectivite_Canonique_Quad4 ();
- AllConn[ 6]=new Connectivite_Canonique_Quad8 ();
- AllConn[ 7]=new Connectivite_Canonique_Tetra4 ();
- AllConn[ 8]=new Connectivite_Canonique_Tetra10 ();
- AllConn[ 9]=new Connectivite_Canonique_Hexa8 ();
- AllConn[10]=new Connectivite_Canonique_Hexa20 ();
- AllConn[11]=new Connectivite_Canonique_Pyra5 ();
- AllConn[12]=new Connectivite_Canonique_Pyra13 ();
- AllConn[13]=new Connectivite_Canonique_Penta6 ();
- AllConn[14]=new Connectivite_Canonique_Penta15 ();
- }
-Connectivite_Generale::~Connectivite_Generale()
- {
- for (int i=0;i<AllConn.size();i++) delete AllConn[i];
- }
-
-
-#endif
+++ /dev/null
-#ifndef MEDMEM_WRAPPER_CONNECTIVITY_HXX
-#define MEDMEM_WRAPPER_CONNECTIVITY_HXX
-
-#include "MEDMEM_Connectivity.hxx"
-
-#include <vector>
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// DECLARATIONS ET CODE ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-/*********************************************************/
-/* */
-/* Wrapper_Med_Connectivity */
-/* */
-/*********************************************************/
-
-// obligé de faire de la recopie car MED n'utilise pas la numérotation standart C
-
-class Wrapper_Med_Connectivity
-{
-protected :
- int * mailles;
- int nbr_mailles;
- vector<int> types;
- vector< int* > premier_pointeur;
-
-public :
- ~Wrapper_Med_Connectivity() {if (mailles) delete [] mailles;}
- Wrapper_Med_Connectivity():mailles(NULL) {}
- Wrapper_Med_Connectivity(CONNECTIVITY * maillesmed)
- {
- const med_int * tab_sommets_mailles=maillesmed->getConnectivity(MED_NODAL,MED_CELL,MED_ALL_ELEMENTS);
- const med_int * med_connectivite=maillesmed->getConnectivityIndex(MED_FULL_INTERLACE,MED_CELL);
- const med_int * med_index=maillesmed->getValueIndex(MED_FULL_INTERLACE);
- nbr_mailles=maillesmed->getNumberOf(MED_CELL,MED_ALL_ELEMENTS);
- int size=med_index[nbr_mailles]-med_index[0];
- types.resize(nbr_mailles);
- premier_pointeur.resize(nbr_mailles);
- mailles=new int[size];
- int i;
- for (i=0;i<size;i++)
- {
- mailles[i]=tab_sommets_mailles[i]-1;
- }
- for (i=0;i<nbr_mailles;i++)
- {
- types[i]=maillesmed->getElementType(MED_CELL,i+1); // A VERIFIER : le +1
- premier_pointeur[i]=&mailles[med_index[i]-1]; // A VERIFIER : la formule
- }
- }
- // Méthodes de la politique
- inline int SIZE() {return nbr_mailles;}
- inline int DONNE_TYPE_MAILLE(int i) {return types[i];}
- inline int * DONNE_PREMIER_POINTEUR(int i) {return premier_pointeur[i];}
-};
-
-
-#endif
+++ /dev/null
-#ifndef MEDMEM_WRAPPER_FIELD_HXX
-#define MEDMEM_WRAPPER_FIELD_HXX
-
-#include "MEDMEM_Field.hxx"
-
-#include <vector>
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// DECLARATIONS ET CODE ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-/*********************************************************/
-/* */
-/* Template Arithmétiques de Valdhuizen */
-/* */
-/*********************************************************/
-
-// permet de faire des opérations algébriques sur des Wrappers_MED_Field sans faire d'allocations inutiles
-// voir les articles de Valdhuizen pour la compréhension du processus
-
-template <class TYPE> class Valeur;
-
-struct Plus
-{
-public :
- static double apply(double a,double b) {return a+b;}
-};
-
-struct Multiply
-{
-public :
- static double apply(double a,double b) {return a*b;}
-};
-
-
-template <typename Left,typename Op, typename Right> struct X
-{
- Left left;
- Right right;
- X(Left l,Right r):left(l),right(r){}
- double operator[](int i)
- {
- return Op::apply(left[i],right[i]);
- }
-};
-
-template <typename Right> struct X<double,Multiply,Right>
-{
- double left;
- Right right;
- X(double l,Right r):left(l),right(r){}
- double operator[](int i)
- {
- return Multiply::apply(left,right[i]);
- }
-};
-
-template <typename TYPE> X< Valeur<TYPE>,Plus,Valeur<TYPE> > operator+(Valeur<TYPE> v1,Valeur<TYPE> v2)
-{
-return X< Valeur<TYPE>,Plus,Valeur<TYPE> >(v1,v2);
-}
-
-template <typename TYPE> X< double,Multiply,Valeur<double> > operator*(TYPE sca,Valeur<TYPE> v)
-{
-return X< TYPE,Multiply,Valeur<TYPE> >(sca,v);
-}
-
-template <typename TYPE,typename L, typename O, typename R> X< Valeur<TYPE>,Plus,X<L,O,R> > operator+(Valeur<TYPE> v,X<L,O,R> expression)
-{
-return X< Valeur<TYPE>,Plus,X<L,O,R> >(v,expression);
-}
-
-template <typename TYPE,typename L, typename O, typename R> X< X<L,O,R>,Plus,Valeur<TYPE> > operator+(X<L,O,R> expression,Valeur<TYPE> v)
-{
-return X< X<L,O,R>,Plus,Valeur<TYPE> >(expression,v);
-}
-
-template <typename Ll, typename Ol, typename Rl,typename Lr, typename Or, typename Rr> X< X<Ll,Ol,Rl>,Plus, X<Lr,Or,Rr> > operator+(X<Ll,Ol,Rl> el, X<Lr,Or,Rr> er )
-{
-return X< X<Ll,Ol,Rl>,Plus,X<Lr,Or,Rr> >(el,er);
-}
-
-template <typename L, typename O, typename R> X< double,Multiply,X<L,O,R> > operator*(double sca,X<L,O,R> expression)
-{
-return X< double,Multiply,X<L,O,R> >(sca,expression);
-}
-
-template <typename Left,typename Op,typename Right> X< double,Multiply,X<Left,Op,Right> > operator/(X<Left,Op,Right> l,double x)
-{
-return X< double,Multiply,X<Left,Op,Right> >(((double) 1/x),l);
-}
-
-/*********************************************************/
-/* */
-/* Classe Valeur */
-/* */
-/*********************************************************/
-
-// Problèmes : les constructeurs par copie ne sont pas satisfaisants
-// Valeur est symboliquement l'argument d'une classe formelle Vecteur<Valeur>
-// elle peut etre un réel ou un pointeur sur réel, simulant un vecteur de vecteur
-
-template <class TYPE> class Valeur
-{
-protected :
- TYPE * valeurs;
- int nbr_valeurs;
- int a_detruire;
-public :
- Valeur():valeurs(NULL),a_detruire(0){}
- Valeur(TYPE * val,int nv):valeurs(val),nbr_valeurs(nv),a_detruire(0){} // A VERIFIER
- Valeur(int n):nbr_valeurs(n),a_detruire(1)
- {
- valeurs=new TYPE[nbr_valeurs];
- }
- template <typename Left,typename Op,typename Right> Valeur(X<Left,Op,Right> expression)
- {
- for (int i=0;i<nbr_valeurs;i++) valeurs[i]=expression[i];
- }
- template <typename Left,typename Op,typename Right> void operator=(X<Left,Op,Right> expression)
- {
- for (int i=0;i<nbr_valeurs;i++) valeurs[i]=expression[i];
- }
- void operator=(Valeur v)
- {
- for (int i=0;i<nbr_valeurs;i++) valeurs[i]=v[i];
- }
- Valeur(const Valeur &v):nbr_valeurs(v.nbr_valeurs)
- {
- if (v.a_detruire)
- {
- a_detruire=1;
- valeurs=new TYPE[nbr_valeurs];
- for (int i=0;i<nbr_valeurs;i++) valeurs[i]=v.valeurs[i];
- }
- else
- {
- a_detruire=0;
- valeurs=v.valeurs;
- }
- }
- ~Valeur(){if (a_detruire) delete [] valeurs;}
- TYPE operator[](int i){return valeurs[i];}
- int SIZE() const {return nbr_valeurs;}
- double NormeAbs()
- {
- int i;
- double tmp=0;
- for (i=0;i<nbr_valeurs;i++) tmp+=fabs(valeurs[i]);
- return tmp;
- }
-
-};
-
-template <class TYPE> ostream &operator<<(ostream &os,Valeur<TYPE> v)
- {
- os<<"("<<flush;
- for (int i=0;i<v.SIZE();i++) os<<" "<<v[i]<<flush;
- os<<" ) "<<flush;
- return os;
- }
-
-/*********************************************************/
-/* */
-/* Classe Wrapper_MED_Field */
-/* */
-/*********************************************************/
-
-// c'est la classe de Wrapping sur un objet FIELD<double> MEDMEMOIRE
-
-class Wrapper_MED_Field
-{
-protected :
- int nbr_valeurs;
- int nbr_composantes;
- double * valeurs;
-public :
- Wrapper_MED_Field():valeurs(NULL){}
- Wrapper_MED_Field(int nv, int nc, double * v):nbr_valeurs(nv),nbr_composantes(nc),valeurs(v)
- {
- }
- Wrapper_MED_Field(const FIELD<double> * medfield)
- {
- nbr_valeurs=medfield->getNumberOfValues();
- nbr_composantes=medfield->getNumberOfComponents();
- valeurs=const_cast<double *>(medfield->getValue(MED_FULL_INTERLACE));
- }
- ~Wrapper_MED_Field(){}
- inline Valeur<double> operator[](int i)
- {
- return Valeur<double>(&valeurs[nbr_composantes*i],nbr_composantes);
- }
- double * Get_Valeurs() {return valeurs;}
- inline int Get_Nbr_Valeurs() const {return nbr_valeurs;}
- inline int Get_Nbr_Composantes() const {return nbr_composantes;}
- friend ostream & operator<<(ostream &os, Wrapper_MED_Field);
-};
-
-ostream & operator<<(ostream &os, Wrapper_MED_Field wmf)
-{
-for (int i=0;i<wmf.nbr_valeurs;i++) os<<"Wrapper_MED_Field["<<i<<"] = "<<wmf[i]<<endl;
-return os;
-}
-
-#endif
+++ /dev/null
-#ifndef MEDMEM_WRAPPER_MESH_HXX
-#define MEDMEM_WRAPPER_MESH_HXX
-
-#include "MEDMEM_WrapperCells.hxx"
-
-#include "stdio.h"
-#include "stdlib.h"
-
-#include <vector>
-
-#ifndef UNDEFINED
-#define UNDEFINED -1
-#endif
-
-#ifndef FAUX
-#define FAUX 0
-#endif
-
-#ifndef VRAI
-#define VRAI 1
-#endif
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// DECLARATIONS ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-/*********************************************************/
-/* */
-/* Wrapper_Maillage */
-/* */
-/*********************************************************/
-
-// cette classe est à la fois un wrapper sur un nuage de maille et une classe d'algorithme
-// elle s'occupe de construire les liens de connexités minimums du nuage de maille
-// pour le transformer en maillage suffisament riche pour etre utilisé par les algorithmes de connexités
-// et autres méthodes nécessitant des informations de connexité sur un maillage
-
-// la version utilisée dans MEDMEMOIRE est dé-templatifiée dans MEDMEM_InterpolationHighLevelObject.hxx
-
-template <class NUAGEMAILLE> class Wrapper_Maillage
-{
-protected :
- // référence vers le nuage de maille,
- // voir la classe Wrapper_Nuage_Maille dans MEDMEM_WrapperCells.hxx pour la politique
- NUAGEMAILLE * mailles;
-
- int nbr_noeuds;
-
- // liste des numéros globaux de faces contenues dans une maille
- vector< vector<int> > faces_contenues;
- // liste des numéros globaux de mailles qui contiennent un noeud
- vector< vector<int> > mailles_contenant_noeud;
- // liste des numéros globaux de mailles voisines d'une maille donnée via une face
- // l'ordre du voisin dans la liste implique par quelle face dans le tableau faces_contenues il est voisin
- vector< vector<int> > voisins_de_maille;
-
- // liste des numéros globaux de faces qui sont au bord du maillage
- // Ce sont les faces qui n'ont qu'une seule maille de rattachement
- vector<int> face_au_bord;
- // liste des numéros globaux de mailles qui sont au bord
- // ce sont les mailles qui ont une face sans voisin
- vector<int> maille_au_bord;
-
- // Méthode privée
- // construit le tableau mailles_contenant_noeud
- void Construit_Contenant_Noeud();
-
-public :
-
- Wrapper_Maillage():mailles(NULL) {}
- // Construit les Connectivités du maillage à la construction
- Wrapper_Maillage(NUAGEMAILLE * fs, int nn);
- ~Wrapper_Maillage() {}
-
- // Méthodes de la politique
- inline int DONNE_NBR_FACES_MAILLE(int num_maille);
- inline int DONNE_VOISIN_DE_MAILLE(int num_maille,int num_face) const;
- inline int EST_AU_BORD_FACE_DE_MAILLE(int num_maille,int num_face) const;
- inline int DONNE_NBR_FACES(int num_maille) const;
- inline int DONNE_PREMIERE_MAILLE_CONTENANT(int num_noeud) const;
- inline NUAGEMAILLE * DONNE_POINTEUR_NUAGEMAILLE();
-
-};
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// CODE ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-template <class NUAGEMAILLE> int Wrapper_Maillage<NUAGEMAILLE>::DONNE_PREMIERE_MAILLE_CONTENANT(int num_noeud) const
- {
- return mailles_contenant_noeud[num_noeud][0];
- }
-template <class NUAGEMAILLE> int Wrapper_Maillage<NUAGEMAILLE>::DONNE_VOISIN_DE_MAILLE(int num_maille,int num_face) const
- {
- return voisins_de_maille[num_maille][num_face];
- }
-template <class NUAGEMAILLE> int Wrapper_Maillage<NUAGEMAILLE>::EST_AU_BORD_FACE_DE_MAILLE(int num_maille,int num_face) const
- {
- return face_au_bord[faces_contenues[num_maille][num_face]];
- }
-template <class NUAGEMAILLE> int Wrapper_Maillage<NUAGEMAILLE>::DONNE_NBR_FACES_MAILLE(int num_maille)
- {
- return (*mailles)[num_maille].DONNE_NBR_FACES();
- }
-template <class NUAGEMAILLE> NUAGEMAILLE * Wrapper_Maillage<NUAGEMAILLE>::DONNE_POINTEUR_NUAGEMAILLE()
- {
- return mailles;
- }
-template <class NUAGEMAILLE> void Wrapper_Maillage<NUAGEMAILLE>::Construit_Contenant_Noeud()
- {
- int nbr_noeuds_maille;
- int num,num_noeud,num_maille;
-
- mailles_contenant_noeud.resize(nbr_noeuds);
-
- // parcours le tableau des mailles, puis les sommets de chaque maille
- // et utilise un push_back pour renseigner mailles_contenant_noeud
-
- for (num_maille=0;num_maille<mailles->SIZE();num_maille++)
- {
- nbr_noeuds_maille=(*mailles)[num_maille].DONNE_NBR_NOEUDS();
- for (num_noeud=0;num_noeud<nbr_noeuds_maille;num_noeud++)
- {
- num=(*mailles)[num_maille][num_noeud];
- mailles_contenant_noeud[num].push_back(num_maille);
- }
- }
-
- }
-template <class NUAGEMAILLE> Wrapper_Maillage<NUAGEMAILLE>::Wrapper_Maillage(NUAGEMAILLE * fs,int nn)
- {
-
- if (fs) mailles=fs;
- else
- {
- cerr<<"Wrapper_Maillage : Nuage mailles vide passé en argument"<<endl;
- exit(-1);
- }
-
- int i,j,k;
- int num_local_face;
- int ind_num_noeud,num_noeud;
- int num_maille;
- int ind_num_maille_sec,num_maille_sec;
- int num_local_sec;
- int flag_existence;
- int nbr_mailles=mailles->SIZE();
- int nbr_formants=0;
- int approx_nbr_formants=0;
- int tmp;
- int num_loc;
-
- nbr_noeuds=nn;
-
- voisins_de_maille.resize(nbr_mailles);
- faces_contenues.resize(nbr_mailles);
- maille_au_bord.resize(nbr_mailles,UNDEFINED);
-
- type_retour sommets_face;
-
- Construit_Contenant_Noeud();
-
- // mise a taille des tableaux et calcul d'une approximation du nombre de faces
- // on postule que le nombre de faces réel est le dixieme de la somme du nombre de faces par maille sur toutes les mailles
- // on calcule cette approximation pour éviter les allocations fréquentes dues aux push_back pour des petits tableaux
-
- for (num_maille=0;num_maille<nbr_mailles;num_maille++)
- {
- tmp=(*mailles)[num_maille].DONNE_NBR_FACES();
- voisins_de_maille[num_maille]=vector<int>(tmp,UNDEFINED);
- faces_contenues[num_maille]=vector<int>(tmp,UNDEFINED);
- approx_nbr_formants+=tmp;
- }
-
- face_au_bord.reserve(approx_nbr_formants/10);
-
- // algorithme principal
-
- // REMARQUE : les faces sont numérotées mais ne sont pas construites ni stockées
-
- int flag_interm;
-
- // on parcourt en premier lieu le nuage de maille (linéaire, en Nombre de Maille)
-
- for (num_maille=0;num_maille<nbr_mailles;num_maille++)
- {
-
- // pour chaque maille, dite primaire, on parcourt ensuite ses faces (borné, par 8)
-
- for (num_local_face=0;num_local_face<(*mailles)[num_maille].DONNE_NBR_FACES();num_local_face++)
- {
- num_noeud=(*mailles)[num_maille].DONNE_PREMIER_NOEUD_DE_FACE(num_local_face);
- flag_existence=0;
- (*mailles)[num_maille].DONNE_FACE(num_local_face,sommets_face);
- flag_interm=0;
-
- // pour chaque face, dite primaire, on prend le premier noeud, et on parcourt les mailles qui contiennent ce noeud tant qu'on n'a pas trouvé de voisin
- // (borné, par un coefficient qui dépend de l'anisotropie du maillage, le nombre maximum de maille qui contient un sommet)
-
- for (ind_num_maille_sec=0;(flag_existence==0)&&(ind_num_maille_sec<mailles_contenant_noeud[num_noeud].size());ind_num_maille_sec++)
- {
- num_maille_sec=mailles_contenant_noeud[num_noeud][ind_num_maille_sec];
-
- // on teste ensuite si cette maille secondaire a un numéro plus élevé que la maille primaire, dans le cas contraire,
- // ça veut dire qu'elle a déja été traitée ou sera traitée ultérieurement
-
- if (num_maille_sec>num_maille)
- {
- flag_interm=1;
-
- // pour cette maille secondaire on regarde si elle contient la face primaire
- // (borné, par 8*4=32)
-
- num_loc=(*mailles)[num_maille_sec].DONNE_NUM_LOC_FACE_EGALE_A_FORMANT(sommets_face);
- if (num_loc>UNDEFINED)
- {
-
- // et dans ce cas, la maille secondaire est voisine de la maille primaire, on met à jour les tableaux
- // si on voulait construire le tableau des faces, c'est ici qu'il faudrait le faire -1-
-
- // MESSAGE("La maille "<<num_maille<<" a pour voisin la maille "<<num_maille_sec<<" via la face "<<nbr_formants);
- face_au_bord.push_back(FAUX);
- faces_contenues[num_maille][num_local_face]=nbr_formants;
- voisins_de_maille[num_maille][num_local_face]=num_maille_sec;
- faces_contenues[num_maille_sec][num_loc]=nbr_formants;
- voisins_de_maille[num_maille_sec][num_loc]=num_maille;
- flag_existence=1;
- nbr_formants++;
- }
- }
- }
- }
- }
-
- // Construction de la connexité des mailles de bord
- // A ce stade, on n'a que la connexité du voisinage des mailles, et les faces de bord n'ont pas été numérotées
-
- int ind_num_cont,test_bord,nbr_faces_bord=0;
-
- // on parcourt les mailles
-
- for (num_maille=0;num_maille<nbr_mailles;num_maille++)
- {
- test_bord=0;
-
- // on examine les faces de cette maille dans la numérotation globale faces_contenues
-
- for (ind_num_cont=0;ind_num_cont<faces_contenues[num_maille].size();ind_num_cont++)
- {
-
- // On regarde si tous les numéros globaux des faces sont définis
-
- if (faces_contenues[num_maille][ind_num_cont]==UNDEFINED)
- {
-
- // si un seul numéro n'est pas défini, la maille est au bord
- // si on voulait construire le tableau des faces, c'est ici qu'il faudrait le faire -2-
-
- // MESSAGE("La maille "<<num_maille<<" est au bord via sa face "<<ind_num_cont);
- test_bord=1;
- faces_contenues[num_maille][ind_num_cont]=nbr_formants;
- maille_au_bord[num_maille]=VRAI;
- face_au_bord.push_back(VRAI);
- nbr_faces_bord++;
- nbr_formants++;
- }
- }
-
- // dans le cas contraire, tous les numéros sont définis, la maille n'est pas au bord
-
- if (test_bord==0)
- {
- maille_au_bord[num_maille]=FAUX;
- }
- }
-
- // Vérification de la connectivité
- // on regarde si tous les numéros globaux sont définis
- // si ce n'est pas le cas, c'est que le nuage de maille est mal défini
-
-
- int verif=0;
- int nf,nbf=0;
- for (i=0;i<nbr_mailles;i++)
- {
- nf=0;
- for (j=0;j<faces_contenues[i].size();j++)
- {
- if (faces_contenues[i][j]==UNDEFINED) verif++;
- if (voisins_de_maille[i][j]==UNDEFINED) nf++;
- }
- if (maille_au_bord[i]==UNDEFINED) cerr<<"Maille "<<i<<" non completement construite"<<endl;
- if (nf==faces_contenues[i].size()) nbf++;
- }
-
-
- MESSAGE("IL Y A "<<verif<<" PROBLEMES A LA SUITE DE LA CONSTRUCTION DE CONNEXITE");
- MESSAGE("Nombre de mailles : "<<nbr_mailles);
- MESSAGE("Approximation du nombre de faces : "<<approx_nbr_formants);
- MESSAGE("Nombre réel de faces de bord : "<<nbr_faces_bord);
- MESSAGE("Nombre réel total de faces : "<<nbr_formants);
- MESSAGE("Nombre de Mailles Isolées : "<<nbf);
- }
-
-#endif
+++ /dev/null
-
-#ifndef MEDMEM_WRAPPER_NODES_HXX
-#define MEDMEM_WRAPPER_NODES_HXX
-
-#ifndef NULL
-#define NULL 0
-#endif
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// DECLARATIONS ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-/*********************************************************/
-/* */
-/* Classe Wrapper_Noeud */
-/* */
-/*********************************************************/
-
-template <int DIMENSION> class Wrapper_Noeud
-{
-protected :
- double * coordonnees;
-public :
- Wrapper_Noeud():coordonnees(NULL)
- {
- }
- Wrapper_Noeud(double * coord):coordonnees(coord)
- {
- }
- ~Wrapper_Noeud()
- {
- }
- void positionne(double *place)
- {
- coordonnees=place;
- }
- const double & operator[] (int i) const
- {
- return coordonnees[i];
- }
- double operator[] (int i)
- {
- return coordonnees[i];
- }
- friend double DistanceInf(const Wrapper_Noeud<DIMENSION> &A,const Wrapper_Noeud<DIMENSION> &B)
- {
- double max=0;
- double tmp;
- for (int i=0;i<DIMENSION;i++)
- {
- tmp=fabs(A[i]-B[i]);
- if (tmp>max) max=tmp;
- }
- return max;
- }
- friend double DistanceL2(const Wrapper_Noeud<DIMENSION> &A,const Wrapper_Noeud<DIMENSION> &B)
- {
- double tmp,somme=0;
- for (int i=0;i<DIMENSION;i++)
- {
- tmp=(A[i]-B[i]);
- somme+=tmp*tmp;
- }
- return sqrt(somme);
- }
- friend int operator==(const Wrapper_Noeud<DIMENSION> &A,const Wrapper_Noeud<DIMENSION> &B)
- {
- for (int i=0;i<DIMENSION;i++) if (A[i]!=B[i]) return 1;
- return 0;
- }
- friend ostream & operator<<(ostream &os,const Wrapper_Noeud<DIMENSION> &A)
- {
- os<<"( "<<flush;
- for (int i=0;i<DIMENSION;i++) os<<A[i]<<" "<<flush;
- os<<")"<<flush;
- return os;
- }
- };
-
-/*********************************************************/
-/* */
-/* Classe Nuage_Wrapper_Noeud */
-/* */
-/*********************************************************/
-
-
-template <int DIMENSION> class Wrapper_Nuage_Noeud
- {
- protected :
- int nbr_noeuds;
- double * noeuds;
- Wrapper_Noeud<DIMENSION> show;
- public :
- Wrapper_Nuage_Noeud():nbr_noeuds(0),noeuds(NULL) {}
- Wrapper_Nuage_Noeud(int nn, double *n):nbr_noeuds(nn),noeuds(n),show(noeuds) {}
- ~Wrapper_Nuage_Noeud() {}
- Wrapper_Noeud<DIMENSION> & operator [] (int i)
- {
- show.positionne((double *) &noeuds[DIMENSION*i]);
- return show;
- }
- int size() const {return nbr_noeuds;}
- int SIZE() const {return nbr_noeuds;}
- void affiche()
- {
- int i,j;
- for (i=0;i<nbr_noeuds;i++)
- {
- cout<<"Noeud "<<i<<" : "<<flush;
- for (j=0;j<DIMENSION;j++) cout<<noeuds[i*DIMENSION+j]<<" "<<flush;
- cout<<endl;
- }
- }
- };
-
-
-#endif
+++ /dev/null
-#ifndef MEDMEM_DTREE_HXX
-#define MEDMEM_DTREE_HXX
-
-#include "MEDMEM_dTreeSommet.hxx"
-
-#define DTREE_FANTOME -1
-#define DTREE_RACINE 0
-#define DTREE_TERMINAL 1
-#define DTREE_COURANT 2
-// etat_descendance
-#define DTREE_NON_CALCULE -1
-#define DTREE_AUCUNE 0
-#define DTREE_VALIDE 1
-// val min nbr noeud
-#define DTREE_NBR_MIN_NOEUDS 2
-#define DTREE_NBR_MAX_DESC 8
-// pour meilleu re lecture
-#define _TEMPLATE_ template <class NOEUD,class NUAGENOEUD,int DIMENSION,int NBR_NOEUDS_PAR_CASE>
-#define _DTREE_ dTree<NOEUD,NUAGENOEUD,DIMENSION,NBR_NOEUDS_PAR_CASE>
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// DECLARATIONS ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-/*********************************************************/
-/* */
-/* Calcul Statique de Puissance */
-/* */
-/*********************************************************/
-
-// Permet de Calculer 2^n de façon statique
-
-template < int DIMENSION > struct DeuxPuissance
- {
- enum { valeur = 2 * DeuxPuissance<DIMENSION-1>::valeur } ;
- };
-
-template <> struct DeuxPuissance<0>
- {
- enum { valeur = 1 } ;
- };
-
-/*********************************************************/
-/* */
-/* DTREE */
-/* */
-/*********************************************************/
-
-// Construit un d-Tree sur un nuage de noeud et pour un noeud donné donne lequel des noeuds du nuage est le plus proche
-
-// # Bugs connus :
-// - Problemes avec points sur les faces des hypercubes ?
-// - Plantage sauvage si le point est plus loin de l'hypercube père que le diametre Linf de celui-ci.
-// # Politique de classe :
-// - NOEUD : voir dans MEDMEM_WrapperNodes.hxx la classe Wrapper_Noeud<..>
-// - NUAGENOEUD : typiquement, c'est vector<NOEUD> en rédefinissant NUAGENOEUD<...>::SIZE()=vector<...>::size()
-// Remarques :
-// - NBR_NOEUDS_PAR_CASE ne doit pas être modifié sauf peut-être dans le cas où l'utilisateur veut utiliser des d-Tree parallèles
-// ou utilise des nuages de noeud trop grands
-
-template <class NOEUD,class NUAGENOEUD,int DIMENSION,int NBR_NOEUDS_PAR_CASE=DTREE_NBR_MIN_NOEUDS> class dTree
-{
-protected :
- // types
- typedef _DTREE_ * Ptr_dTree;
- // Static Const
- static const int nbr_descendants=DeuxPuissance<DIMENSION>::valeur;
- // champs
- NUAGENOEUD * nuage;
- Ptr_dTree descendant[nbr_descendants];
- // numéro des noeuds contenus
- vector<int> * noeud_contenu;
- int etat;
- int niveau;
- dTree * pere;
- // extrémités de l'hypercube du dTree
- Sommet_dTree<DIMENSION> coord_max;
- Sommet_dTree<DIMENSION> coord_min;
-public :
-
- void init();
- dTree();
- // Ce constructeur est le seul constructeur utilisateur, il construit le père puis tous les descendants
- dTree(NUAGENOEUD *n);
- // Ce Constructeur est utilisé par le précédent, pour un pere donné, avec deux extrémités données,
- // il instantie un dTree sans en calculer les noeuds contenus
- dTree(const Sommet_dTree<DIMENSION> &A,const Sommet_dTree<DIMENSION> &B,dTree *mypere);
- dTree(const dTree &F);
- ~dTree();
- // Renvoie les numéros de noeuds contenus dans le dTree
- void Get_Noeuds_Filtre(vector<int> &tmp);
- // renvoie les extrémités
- Sommet_dTree<DIMENSION> Get_Max() const;
- Sommet_dTree<DIMENSION> Get_Min() const;
- // renvoie vrai si P est dans le dTree
- int is_in_dTree(NOEUD P) const;
- // calcule la distance topologique locale de P au dTree
- double calcule_distance(NOEUD P) const;
- dTree & operator = (const dTree & F);
- // retourne le sommet du dTree codé par l'entier selecteur (voir explications dans le code)
- Sommet_dTree<DIMENSION> donne_sommet(int selecteur) const;
- int a_des_fils() const;
- // renvoi une reference sur le dTree terminal descendant de this contenant P
- dTree * trouve_dTree_contenant(NOEUD P) const;
- // renvoie le point le plus proche de P dans this par la méthode exhaustive brutale
- int trouve_plus_proche_point_bourrin(NOEUD P) const;
- // renvoie le point le plus proche de p dans this par la méthode dtree
- int trouve_plus_proche_point(NOEUD P) const;
- // renvoie un numéro de point contenu dans this
- int trouve_un_point() const;
- // méthode récursive utilisée par trouve_plus_proche_point
- int tppp_rec(NOEUD P,double &delta,int &flag) const;
- // dit si P est d-proche de l'hypercube de this
- int Localise_Point(NOEUD P,double d) const;
- // utilisé par le constructeur pour créer tout la filiation du dTree
- void cree_filiation();
- // méthodes de mesure
- int Get_Nbr_Descendants_Non_Vides() const;
- int Get_Nbr_Descendants_Vides() const;
- int Get_Profondeur_Max() const;
-};
-
-
-//////////////////////////////////////////////////////////////////
-/// ///
-/// CODE ///
-/// ///
-//////////////////////////////////////////////////////////////////
-
-_TEMPLATE_ void _DTREE_::init()
- {
- int i;
- nuage=NULL;
- noeud_contenu=NULL;
- etat=DTREE_FANTOME;
- for (i=0;i<nbr_descendants;i++) descendant[i]=NULL;
- niveau=-1;
- pere=NULL;
- }
-_TEMPLATE_ _DTREE_::dTree()
- {
- init();
- coord_max=0.0;
- coord_min=0.0;
- }
-_TEMPLATE_ _DTREE_::dTree(NUAGENOEUD *n)
- {
- int i,j;
- double tmp;
-
- if (n==NULL)
- {
- cerr<<"DTREE : Nuage vide !"<<endl;
- exit(-1);
- }
-
- init();
- nuage=n;
- etat=DTREE_RACINE;
- noeud_contenu=new vector<int>(nuage->size());
- niveau=0;
-
- // calcule les extrémités du dTree pere
- for (i=0;i<DIMENSION;i++)
- {
- coord_max[i]=(*nuage)[0][i];
- coord_min[i]=(*nuage)[0][i];
- }
- (*noeud_contenu)[0]=0;
- for (i=1;i<nuage->size();i++)
- {
- (*noeud_contenu)[i]=i;
- for (j=0;j<DIMENSION;j++)
- {
- if ((*nuage)[i][j]>coord_max[j]) coord_max[j]=(*nuage)[i][j];
- if ((*nuage)[i][j]<coord_min[j]) coord_min[j]=(*nuage)[i][j];
- }
- }
- for (j=0;j<DIMENSION;j++)
- {
- tmp=(coord_max[j]-coord_min[j])*0.01;
- coord_max[j]+=tmp;
- coord_min[j]-=tmp;
- }
-
- // méthode récursive qui construit la filiation
- cree_filiation();
-
- }
-_TEMPLATE_ _DTREE_::dTree(const Sommet_dTree<DIMENSION> &A,const Sommet_dTree<DIMENSION> &B,dTree *mypere)
- {
- if (mypere!=NULL)
- {
-
- int i,j;
- double tmp;
-
- init();
-
- pere=mypere;
- nuage=pere->nuage;
- niveau=pere->niveau+1;
-
- etat=DTREE_COURANT;
-
- noeud_contenu=new vector<int>;
- noeud_contenu->reserve((pere->noeud_contenu->size())/nbr_descendants);
-
- for (i=0;i<DIMENSION;i++)
- {
- coord_max[i]=(*nuage)[0][i];
- coord_min[i]=(*nuage)[0][i];
- }
-
- for (i=0;i<DIMENSION;i++)
- {
- if (A[i]>B[i])
- {
- coord_max[i]=A[i];
- coord_min[i]=B[i];
- }
- else
- {
- coord_min[i]=A[i];
- coord_max[i]=B[i];
- }
- }
- }
- else
- {
- cerr<<"DTREE : Construction de descendance sans père !"<<endl;
- exit(-1);
- }
- }
-_TEMPLATE_ _DTREE_::dTree(const _DTREE_ &F)
- {
- // Pas Super Top Moumoute ... Recopie de pointeurs et pas de contenus, merdique
- int i,j;
- init();
- for (i=0;i<nbr_descendants;i++) descendant[i]=F.descendant[i];
- noeud_contenu=F.noeud_contenu;
- etat=F.etat;
- niveau=F.niveau;
- pere=F.pere;
- coord_max=F.coord_max;
- coord_min=F.coord_min;
- }
-_TEMPLATE_ _DTREE_::~dTree()
- {
- int i;
- nuage=NULL;
- pere=NULL;
- // cout<<*this<<endl;
- if (noeud_contenu)
- {
- delete noeud_contenu;
- }
- for (i=0;i<nbr_descendants;i++) if (descendant[i])
- {
- delete descendant[i];
- }
- }
-_TEMPLATE_ void _DTREE_::Get_Noeuds_Filtre(vector<int> &tmp)
- {
- int i;
- switch (etat)
- {
- case DTREE_RACINE : int pourlefunlecompilolesttropcon;
- case DTREE_COURANT :
- for (i=0;i<nbr_descendants;i++) descendant[i]->Get_Noeuds_Filtre(tmp);
- case DTREE_TERMINAL :
- if (noeud_contenu->size()>0)
- {
- for (i=0;i<NBR_NOEUDS_PAR_CASE;i++) tmp.push_back((*noeud_contenu)[i]);
- }
- default :
- cerr<<"DTREE : dTree Non Valide dans Rempli_Noeuds_Filtre"<<endl;
- exit(-1);
- }
- }
-_TEMPLATE_ Sommet_dTree<DIMENSION> _DTREE_::Get_Max() const
- {
- return coord_max;
- }
-_TEMPLATE_ Sommet_dTree<DIMENSION> _DTREE_::Get_Min() const
- {
- return coord_min;
- }
-_TEMPLATE_ int _DTREE_::is_in_dTree(NOEUD P) const
- {
- int test;
- for (int i=0;i<DIMENSION;i++)
- {
- test=((coord_min[i]<=P[i])&&(P[i]<=coord_max[i]));
- if (!test) return 0;
- }
- return 1;
-
- }
-// calcule la distance Linf d'un point exterieur, si le point est interieur, le resultat sera erroné
-_TEMPLATE_ double _DTREE_::calcule_distance(NOEUD P) const
- {
- double min=fabs(coord_max[0]-P[0]);
- double tmp;
- int i;
- for (i=0;i<DIMENSION;i++)
- {
- tmp=fabs(coord_max[i]-P[i]);
- if (min>tmp) min=tmp;
- tmp=fabs(coord_min[i]-P[i]);
- if (min>tmp) min=tmp;
- }
- return min;
- }
-_TEMPLATE_ _DTREE_ & _DTREE_::operator = (const _DTREE_ & F)
- {
- // Pas Super Top Moumoute ... Recopie de pointeurs et pas de contenus, merdique
- int i,j;
- init();
- for (i=0;i<nbr_descendans;i++) descendant[i]=F.descendant[i];
- noeud_contenu=F.noeud_contenu;
- etat=F.etat;
- niveau=F.niveau;
- pere=F.pere;
- coord_max=F.coord_max;
- coord_min=F.coord_min;
- }
-// selecteur doit etre lu comme un nombre en base 2
-// il specifie les coordonnes de reference du sommet dont on veut les coordonnees reelles
-// ex : en dim 3 : coord_min=0+0*2+0*4=0
-// coord_max=1+1*2*1*4=7
-// donc les unites pour x, les 2aines pour y, les 4aines pour z
-_TEMPLATE_ Sommet_dTree<DIMENSION> _DTREE_::donne_sommet(int selecteur) const
- {
- Sommet_dTree<DIMENSION> p;
- int i;
- int residu=selecteur;
- int reste;
- for (i=0;i<DIMENSION;i++)
- {
- reste=residu%2;
- if (reste==0) p[i]=coord_min[i]; else p[i]=coord_max[i];
- residu=(residu-reste)/2;
- }
- return p;
- }
-_TEMPLATE_ int _DTREE_::a_des_fils() const
- {
- if ((etat==DTREE_COURANT)||(etat=DTREE_RACINE)) return 1;
- else return 0;
- }
-_TEMPLATE_ _DTREE_ * _DTREE_::trouve_dTree_contenant(NOEUD P) const
- {
- Sommet_dTree<DIMENSION> B(coord_min,coord_max);
- int i;
- if ((etat==DTREE_RACINE)&&(!is_in_dTree(P))) return NULL; // Le noeud est extérieur a l'dTree
- else if (etat==DTREE_TERMINAL) return (dTree *) this; // Le noeud est dans *this qui est terminal
-
- for (i=0;i<nbr_descendants;i++)
- {
- Sommet_dTree<DIMENSION> A=donne_sommet(i);
- int test,j;
- for (j=0;j<DIMENSION;j++)
- {
- if (A[j]<=B[j]) test=((A[j]<=P[j])&&(P[j]<=B[j]));
- else test=((A[j]>=P[j])&&(P[j]>=B[j]));
- if (!test) break;
- }
-
- if (test) return descendant[i]->trouve_dTree_contenant(P); // Propagation
- }
- }
-// si de le dTree n'est pas TERMINAL, scanne tous les points du nuage du pere pour trouver le point le plus proche
-// sinon scanne uniquement les points contenus dans le dTree
-_TEMPLATE_ int _DTREE_::trouve_plus_proche_point_bourrin(NOEUD P) const
- {
- int i;
- int num_sol=0;
- double min;
- double tmp;
- if (etat!=DTREE_TERMINAL)
- {
- min=DistanceL2(P,(*nuage)[0]);
- for (i=1;i<nuage->size();i++)
- {
- tmp=DistanceL2(P,(*nuage)[i]);
- if (tmp<min)
- {
- num_sol=i;
- min=tmp;
- }
- }
- return num_sol;
- }
- else
- {
- if (noeud_contenu->size()!=0)
- {
- num_sol=(*noeud_contenu)[0];
- min=DistanceL2(P,(*nuage)[num_sol]);
- for (i=1;i<noeud_contenu->size();i++)
- {
- tmp=DistanceL2(P,(*nuage)[(*noeud_contenu)[i]]);
- if (tmp<min)
- {
- num_sol=(*noeud_contenu)[i];
- min=tmp;
- }
- }
- return num_sol;
- }
- else return DTREE_FANTOME;
- }
- }
-// Fonction de pilotage de la recursion, lance les tests preliminaires et invoque la recursion
-_TEMPLATE_ int _DTREE_::trouve_plus_proche_point(NOEUD P) const
- {
-
- if (etat==DTREE_FANTOME)
- {
- cerr<<"DTREE : TROUVE PLUS PROCHE POINT : L'octree n'est pas construit !"<<endl;
- exit(-1);
- }
- dTree *ref=trouve_dTree_contenant(P);
- double delta;
-
- if (ref!=NULL)
- {
- // Le point est intérieur
-
- if (ref->pere!=NULL)
- {
- delta=DistanceInf((ref->pere->coord_max),(ref->pere->coord_min));
- }
- else
- {
- cerr<<"DTREE : TROUVE PLUS PROCHE POINT : l'octree contenant le noeud n'a pas de pere !"<<endl;
- exit(-1);
- }
- }
- else
- {
- // Le point est extérieur
-
- delta=DistanceL2(P,(*nuage)[0]);
- }
-
- int flag=0;
- int retour;
-
- retour=tppp_rec(P,delta,flag);
-
- return retour;
- }
-_TEMPLATE_ int _DTREE_::trouve_un_point() const
- {
- if (noeud_contenu!=NULL)
- {
- if (noeud_contenu->size()>0) return (*(noeud_contenu))[0];
- }
- else
- {
- int i;
- for (i=0;i<nbr_descendants;i++)
- {
- return descendant[i]->trouve_un_point();
- }
- }
- }
-// partie recursive de trouve_plus_proche_point
-// change le flag en 1 si un point plus proche est trouvé
-// adapte automatiquement la distance delta de filtrage
-_TEMPLATE_ int _DTREE_::tppp_rec(NOEUD P,double &delta,int &flag) const
- {
- if (Localise_Point(P,delta)==0)
- {
-
- // La distance du point à l'octree est plus grande que delta
-
- return DTREE_FANTOME;
- }
- int num_Ptmp;
- double dtmp;
- if (etat==DTREE_TERMINAL)
- {
- if (noeud_contenu->size()>0)
- {
- num_Ptmp=trouve_plus_proche_point_bourrin(P);
- dtmp=DistanceL2((*nuage)[num_Ptmp],P);
- if (dtmp<=delta)
- {
-
- // Le point le plus proche minimise delta, c'est un bon candidat, on l'envoie !
-
- delta=dtmp;
- flag=1;
- return num_Ptmp;
- }
-
- // Le point le plus proche ne minimise pas delta
-
- // ===========> peut etre rajouter exit(-1); ??????????
- return DTREE_FANTOME;
- }
- else
- {
-
- // L'octree qui contient P ne contient aucun point
-
- return DTREE_FANTOME;
- }
- }
- int i;
- int num_sol=DTREE_FANTOME;
- for (i=0;i<nbr_descendants;i++)
- {
- num_Ptmp=descendant[i]->tppp_rec(P,delta,flag);
- if ((num_Ptmp!=DTREE_FANTOME)&&(flag==1))
- {
-
- // On a trouvé un point qui minimise delta dans une branche
-
- num_sol=num_Ptmp;
- }
- }
- // A ce stade, on a trouvé un point qui minimise tous les deltas, c'est donc le point le plus proche
- // REMARQUE : cette affirmation est à la base de l'algorithme par dTree mais est loin d'étre évidente
-
- return num_sol;
- }
-
-// renvoie 1 si la distance L inf du noeud a l'octree est plus petite que d, 0 sinon
-_TEMPLATE_ int _DTREE_::Localise_Point(NOEUD P,double d) const
- {
- int i;
- for (i=0;i<DIMENSION;i++)
- {
- if (P[i]>coord_max[i]+d) return 0;
- if (P[i]<coord_min[i]-d) return 0;
- }
- return 1;
- }
-
-// Méthode de construction du dTree par propagation
-_TEMPLATE_ void _DTREE_::cree_filiation()
- {
- if (etat!=DTREE_RACINE)
- {
- niveau=pere->niveau+1;
- }
- else
- {
- niveau=0;
- }
-
- if (noeud_contenu->size()<=NBR_NOEUDS_PAR_CASE)
- {
- etat=DTREE_TERMINAL;
- }
- else
- {
- int i,num_loc,test;
-
- Sommet_dTree<DIMENSION> centre(coord_max,coord_min);
-
- for (i=0;i<nbr_descendants;i++)
- {
- descendant[i]=new dTree(centre,donne_sommet(i),this);
- }
-
- for (num_loc=0;num_loc<noeud_contenu->size();num_loc++)
- {
- int indice=(*noeud_contenu)[num_loc];
- NOEUD & courant=(*nuage)[indice];
- test=1;
- for (i=0;(test)&&(i<nbr_descendants);i++)
- {
- if (descendant[i]->is_in_dTree(courant))
- {
- descendant[i]->noeud_contenu->push_back(indice);
- test=0;
- }
- }
- }
-
- delete noeud_contenu;
- noeud_contenu=NULL;
-
- for (i=0;i<nbr_descendants;i++) descendant[i]->cree_filiation();
- }
- }
-_TEMPLATE_ int _DTREE_::Get_Nbr_Descendants_Non_Vides() const
- {
- int i;
- int ndnv=0;
- switch (etat)
- {
- case DTREE_RACINE : int pourlefunlecompilolesttropcon;
- case DTREE_COURANT :
- for (i=0;i<nbr_descendants;i++) ndnv+=descendant[i]->Get_Nbr_Descendants_Non_Vides();
- return ndnv;
- case DTREE_TERMINAL :
- if (noeud_contenu->size()>0) return 1;
- else return 0;
- default :
- cerr<<"dTree Non Valide dans Get_Nbr_Descendants_Non_Vides"<<endl;
- return -1;
- }
- }
-_TEMPLATE_ int _DTREE_::Get_Nbr_Descendants_Vides() const
- {
- int i;
- int ndnv=0;
- switch (etat)
- {
- case DTREE_RACINE : int pourlefunlecompilolesttropcon;
- case DTREE_COURANT :
- for (i=0;i<nbr_descendants;i++) ndnv+=descendant[i]->Get_Nbr_Descendants_Vides();
- return ndnv;
- case DTREE_TERMINAL :
- if (noeud_contenu->size()==0) return 1;
- else return 0;
- default :
- cerr<<"dTree Non Valide dans Get_Nbr_Descendants_Non_Vides"<<endl;
- return -1;
- }
- }
-_TEMPLATE_ int _DTREE_::Get_Profondeur_Max() const
- {
- int i;
- int prof=0;
- int tmp;
- switch (etat)
- {
- case DTREE_RACINE : int pourlefunlecompilolesttropcon;
- case DTREE_COURANT :
- for (i=0;i<nbr_descendants;i++)
- {
- tmp=descendant[i]->Get_Profondeur_Max();
- if (tmp>prof) prof=tmp;
- }
- return prof;
- case DTREE_TERMINAL : return niveau;
- default :
- cerr<<"dTree Non Valide dans Get_Nbr_Descendants_Non_Vides"<<endl;
- return -1;
- }
- }
-
-#undef _TEMPLATE_
-#undef _DTREE_
-
-
-#endif
+++ /dev/null
-#ifndef SOMMET_HPP
-#define SOMMET_HPP
-
-
-// La classe qui suit sert UNIQUEMENT pour les sommets du dTree
-
-template <int DIMENSION> class Sommet_dTree
-{
-protected :
- double coord[DIMENSION];
-public :
- Sommet_dTree()
- {
- }
- Sommet_dTree(double *c)
- {
- for (int i=0;i<DIMENSION;i++) coord[i]=c[i];
- }
- Sommet_dTree(double c)
- {
- for (int i=0;i<DIMENSION;i++) coord[i]=c;
- }
- Sommet_dTree(const Sommet_dTree & SO)
- {
- for (int i=0;i<DIMENSION;i++) coord[i]=SO.coord[i];
- }
- Sommet_dTree(const Sommet_dTree &s1,const Sommet_dTree &s2)
- {
- for (int i=0;i<DIMENSION;i++) coord[i]=0.5*(s1[i]+s2[i]);
- }
- ~Sommet_dTree()
- {
- }
- const double operator[](int i) const
- {
- return coord[i];
- }
- double & operator[](int i)
- {
- return coord[i];
- }
- Sommet_dTree & operator=(const Sommet_dTree &f)
- {
- for (int i=0;i<DIMENSION;i++) coord[i]=f.coord[i];return *this;
- }
- friend double DistanceInf(const Sommet_dTree<DIMENSION> &A,const Sommet_dTree<DIMENSION> &B)
- {
- double max=0;
- double tmp;
- for (int i=0;i<DIMENSION;i++)
- {
- tmp=fabs(A[i]-B[i]);
- if (tmp>max) max=tmp;
- }
- return max;
- }
-};
-
-#endif
+++ /dev/null
-# MED MEDMEM : MED files in memory
-#
-# Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library 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
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
-#
-#
-#
-# File : Makefile.in
-# Module : MED
-
-top_srcdir=@top_srcdir@
-top_builddir=../../..
-srcdir=@srcdir@
-VPATH=.:$(srcdir):$(srcdir)/tests
-
-MACHINE=PCLINUX
-
-@COMMENCE@
-
-
-EXPORT_PYSCRIPTS = \
-
-
-EXPORT_HEADERS = \
-MEDMEM_dTree.hxx\
-MEDMEM_dTreeSommet.hxx\
-MEDMEM_InterpolationHighLevelObjects.hxx\
-MEDMEM_Interpolation.hxx\
-MEDMEM_InterpolationTools.hxx\
-MEDMEM_Mapping.hxx\
-MEDMEM_MappingTools.hxx\
-MEDMEM_WrapperCells.hxx\
-MEDMEM_WrapperConnectivity.hxx\
-MEDMEM_WrapperField.hxx\
-MEDMEM_WrapperMesh.hxx\
-MEDMEM_WrapperNodes.hxx
-
-
-# Libraries targets
-
-LIB=
-LIB_SRC =
-
-
-# Executables targets
-BIN =
-BIN_SRC =
-BIN_SERVER_IDL =
-BIN_CLIENT_IDL =
-
-TEST_PROGS = \
-test_MEDMEM_InterpolationFlipBack\
-test_MEDMEM_InterpolationFromMesh_toMesh\
-test_MEDMEM_InterpolationRecopieMaillage\
-test_MEDMEM_InterpolationSansRecopieMaillage\
-test_MEDMEM_InterpolationTimeStep\
-UseCasedTree\
-UseCaseInterpolationts\
-UseCaseInterpolationwots\
-UseCaseMapping\
-UseCaseWrapper_Maillage
-
-
-
-
-CPPFLAGS+=-U_DEBUG_ $(MED2_INCLUDES) $(HDF5_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome -I../
-CXXFLAGS+=-U_DEBUG_ -ftemplate-depth-42 -I${KERNEL_ROOT_DIR}/include/salome
-LDFLAGS+=$(MED2_LIBS) $(HDF5_LIBS) -lSalomeLoggerServer -L${KERNEL_ROOT_DIR}/lib/salome
-
-LDFLAGSFORBIN+=$(MED2_LIBS) $(HDF5_LIBS) -L../.libs -lmedmem -lSalomeLoggerServer -L${KERNEL_ROOT_DIR}/lib/salome
-
-LIBSFORBIN=
-
-LDFLAGS=
-
-LIBS=
-
-# build create_mesh :
-bin: create_mesh_interpolation
-
-create_mesh_interpolation: %: %.c
- $(CC) $(CFLAGS) $(CPPFLAGS) -o $@ $(MED2_LIBS) $(HDF5_LIBS) $<
-
-@CONCLUDE@
+++ /dev/null
-#include "MEDMEM_Exception.hxx"
-#include "MEDMEM_define.hxx"
-
-#include "MEDMEM_Med.hxx"
-#include "MEDMEM_Field.hxx"
-#include "MEDMEM_Mesh.hxx"
-#include "MEDMEM_Interpolation.hxx"
-
-#include <deque>
-
-#include "stdio.h"
-
-main () {
-
- const char * fromFileName = "ResultatSyrthes.med";
- const char * toFileName = "MaillageAster.med";
- const char * resultFileName = "ResultatInterpolation.med";
-
- const char * fromFieldName = "THERDEP_TEMP____________________";
-
- const char * fromMeshName = "MA";
- const char * toMeshName = "MAILLAGE_IDEAS";
- int handle;
-
- try {
-
-
- MED fromMED(MED_DRIVER,fromFileName);
-
- fromMED.updateSupport();
-
- MESH toMesh(MED_DRIVER,toFileName,toMeshName);
-
- deque<DT_IT_> pasDeTemps=fromMED.getFieldIteration (fromFieldName);
-
- deque<DT_IT_>::const_iterator currentStep;
-
- INTERPOLATION<3> * myInter ;
- FIELD<double> * toField ;
- int flagNewMapping = 1;
-
- for (currentStep=pasDeTemps.begin();currentStep!=pasDeTemps.end();currentStep++)
- {
- FIELD_ * fromField_ = fromMED.getField(fromFieldName,(*currentStep).dt,(*currentStep).it) ;
-
- FIELD<double> * fromField = dynamic_cast<FIELD<double> *>(fromField_);
-
- fromField->getSupport()->getMesh()->read();
-
- fromField->read();
-
- if (currentStep==pasDeTemps.begin())
- {
- myInter = new INTERPOLATION<3>(*fromField,toMesh) ;
-
- toField = myInter->interpolate(1,1);
- }
- else
- {
- toField = myInter->interpolateNextStep(*fromField,flagNewMapping);
- }
-
- toField->addDriver(MED_DRIVER,resultFileName,toField->getName());
-
- toField->write();
-
- if (flagNewMapping==1)
- {
- handle = toMesh.addDriver(MED_DRIVER,resultFileName,toMesh.getName()) ;
-
- toMesh.write(handle);
- }
- }
-
- } catch (MEDEXCEPTION& ex){
- MESSAGE(ex.what()) ;
- }
-}
+++ /dev/null
-#include "MEDMEM_Exception.hxx"
-#include "MEDMEM_define.hxx"
-
-#include "MEDMEM_Field.hxx"
-#include "MEDMEM_Mesh.hxx"
-#include "MEDMEM_Interpolation.hxx"
-
-#include "stdio.h"
-
-using namespace MEDMEM;
-
-main () {
-
- const char * fromFileName = "fromMesh.med";
- const char * toFileName = "toMesh.med";
- const char * fieldName = "fieldnodedouble";
-
- const char * fromMeshName = "fromMesh";
- const char * toMeshName = "toMesh";
-
- const int flagConvex = 1;
- const int interpolationType = 1;
-
- try {
-
- MESH fromMesh (MED_DRIVER,fromFileName,fromMeshName);
- SUPPORT fromSupport (&fromMesh,"XsupportX",MED_NODE);
- FIELD<double> fromField (&fromSupport,MED_DRIVER,fromFileName,fieldName);
- MESH toMesh (MED_DRIVER,toFileName,toMeshName);
-
- INTERPOLATION<3> myInter (fromField,toMesh);
-
- FIELD<double> * toField = myInter.interpolate(interpolationType,flagConvex);
-
- toField->addDriver(MED_DRIVER,toFileName,toField->getName()) ;
-
- toField->write();
-
-
- } catch (MEDEXCEPTION& ex){
- MESSAGE(ex.what()) ;
- }
-}
+++ /dev/null
-#include "stdio.h"
-#include "stdlib.h"
-
-#include <iostream.h>
-
-#include "MEDMEM_InterpolationHighLevelObjects.hxx"
-
-int main (void)
-{
-int i;
-
-const int DIMENSION = 3;
-
-const int isConvexFromMesh = 1;
-
-const char * fromFileName = "fromMesh.med";
-const char * fromMeshName = "fromMesh";
-
-MESH * fromMesh = new MESH(MED_DRIVER,fromFileName,fromMeshName);
-
-const char * toFileName = "toMesh.med";
-const char * toMeshName = "toMesh";
-
-MESH * toMesh = new MESH(MED_DRIVER,toFileName,toMeshName);
-
-Meta_Wrapper<DIMENSION> * fromWrapper = new Meta_Wrapper<DIMENSION>
- (
- fromMesh->getNumberOfNodes(),
- const_cast<double *> (fromMesh->getCoordinates(MED_FULL_INTERLACE)),
- const_cast<CONNECTIVITY *> (fromMesh->getConnectivityptr())
- );
-
-Meta_Wrapper<DIMENSION> * toWrapper = new Meta_Wrapper<DIMENSION>
- (
- toMesh->getNumberOfNodes(),
- const_cast<double *> (toMesh->getCoordinates(MED_FULL_INTERLACE))
- );
-
-Meta_Mapping<DIMENSION> * mapping = new Meta_Mapping<DIMENSION> (fromWrapper,toWrapper);
-
-mapping->Cree_Mapping(isConvexFromMesh);
-
-vector<int> vectormapping = mapping->Get_Mapping();
-
-for (i=0;i<vectormapping.size();i++)
- {
- cout<<"Le noeud "<<i<<" de "<<toMeshName<<" est contenu dans la maille "<<vectormapping[i]<<" de "<<fromMeshName<<endl;
- }
-
-}
+++ /dev/null
-#include "stdio.h"
-#include "stdlib.h"
-
-#include <iostream.h>
-
-#include "MEDMEM_InterpolationHighLevelObjects.hxx"
-
-int main (void)
-{
-int i,j;
-
-const char * fromFileName = "fromMesh.med";
-const char * fromMeshName = "fromMesh";
-
-MESH fromMesh(MED_DRIVER,fromFileName,fromMeshName);
-
-Meta_Nuage_Maille * nuagemailles = new Meta_Nuage_Maille(const_cast<CONNECTIVITY *> (fromMesh.getConnectivityptr()));
-
-int nbr_noeuds = fromMesh.getNumberOfNodes();
-
-Meta_Maillage * maillage = new Meta_Maillage(nuagemailles,nbr_noeuds);
-
-int nbr_mailles = maillage->DONNE_POINTEUR_NUAGEMAILLE()->SIZE();
-
-int nbr_faces;
-
-for (i=0;i<nbr_mailles;i++)
- {
- cout<<"Voisins de la maille "<<i<<" : "<<flush;
- nbr_faces=maillage->DONNE_NBR_FACES_MAILLE(i);
- for (j=0;j<nbr_faces;j++) cout<<"["<<maillage->DONNE_VOISIN_DE_MAILLE(i,j)<<"]-("<<maillage->EST_AU_BORD_FACE_DE_MAILLE(i,j)<<") "<<flush;
- cout<<endl;
- }
-
-}
-
+++ /dev/null
-#include "stdio.h"
-#include "stdlib.h"
-
-#include <iostream.h>
-
-#include "MEDMEM_InterpolationHighLevelObjects.hxx"
-
-#define affiche(NOEUD) cout<<flush;for (int iii=0;iii<DIMENSION;iii++) cout<<NOEUD[iii]<<" "<<flush;
-
-int main (void)
-{
-int i;
-
-const int DIMENSION = 3;
-const int NBR_NOEUDS = 8;
-const int NBR_INC = 3;
-
-double noeuds[DIMENSION*NBR_NOEUDS] = { 0,0,0,
- 1,0,0,
- 0,1,0,
- 0,0,1,
- 1,1,0,
- 1,0,1,
- 0,1,1,
- 1,1,1 };
-
-double noeuds_inconnus[DIMENSION*NBR_INC] = { 2 ,2 ,2 ,
- 0.2,0.2,0.2,
- 0 ,0.9,0.9 };
-
-double * tmp1, * tmp2;
-
-for (i=0;i<NBR_NOEUDS;i++)
- {
- cout<<"Noeud["<<i<<"] = ";
- tmp1=&noeuds[DIMENSION*i];
- affiche(tmp1);
- cout<<endl;
- }
-
-Meta_dTree<DIMENSION> Octree(NBR_NOEUDS,noeuds);
-
-for (i=0;i<NBR_INC;i++)
- {
- cout<<"Noeud le plus proche de ";
- tmp1=&noeuds_inconnus[DIMENSION*i];
- affiche(tmp1);
- cout<<" : ";
- tmp2=&noeuds[DIMENSION*Octree.trouve_plus_proche_point(tmp1)];
- affiche(tmp2);
- cout<<" ; Vérification par méthode bourrin : ";
- tmp2=&noeuds[DIMENSION*Octree.trouve_plus_proche_point_bourrin(tmp1)];
- affiche(tmp2);
- cout<<endl;
- }
-
-}
-
+++ /dev/null
-#include <med.h>
-#include <string.h>
-
-#define MED_NOPG 1 /* -> pas de point de Gauss */
-#define MED_NOPFL "" /* -> pas de profils utilisateur */
-#define MED_NOPFLi " " /* Variable Interne */
-#define MED_NOPF 0 /* -> pas de profils pour _MEDdataseNnumEcrire */
-#define MED_NOPDT -1 /* rem: pas de pas de temps negatifs */
-#define MED_NONOR -1 /* rem: pas de n°ordre negatif */
-#define MED_DIM1 1 /* PAS */
-
-#define MED_ALL 0
-
-/*****************************************************************************************************/
-
-void affiche_noeuds(med_float * nodes,int nnpl)
- {
- int nbr_nodes=nnpl*nnpl*nnpl;
- int i;
-
- for (i=0;i<nbr_nodes;i++) printf("Noeud %d : ( %4.5f ; %4.5f ; %4.5f )\n",i,nodes[3*i],nodes[3*i+1],nodes[3*i+2]);
-
- }
-
-
-void cree_nodes(med_float * coord_nodes,int nnpl, int flag)
- {
- int i,j,k;
- int nbr_nodes=nnpl*nnpl*nnpl;
- int num_noeud;
- int diviseur=nnpl-1+flag;
-
- /*coord_nodes=(med_float *) malloc(3*nbr_nodes*sizeof(med_float));*/
-
- for (i=0;i<nnpl;i++) for (j=0;j<nnpl;j++) for (k=0;k<nnpl;k++)
- {
- num_noeud=i+nnpl*j+nnpl*nnpl*k;
-
- if (3*num_noeud >=3*nbr_nodes) {printf("%d : OUT OF RANGE REQUEST\n",num_noeud);exit(-1);}
- if (3*num_noeud+1>=3*nbr_nodes) {printf("%d : OUT OF RANGE REQUEST\n",num_noeud);exit(-1);}
- if (3*num_noeud+2>=3*nbr_nodes) {printf("%d : OUT OF RANGE REQUEST\n",num_noeud);exit(-1);}
-
- coord_nodes[3*num_noeud ]= (double) (i+flag)/diviseur;
- coord_nodes[3*num_noeud+1]= (double) (j+flag)/diviseur;
- coord_nodes[3*num_noeud+2]= (double) (k+flag)/diviseur;
- }
-
- affiche_noeuds(coord_nodes,nnpl);
-
- }
-void cree_num_nodes(med_int * num_nodes,int nnpl)
- {
- int nbr_nodes=nnpl*nnpl*nnpl;
- int i;
- /*num_nodes=(med_int *) malloc(nbr_nodes*sizeof(med_int));*/
- for (i=0;i<nbr_nodes;i++) num_nodes[i]=i+1;//nbr_nodes+i;
- }
-void cree_Hexa8(med_int * conn_hexa8, int nnpl,med_int * num_nodes)
- {
- int i,j,k;
- int i0,j0,k0,i1,j1,k1;
- int nbr_nodes=nnpl*nnpl*nnpl;
- int nbr_hexa8=(nnpl-1)*(nnpl-1)*(nnpl-1);
- int num_hexa8;
-
- /*conn_hexa8=(med_int *) malloc(8*nbr_hexa8*sizeof(med_int));*/
-
- for (i=0;i<nnpl-1;i++) for (j=0;j<nnpl-1;j++) for (k=0;k<nnpl-1;k++)
- {
- i0=i;j0=j;k0=k;
- i1=i+1;j1=j+1;k1=k+1;
-
- num_hexa8=i+(nnpl-1)*j+(nnpl-1)*(nnpl-1)*k;
-
- if (8*num_hexa8 >=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
- if (8*num_hexa8+1>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
- if (8*num_hexa8+2>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
- if (8*num_hexa8+3>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
- if (8*num_hexa8+4>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
- if (8*num_hexa8+5>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
- if (8*num_hexa8+6>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
- if (8*num_hexa8+7>=8*nbr_hexa8) {printf("%d : OUT OF RANGE REQUEST\n",num_hexa8);exit(-1);}
-
- conn_hexa8[8*num_hexa8 ] = num_nodes[ i0+nnpl*j1+nnpl*nnpl*k1 ];
- conn_hexa8[8*num_hexa8+1] = num_nodes[ i0+nnpl*j0+nnpl*nnpl*k1 ];
- conn_hexa8[8*num_hexa8+2] = num_nodes[ i1+nnpl*j0+nnpl*nnpl*k1 ];
- conn_hexa8[8*num_hexa8+3] = num_nodes[ i1+nnpl*j1+nnpl*nnpl*k1 ];
- conn_hexa8[8*num_hexa8+4] = num_nodes[ i0+nnpl*j1+nnpl*nnpl*k0 ];
- conn_hexa8[8*num_hexa8+5] = num_nodes[ i0+nnpl*j0+nnpl*nnpl*k0 ];
- conn_hexa8[8*num_hexa8+6] = num_nodes[ i1+nnpl*j0+nnpl*nnpl*k0 ];
- conn_hexa8[8*num_hexa8+7] = num_nodes[ i1+nnpl*j1+nnpl*nnpl*k0 ];
-
-
- }
-
- for (num_hexa8=0;num_hexa8<nbr_hexa8;num_hexa8++)
- {
- printf("Maille numéro %4d :",num_hexa8);
- printf("%4d ",conn_hexa8[8*num_hexa8 ]);
- printf("%4d ",conn_hexa8[8*num_hexa8+1]);
- printf("%4d ",conn_hexa8[8*num_hexa8+2]);
- printf("%4d ",conn_hexa8[8*num_hexa8+3]);
- printf("%4d ",conn_hexa8[8*num_hexa8+4]);
- printf("%4d ",conn_hexa8[8*num_hexa8+5]);
- printf("%4d ",conn_hexa8[8*num_hexa8+6]);
- printf("%4d ",conn_hexa8[8*num_hexa8+7]);
- printf("\n");
- }
- }
-void cree_noms_mailles(char * noms, int nnpl)
- {
- int nbr_hexa8=(nnpl-1)*(nnpl-1)*(nnpl-1);
- int i;
- char pnom[MED_TAILLE_PNOM+1]="hexa ";
-
- /*noms=(char *) malloc((nbr_hexa8*MED_TAILLE_PNOM+1)*sizeof(char));*/
-
- for (i=0;i<nbr_hexa8;i++) strncpy(&noms[i*MED_TAILLE_PNOM],pnom,MED_TAILLE_PNOM);
-
- noms[nbr_hexa8*MED_TAILLE_PNOM]='\n';
-
- }
-void cree_num_mailles(med_int * num_mailles,int nnpl)
- {
- int nbr_hexa8=(nnpl-1)*(nnpl-1)*(nnpl-1);
- int i;
-
- /*num_mailles=(med_int *) malloc(nbr_hexa8*sizeof(med_int));*/
-
- for (i=0;i<nbr_hexa8;i++) num_mailles[i]=i+1;
- }
-void cree_fam_nodes(med_int * fam,int nnpl)
- {
- int nbr_nodes=nnpl*nnpl*nnpl;
- int i;
-
- /*fam=(med_int *) malloc(nbr_nodes*sizeof(med_int));*/
-
- for (i=0;i<nbr_nodes;i++) fam[i]=0;
- }
-void cree_fam_mailles(med_int * fam,int nnpl)
- {
- int nbr_hexa8=(nnpl-1)*(nnpl-1)*(nnpl-1);
- int i;
-
- /*fam=(med_int *) malloc(nbr_hexa8*sizeof(med_int));*/
-
- for (i=0;i<nbr_hexa8;i++) fam[i]=0;
- }
-void cree_valeurs_champ_node(med_float * val,int nnpl)
- {
- int i,j,k;
- int nbr_nodes=nnpl*nnpl*nnpl;
- int num_noeud;
- int diviseur=3*(nnpl-1);
-
- /*val=(med_float *) malloc(nbr_nodes*sizeof(med_float));*/
-
- for (i=0;i<nnpl;i++) for (j=0;j<nnpl;j++) for (k=0;k<nnpl;k++)
- {
- num_noeud=i+nnpl*j+nnpl*nnpl*k;
- val[num_noeud] = (med_float) (i+j+k)/diviseur;
- }
- for (num_noeud=0;num_noeud<nbr_nodes;num_noeud++) printf("Valeur Scalaire noeud %5d : %4.5f\n",num_noeud,val[num_noeud]);
- }
-void cree_valeurs_champ_vector_node(med_float * val,int nnpl)
- {
- int i,j,k;
- int nbr_nodes=nnpl*nnpl*nnpl;
- int num_noeud;
-
- /*val=(med_float *) malloc(nbr_nodes*sizeof(med_float));*/
-
- for (i=0;i<nnpl;i++) for (j=0;j<nnpl;j++) for (k=0;k<nnpl;k++)
- {
- num_noeud=i+nnpl*j+nnpl*nnpl*k;
- val[3*num_noeud ] = (med_float) 0;
- val[3*num_noeud+1] = (med_float) 1;
- val[3*num_noeud+2] = (med_float) 2;
- }
- for (num_noeud=0;num_noeud<nbr_nodes;num_noeud++) printf("Valeur Vectorielle noeud %5d : %4.5f %4.5f %4.5f \n ",num_noeud,val[3*num_noeud],val[3*num_noeud+1],val[3*num_noeud+2]);
- }
-void cree_valeurs_champ_cell(med_float * val,int nnpl)
- {
- int i,j,k;
- int nbr_cells=(nnpl-1)*(nnpl-1)*(nnpl-1);
- int num_cell;
-
- med_float diviseur=3*(nnpl-2);
-
- /*val=(med_float *) malloc(3*nbr_cells*sizeof(med_float));*/
-
- for (i=0;i<nnpl-1;i++) for (j=0;j<nnpl-1;j++) for (k=0;k<nnpl-1;k++)
- {
- num_cell=i+(nnpl-1)*j+(nnpl-1)*(nnpl-1)*k;
- val[num_cell ] = (med_float) (i+j+k)/diviseur;
- }
- for (num_cell=0;num_cell<nbr_cells;num_cell++) printf("Valeur scalaire maille %5d : %4.5f\n ",num_cell,val[num_cell]);
- }
-void cree_valeurs_champ_vector_cell(med_float * val,int nnpl)
- {
- int i,j,k;
- int nbr_cells=(nnpl-1)*(nnpl-1)*(nnpl-1);
- int num_cell;
-
- /*val=(med_float *) malloc(3*nbr_cells*sizeof(med_float));*/
-
- for (i=0;i<nnpl-1;i++) for (j=0;j<nnpl-1;j++) for (k=0;k<nnpl-1;k++)
- {
- num_cell=i+(nnpl-1)*j+(nnpl-1)*(nnpl-1)*k;
- val[3*num_cell ] = (med_float) 0;
- val[3*num_cell+1] = (med_float) 1;
- val[3*num_cell+2] = (med_float) 2;
- }
- for (num_cell=0;num_cell<nbr_cells;num_cell++) printf("Valeur Vectorielle maille %5d : %4.5f %4.5f %4.5f \n ",num_cell,val[3*num_cell],val[3*num_cell+1],val[3*num_cell+2]);
- }
-
-
-/*****************************************************************************************************/
-
-int main (int argc, char **argv)
- {
-
- int i,j,k;
-
- int nnpl;
-
- int nbr_nodes, nbr_hexa8;
-
- med_err ret;
- med_idt fromfid;
- med_idt tofid;
- char frommaa[MED_TAILLE_NOM+1] = "fromMesh";
- char tomaa[MED_TAILLE_NOM+1] = "toMesh";
- const med_int mdim = 3;
- med_int fromnnoe;
- med_int tonnoe;
-
- med_float * tocoo;
- med_float * fromcoo;
-
- char nomcoo[3*MED_TAILLE_PNOM+1] = "x y z ";
- char unicoo[3*MED_TAILLE_PNOM+1] = "cm cm cm ";
-
- char * nomnoe = NULL ;
-
- med_int * fromnumnoe;
- med_int * fromnufano;
-
- med_int * tonumnoe;
- med_int * tonufano;
-
- med_int fromnhexa8;
- med_int * fromhexa8;
-
- med_int tonhexa8;
- med_int * tohexa8;
-
-
- char * fromnomhexa8;
- med_int * fromnumhexa8;
- med_int * fromnufahexa8;
-
- char * tonomhexa8;
- med_int * tonumhexa8;
- med_int * tonufahexa8;
-
-/*****************************************************************************************************/
-
- char nomfam[MED_TAILLE_NOM+1];
- med_int numfam;
- char attdes[MED_TAILLE_DESC+1];
- med_int natt;
- med_int attide;
- med_int attval;
- med_int ngro;
- char gro[MED_TAILLE_LNOM+1];
- char gro2[MED_TAILLE_LNOM*2+1];
- char gro3[MED_TAILLE_LNOM*3+1];
- int nfame = 1;
- int nfamn = 1;
-
-/*****************************************************************************************************/
-
- /* Some fields : one on nodes : double , one on cells : double */
-
- char champnode[MED_TAILLE_NOM+1]="fieldnodedouble" ;
- char champnode_comp[MED_TAILLE_PNOM+1]="X+Y+Z " ;
- char champnode_unit[MED_TAILLE_PNOM+1]="X+Y+Z " ;
- med_float * fieldnodedouble;
-
- char champnodevector[MED_TAILLE_NOM+1]="fieldnodedoublevector" ;
- char champnodevector_comp[MED_TAILLE_PNOM*3+1]="0 1 2 " ;
- char champnodevector_unit[MED_TAILLE_PNOM*3+1]="O 1 2 " ;
- med_float * fieldnodedoublevector;
-
- char champcellscalar[MED_TAILLE_NOM+1]="fieldcelldouble" ;
- char champcellscalar_comp[MED_TAILLE_PNOM+1]="X+Y+Z " ;
- char champcellscalar_unit[MED_TAILLE_PNOM+1]="X+Y+Z " ;
- med_float * fieldcelldouble;
-
- char champcell[MED_TAILLE_NOM+1]="fieldcelldoublevector" ;
- char champcell_comp[MED_TAILLE_PNOM*3+1]="0 1 2 " ;
- char champcell_unit[MED_TAILLE_PNOM*3+1]="0 1 2 " ;
- med_float * fieldcelldoublevector;
-
-/*****************************************************************************************************/
-
-
- if (argc!=2)
- {
- printf("Il manque un paramètre : le nombre de point par ligne\n");
- exit(-1);
- }
-
- sscanf(argv[1],"%d",&nnpl);
-
- printf("VERSION 2.0\n");
- printf("Traitement avec %d noeuds par ligne\n",nnpl);
-
- fromnnoe = nnpl*nnpl*nnpl ;
- fromnhexa8 = (nnpl-1)*(nnpl-1)*(nnpl-1) ;
- tonnoe = (nnpl-1)*(nnpl-1)*(nnpl-1) ;
- tonhexa8 = (nnpl-2)*(nnpl-2)*(nnpl-2) ;
-
-
-
- nbr_nodes=nnpl*nnpl*nnpl;
- nbr_hexa8=(nnpl-1)*(nnpl-1)*(nnpl-1);
-
- fromcoo = (med_float *) malloc(3*nbr_nodes*sizeof(med_float)); cree_nodes ( fromcoo , nnpl, 0 );
- fromnumnoe = (med_int *) malloc(nbr_nodes*sizeof(med_int)); cree_num_nodes ( fromnumnoe , nnpl );
- fromnufano = (med_int *) malloc(nbr_nodes*sizeof(med_int)); cree_fam_nodes ( fromnufano , nnpl );
- fromhexa8 = (med_int *) malloc(8*nbr_hexa8*sizeof(med_int)); cree_Hexa8 ( fromhexa8 , nnpl ,fromnumnoe);
- fromnomhexa8 = (char *) malloc((nbr_hexa8*MED_TAILLE_PNOM+1)*sizeof(char)); cree_noms_mailles ( fromnomhexa8 , nnpl );
- fromnumhexa8 = (med_int *) malloc(nbr_hexa8*sizeof(med_int)); cree_num_mailles ( fromnumhexa8 , nnpl );
- fromnufahexa8 = (med_int *) malloc(nbr_hexa8*sizeof(med_int)); cree_fam_mailles ( fromnufahexa8 , nnpl );
-
- fieldnodedouble = (med_float *) malloc(nbr_nodes*sizeof(med_float)); cree_valeurs_champ_node ( fieldnodedouble , nnpl );
- fieldnodedoublevector = (med_float *) malloc(3*nbr_nodes*sizeof(med_float)); cree_valeurs_champ_vector_node ( fieldnodedoublevector , nnpl );
- fieldcelldouble = (med_float *) malloc(nbr_hexa8*sizeof(med_float)); cree_valeurs_champ_cell ( fieldcelldouble , nnpl );
- fieldcelldoublevector = (med_float *) malloc(3*nbr_hexa8*sizeof(med_float)); cree_valeurs_champ_vector_cell ( fieldcelldoublevector , nnpl );
-
-
- nbr_nodes=(nnpl-1)*(nnpl-1)*(nnpl-1);
- nbr_hexa8=(nnpl-2)*(nnpl-2)*(nnpl-2);
-
- tocoo = (med_float *) malloc(3*nbr_nodes*sizeof(med_float)); cree_nodes ( tocoo , nnpl-1, 1 );
- tonumnoe = (med_int *) malloc(nbr_nodes*sizeof(med_int)); cree_num_nodes ( tonumnoe , nnpl-1 );
- tonufano = (med_int *) malloc(nbr_nodes*sizeof(med_int)); cree_fam_nodes ( tonufano , nnpl-1 );
- tohexa8 = (med_int *) malloc(8*nbr_hexa8*sizeof(med_int)); cree_Hexa8 ( tohexa8 , nnpl-1 ,tonumnoe);
- tonomhexa8 = (char *) malloc((nbr_hexa8*MED_TAILLE_PNOM+1)*sizeof(char)); cree_noms_mailles ( tonomhexa8 , nnpl-1 );
- tonumhexa8 = (med_int *) malloc(nbr_hexa8*sizeof(med_int)); cree_num_mailles ( tonumhexa8 , nnpl-1 );
- tonufahexa8 = (med_int *) malloc(nbr_hexa8*sizeof(med_int)); cree_fam_mailles ( tonufahexa8 , nnpl-1 );
-
-
-/*****************************************************************************************************/
- fromfid = MEDouvrir("fromMesh.med",MED_REMP);
- if (fromfid < 0)
- ret = -1;
- else
- ret = 0;
- printf("MEDouvrir : %d\n",ret);
-
-/*****************************************************************************************************/
- tofid = MEDouvrir("toMesh.med",MED_REMP);
- if (tofid < 0)
- ret = -1;
- else
- ret = 0;
- printf("MEDouvrir : %d\n",ret);
-/*****************************************************************************************************/
- if (ret == 0)
- ret = MEDmaaCr(fromfid,frommaa,mdim);
- printf("MEDmaaCr : %d\n",ret);
-
-/*****************************************************************************************************/
-
- if (ret == 0)
- ret = MEDmaaCr(tofid,tomaa,mdim);
- printf("MEDmaaCr : %d\n",ret);
-
-/*****************************************************************************************************/
- if (ret == 0)
- ret = MEDnoeudsEcr(fromfid,frommaa,mdim,fromcoo,MED_FULL_INTERLACE,MED_CART,
- // nomcoo,unicoo,nomnoe,MED_FAUX,fromnumnoe,MED_VRAI,
- nomcoo,unicoo,nomnoe,MED_FAUX,fromnumnoe,MED_FAUX,
- fromnufano,fromnnoe,MED_ECRI);
- printf("MEDnoeudsEcr : %d\n",ret);
-/*****************************************************************************************************/
-
- if (ret == 0)
- ret = MEDnoeudsEcr(tofid,tomaa,mdim,tocoo,MED_FULL_INTERLACE,MED_CART,
- //nomcoo,unicoo,nomnoe,MED_FAUX,tonumnoe,MED_VRAI,
- nomcoo,unicoo,nomnoe,MED_FAUX,tonumnoe,MED_FAUX,
- tonufano,tonnoe,MED_ECRI);
- printf("MEDnoeudsEcr : %d\n",ret);
-
-
-/*****************************************************************************************************/
-/* ecriture des mailles MED_HEXA8 :
- - connectivite
- - noms (optionnel)
- - numeros (optionnel)
- - numeros des familles */
- if (ret == 0)
- ret = MEDelementsEcr(fromfid,frommaa,mdim,fromhexa8,MED_FULL_INTERLACE,
- fromnomhexa8,MED_FAUX,fromnumhexa8,MED_VRAI,fromnufahexa8,fromnhexa8,
- MED_MAILLE,MED_HEXA8,MED_NOD,MED_ECRI);
- printf("MEDelementsEcr : %d \n",ret);
-
-/*****************************************************************************************************/
-/* ecriture des mailles MED_HEXA8 :
- - connectivite
- - noms (optionnel)
- - numeros (optionnel)
- - numeros des familles */
-
- if (ret == 0)
- ret = MEDelementsEcr(tofid,tomaa,mdim,tohexa8,MED_FULL_INTERLACE,
- tonomhexa8,MED_FAUX,tonumhexa8,MED_VRAI,tonufahexa8,tonhexa8,
- MED_MAILLE,MED_HEXA8,MED_NOD,MED_ECRI);
- printf("MEDelementsEcr : %d \n",ret);
-
-/*****************************************************************************************************/
-/* ecriture des familles */
-/* Conventions :
- - toujours creer une famille de numero 0 ne comportant aucun attribut
- ni groupe (famille de reference pour les noeuds ou les elements
- qui ne sont rattaches a aucun groupe ni attribut)
- - les numeros de familles de noeuds sont > 0
- - les numeros de familles des elements sont < 0
- - rien d'imposer sur les noms de familles
- */
-
-/* la famille 0 */
- if (ret == 0)
- {
- strcpy(nomfam,"FAMILLE_0");
- numfam = 0;
- ret = MEDfamCr(fromfid,frommaa,nomfam,numfam,&attide,&attval,attdes,0,gro,0);
- }
- printf("MEDfamCr : %d \n",ret);
-/*****************************************************************************************************/
-
- if (ret == 0)
- {
- strcpy(nomfam,"FAMILLE_0");
- numfam = 0;
- ret = MEDfamCr(tofid,tomaa,nomfam,numfam,&attide,&attval,attdes,0,gro,0);
- }
- printf("MEDfamCr : %d \n",ret);
-
-/*****************************************************************************************************/
-/* Les champs */
-
- if (ret == 0)
- {
- ret = MEDchampCr(fromfid,champnode,MED_REEL64,champnode_comp,champnode_unit,1);
- printf("MEDchampCr : %d \n",ret);
- if (ret == 0)
- {
- ret = MEDchampEcr(fromfid, frommaa, champnode, (unsigned char *)fieldnodedouble,
- MED_FULL_INTERLACE, fromnnoe,
- MED_NOPG, MED_ALL, MED_NOPFL, MED_ECRI, MED_NOEUD,
- 0, MED_NOPDT," ", 0. , MED_NONOR);
- printf("MEDchampEcr : %d \n",ret);
- }
- }
-
- if (ret == 0)
- {
- ret = MEDchampCr(fromfid,champcell,MED_REEL64,champcell_comp,champcell_unit,3);
- printf("MEDchampCr : %d \n",ret);
- if (ret == 0)
- {
- ret = MEDchampEcr(fromfid, frommaa, champcell, (unsigned char *)fieldcelldoublevector,
- MED_FULL_INTERLACE, fromnhexa8,
- MED_NOPG, MED_ALL, MED_NOPFL, MED_ECRI, MED_MAILLE,
- MED_HEXA8, MED_NOPDT," ", 0., MED_NONOR);
- printf("MEDchampEcr : %d \n",ret);
- }
- }
-
- if (ret == 0)
- {
- ret = MEDchampCr(fromfid,champcellscalar,MED_REEL64,champcellscalar_comp,champcellscalar_unit,1);
- printf("MEDchampCr : %d \n",ret);
- if (ret == 0)
- {
- ret = MEDchampEcr(fromfid, frommaa, champcellscalar, (unsigned char *)fieldcelldouble,
- MED_FULL_INTERLACE, fromnhexa8,
- MED_NOPG, MED_ALL, MED_NOPFL, MED_ECRI, MED_MAILLE,
- MED_HEXA8, MED_NOPDT," ", 0., MED_NONOR);
- printf("MEDchampEcr : %d \n",ret);
- }
- }
-
- if (ret == 0)
- {
- ret = MEDchampCr(fromfid,champnodevector,MED_REEL64,champnodevector_comp,champnodevector_unit,3);
- printf("MEDchampCr : %d \n",ret);
- if (ret == 0)
- {
- ret = MEDchampEcr(fromfid, frommaa, champnodevector, (unsigned char *)fieldnodedoublevector,
- MED_FULL_INTERLACE, fromnnoe,
- MED_NOPG, MED_ALL, MED_NOPFL, MED_ECRI, MED_NOEUD,
- 0, MED_NOPDT," ", 0. , MED_NONOR);
- printf("MEDchampEcr : %d \n",ret);
- }
- }
-
-
-/***************************************************************************/
-ret = MEDfermer(fromfid);
-printf("MEDfermer : %d\n",ret);
-/***************************************************************************/
-ret = MEDfermer(tofid);
-printf("MEDfermer : %d\n",ret);
-
-return 0;
-}
-
+++ /dev/null
-#include "MEDMEM_Exception.hxx"
-#include "MEDMEM_define.hxx"
-
-#include "MEDMEM_Field.hxx"
-#include "MEDMEM_Mesh.hxx"
-#include "MEDMEM_Interpolation.hxx"
-
-#include "stdio.h"
-
-main () {
-
- const char * fromFileName = "fromMesh.med";
- const char * toFileName = "toMesh.med";
- //const char * fieldName = "fieldcelldoublevector";
- const char * fieldName = "fieldnodedouble";
-
- const char * fromMeshName = "fromMesh";
- const char * toMeshName = "toMesh";
-
- try {
-
- cout<<"Lecture du Maillage Source : "<<flush; MESH fromMesh (MED_DRIVER,fromFileName,fromMeshName); cout<<"OK !"<<endl;
- //cout<<"Construction du support : "<<flush; SUPPORT fromSupport (&fromMesh,"XsupportX",MED_CELL); cout<<"OK !"<<endl;
- cout<<"Construction du support : "<<flush; SUPPORT fromSupport (&fromMesh,"XsupportX",MED_NODE); cout<<"OK !"<<endl;
- cout<<"Lecture du champ : "<<flush; FIELD<double> fromField (&fromSupport,MED_DRIVER,fromFileName,fieldName); cout<<"OK !"<<endl;
- cout<<"Lecture du Mailllage Cible : "<<flush; MESH toMesh (MED_DRIVER,toFileName,toMeshName); cout<<"OK !"<<endl;
-
- INTERPOLATION<3> myInter (fromField,toMesh);
-
- //FIELD<double> * toField = myInter.interpolate(0,1);
- FIELD<double> * toField = myInter.interpolate(1,1);
-
- cout<<"Creation du driver"<<endl;
-
- toField->addDriver(MED_DRIVER,toFileName,toField->getName()) ;
-
- cout<<"toField->getName() = "<<toField->getName() <<endl;
- cout<<"toField->getDescription() = "<<toField->getDescription() <<endl;
- cout<<"toField->getNumberOfComponents() = "<<toField->getNumberOfComponents() <<endl;
- cout<<"toField->getNumberOfValues() = "<<toField->getNumberOfValues() <<endl;
- cout<<"toField->getComponentsNames() = "<<toField->getComponentsNames() <<endl;
- cout<<"toField->getComponentsDescriptions() = "<<toField->getComponentsDescriptions()<<endl;
- cout<<"toField->getMEDComponentsUnits() = "<<toField->getMEDComponentsUnits() <<endl;
- cout<<"toField->getIterationNumber() = "<<toField->getIterationNumber() <<endl;
- cout<<"toField->getTime() = "<<toField->getTime() <<endl;
- cout<<"toField->getOrderNumber() = "<<toField->getOrderNumber() <<endl;
- cout<<"toField->getValueType() = "<<toField->getValueType() <<endl;
-
- toField->write();
-
- cout<<"Fin"<<endl;
-
- } catch (MEDEXCEPTION& ex){
- MESSAGE(ex.what()) ;
- }
-}
+++ /dev/null
-#include "MEDMEM_Exception.hxx"
-#include "MEDMEM_define.hxx"
-
-#include "MEDMEM_Med.hxx"
-#include "MEDMEM_Field.hxx"
-#include "MEDMEM_Mesh.hxx"
-#include "MEDMEM_Interpolation.hxx"
-
-#include <deque>
-
-#include "stdio.h"
-
-using namespace MEDMEM;
-
-// pour gestion timings
-#include "time.h"
-
-#define RUN(procedure) {double t0,t1;cout<<"# =============> TEMPS D'EXECUTION A PARTIR D'ICI "<<endl<<#procedure<<endl;t0=CPUtime();procedure;t1=CPUtime();cout<<"# ================> TEMPS D'EXECUTION : "<<t1-t0<<endl;}
-#define TIMORIZE(procedure,t) {double t0,t1;t0=CPUtime();procedure;t1=CPUtime();t=t1-t0;}
-
-double CPUtime()
- {
- #ifdef SYSTIMES
- struct tms buf;
- if (times(&buf)!=-1)
- return ((double)buf.tms_utime+(double)buf.tms_stime)/(long) sysconf(_SC_CLK_TCK);
- else
- #endif
- return ((double) clock())/CLOCKS_PER_SEC;
- }
-
-double ABS(Valeur<double> v)
- {
- double tmp=0;
- int i;
- for (i=0;i<v.SIZE();i++) tmp+=fabs(v[i]);
- return tmp;
- }
-
-double ABS(Valeur<double> v1,Valeur<double> v2)
- {
- double tmp=0;
- int i;
- for (i=0;i<v1.SIZE();i++) tmp+=fabs(v1[i]-v2[i]);
- return tmp;
- }
-
-
-
-// effectue la soustraction du premier moins le second et stocke le résultat dans le premier
-void Flipback(FIELD<double> * firstField, FIELD<double> * secondField)
- {
- Wrapper_MED_Field first ( firstField);
- Wrapper_MED_Field second (secondField);
- int nbr_valeurs_first = first.Get_Nbr_Valeurs();
- int nbr_valeurs_second = second.Get_Nbr_Valeurs();
-
- double max1 = 0;
- double max2 = 0;
-
- double min1 = ABS(first[0]);
- double min2 = ABS(second[0]);
-
- int imax1,imax2;
-
- double tmp;
-
- int i;
-
- //cout<<first<<endl;
- //int tyty;cin>>tyty;
-
- if (nbr_valeurs_first!=nbr_valeurs_second)
- {
- cerr<<"Les champs à soustraire n'ont pas le meme nombre de valeurs"<<endl;
- exit(-1);
- }
-
- imax1=0;
- for (i=0;i<nbr_valeurs_first;i++)
- {
- tmp=ABS(first[i]);
- //cout<<"tmp 1 ["<<i<<"] = "<<tmp<<endl;
- if (tmp>max1)
- {
- imax1=i;
- max1=tmp;
- }
- if (tmp<min1) min1=tmp;
- }
-
- imax2=0;
- for (i=0;i<nbr_valeurs_first;i++)
- {
- tmp=ABS(second[i]);
- if (tmp>max2)
- {
- imax2=i;
- max2=tmp;
- }
- if (tmp<min2) min2=tmp;
- }
-
- for (i=0;i<nbr_valeurs_first;i++)
- {
- first[i]=ABS(first[i],second[i]);
- }
-
- double maxdiff=ABS(first[0]);
- double mindiff=ABS(first[0]);
-
- for (i=0;i<nbr_valeurs_first;i++)
- {
- tmp=ABS(first[i]);
- if (tmp>maxdiff) maxdiff=tmp;
- if (tmp<mindiff) mindiff=tmp;
- }
-
- cout<<endl;
- cout<<"/////////////////////////////////////////////////////////////////////////"<<endl;
- cout<<"/////// max1 = "<<max1<<endl;
- cout<<"/////// min1 = "<<min1<<endl;
- cout<<"/////// Maximum First atteint pour i = "<<imax1<<endl;
- cout<<"/////// max2 = "<<max2<<endl;
- cout<<"/////// min2 = "<<min2<<endl;
- cout<<"/////// Maximum Second atteint pour i = "<<imax2<<endl;
- cout<<"/////// maxdiff = "<<maxdiff<<endl;
- cout<<"/////// mindiff = "<<mindiff<<endl;
- cout<<"/////////////////////////////////////////////////////////////////////////"<<endl;
-
- }
-
-
-#include "MEDMEM_WrapperCells.hxx"
-
-main () {
-
- const char * fromFileName = "ResultatSyrthes.med";
- const char * toFileName = "MaillageAster.med";
- const char * resultFileName = "ResultatFlipback.med";
-
- const char * fromFieldName = "THERDEP_TEMP____________________";
-
- const char * fromMeshName = "MA";
- const char * toMeshName = "MAILLAGE_IDEAS";
- int handle;
-
- try {
-
- string flag="================[MAIN MESSAGES]================> ";
-
- cout<<flag<<"Lecture de la structure MED : "<<flush;
- MED fromMED (MED_DRIVER,fromFileName);
- cout<<"OK !"<<endl;
-
- // Utilisation completement débile, on ne devrait pas avoir a faire l'appel suivant
- fromMED.updateSupport();
-
- cout<<flag<<"Lecture du Mailllage Cible : "<<flush;
- MESH toMesh (MED_DRIVER,toFileName,toMeshName);
- cout<<"OK !"<<endl;
-
- cout<<flag<<"Lecture des pas de temps : "<<flush;
- deque<DT_IT_> pasDeTemps=fromMED.getFieldIteration (fromFieldName);
- cout<<"OK !"<<endl;
-
- deque<DT_IT_>::const_iterator currentStep;
-
- INTERPOLATION<3> * interFromTo ;
- INTERPOLATION<3> * interToFrom ;
- FIELD<double> * toField ;
- FIELD<double> * toToField ;
- int flagNewMappingFromTo = 0;
- int flagNewMappingToFrom = 0;
-
- for (currentStep=pasDeTemps.begin();currentStep!=pasDeTemps.end();currentStep++)
- {
- cout<<flag<<"Traitement du Step ( "<<flush<<(*currentStep).dt<<" ; "<<(*currentStep).it<<" ) : "<<endl;
-
- cout<<flag<<"Lecture du FIELD_ "<<flush;
- FIELD_ * fromField_ = fromMED.getField(fromFieldName,(*currentStep).dt,(*currentStep).it);
- cout<<"OK !"<<endl;
-
- cout<<flag<<"Transtypage en FIELD : "<<flush;
- FIELD<double> * fromField = dynamic_cast<FIELD<double> *>(fromField_);
- cout<<"OK !"<<endl;
-
- if (currentStep==pasDeTemps.begin())
- {
- //Utilisation completement débile, on ne devrait pas avoir a faire l'appel suivant
- RUN(fromField->getSupport()->getMesh()->read());
- }
-
- MESH * fromMesh = fromField->getSupport()->getMesh();
-
- cout<<flag<<"Lecture des valeurs du FIELD : "<<flush;
- RUN(fromField->read());
- cout<<"OK !"<<endl;
-
- if (currentStep==pasDeTemps.begin())
- {
- cout<<flag<<"Préparation de l'interpolation DIRECTE pour le premier pas de temps : "<<flush;
- RUN(interFromTo = new INTERPOLATION<3>(*fromField,toMesh));
- cout<<"OK !"<<endl;
- cout<<flag<<"Interpolation effective DIRECTE du premier pas de temps : "<<flush;
- RUN(toField = interFromTo->interpolate(1,1));
- cout<<"OK !"<<endl;
- cout<<flag<<"Préparation de l'interpolation INVERSE pour le premier pas de temps : "<<flush;
- RUN(interToFrom = new INTERPOLATION<3>(*toField,*fromMesh));
- cout<<"OK !"<<endl;
- cout<<flag<<"Interpolation effective INVERSE du premier pas de temps : "<<flush;
- RUN(toToField = interToFrom->interpolate(1,1));
- cout<<"OK !"<<endl;
- }
- else
- {
- cout<<flag<<"Interpolation nextStep DIRECTE : "<<flush;
- RUN(toField = interFromTo->interpolateNextStep(*fromField,flagNewMappingFromTo));
- cout<<"OK !"<<endl;
- cout<<flag<<"Interpolation nextStep INVERSE : "<<flush;
- RUN(toToField = interToFrom->interpolateNextStep(*toField,flagNewMappingToFrom));
- cout<<"OK !"<<endl;
- }
-
- cout<<flag<<"Calcul du flip back : "<<flush;
- Flipback(toToField,fromField);
- cout<<"OK !"<<endl;
-
- cout<<flag<<"Creation du driver d'écriture Field : "<<flush;
- toToField->addDriver(MED_DRIVER,resultFileName,toToField->getName());
- cout<<"OK !"<<endl;
-
- cout<<flag<<"Ecriture du Field résultat : "<<flush;
- toToField->write();
- cout<<"OK !"<<endl;
-
- if (flagNewMappingToFrom==1)
- {
- cout<<flag<<"Creation du driver d'écriture Mesh : "<<flush;
- handle = fromMesh->addDriver(MED_DRIVER,resultFileName,fromMesh->getName()) ;
- cout<<"OK !"<<endl;
-
- cout<<flag<<"Ecriture du Mesh résultat : "<<flush;
- fromMesh->write(handle);
- cout<<"OK !"<<endl;
- }
- }
-
- } catch (MEDEXCEPTION& ex){
- MESSAGE(ex.what()) ;
- }
-}
+++ /dev/null
-#include "MEDMEM_Exception.hxx"
-#include "MEDMEM_define.hxx"
-
-#include "MEDMEM_Field.hxx"
-#include "MEDMEM_Mesh.hxx"
-#include "MEDMEM_Interpolation.hxx"
-
-#include "stdio.h"
-
-main () {
-
- const char * fromFileName = "fromMesh.med";
- const char * toFileName = "toMesh.med";
- //const char * fieldName = "fieldcelldoublevector";
- const char * fieldName = "fieldnodedouble";
-
- const char * fromMeshName = "fromMesh";
- const char * toMeshName = "toMesh";
-
- try {
-
- cout<<"Lecture du Maillage Source : "<<flush; MESH fromMesh (MED_DRIVER,fromFileName,fromMeshName); cout<<"OK !"<<endl;
- //cout<<"Construction du support : "<<flush; SUPPORT fromSupport (&fromMesh,"XsupportX",MED_CELL); cout<<"OK !"<<endl;
- cout<<"Construction du support : "<<flush; SUPPORT fromSupport (&fromMesh,"XsupportX",MED_NODE); cout<<"OK !"<<endl;
- cout<<"Lecture du champ : "<<flush; FIELD<double> fromField (&fromSupport,MED_DRIVER,fromFileName,fieldName); cout<<"OK !"<<endl;
- cout<<"Lecture du Mailllage Cible : "<<flush; MESH toMesh (MED_DRIVER,toFileName,toMeshName); cout<<"OK !"<<endl;
-
- INTERPOLATION<3> myInter (fromField,toMesh);
-
- //FIELD<double> * toField = myInter.interpolate(0,1);
- FIELD<double> * toField = myInter.interpolate(1,1);
-
- cout<<"Creation du driver"<<endl;
-
- toField->addDriver(MED_DRIVER,toFileName,toField->getName()) ;
-
- cout<<"toField->getName() = "<<toField->getName() <<endl;
- cout<<"toField->getDescription() = "<<toField->getDescription() <<endl;
- cout<<"toField->getNumberOfComponents() = "<<toField->getNumberOfComponents() <<endl;
- cout<<"toField->getNumberOfValues() = "<<toField->getNumberOfValues() <<endl;
- cout<<"toField->getComponentsNames() = "<<toField->getComponentsNames() <<endl;
- cout<<"toField->getComponentsDescriptions() = "<<toField->getComponentsDescriptions()<<endl;
- cout<<"toField->getMEDComponentsUnits() = "<<toField->getMEDComponentsUnits() <<endl;
- cout<<"toField->getIterationNumber() = "<<toField->getIterationNumber() <<endl;
- cout<<"toField->getTime() = "<<toField->getTime() <<endl;
- cout<<"toField->getOrderNumber() = "<<toField->getOrderNumber() <<endl;
- cout<<"toField->getValueType() = "<<toField->getValueType() <<endl;
-
- toField->write();
-
- cout<<"Fin"<<endl;
-
- } catch (MEDEXCEPTION& ex){
- MESSAGE(ex.what()) ;
- }
-}
+++ /dev/null
-#include "MEDMEM_Exception.hxx"
-#include "MEDMEM_define.hxx"
-
-#include "MEDMEM_Med.hxx"
-#include "MEDMEM_Field.hxx"
-#include "MEDMEM_Mesh.hxx"
-#include "MEDMEM_Interpolation.hxx"
-
-#include <deque>
-
-#include "stdio.h"
-
-
-
-// pour gestion timings
-#include "time.h"
-
-#define RUN(procedure) {double t0,t1;cout<<"# =============> TEMPS D'EXECUTION A PARTIR D'ICI "<<endl<<#procedure<<endl;t0=CPUtime();procedure;t1=CPUtime();cout<<"# ================> TEMPS D'EXECUTION : "<<t1-t0<<endl;}
-#define TIMORIZE(procedure,t) {double t0,t1;t0=CPUtime();procedure;t1=CPUtime();t=t1-t0;}
-
-double CPUtime()
- {
- #ifdef SYSTIMES
- struct tms buf;
- if (times(&buf)!=-1)
- return ((double)buf.tms_utime+(double)buf.tms_stime)/(long) sysconf(_SC_CLK_TCK);
- else
- #endif
- return ((double) clock())/CLOCKS_PER_SEC;
- }
-
-
-
-#include "MEDMEM_WrapperCells.hxx"
-
-main () {
-/*
-int taille=100;
-int * liste = new int [taille] ;
-int i,j;
-int nbr_faces;
-for (i=0;i<taille;i++) liste[i]=i;
-
-Wrapper_Maille_Tria3 Tria3 ;Tria3 .positionne(liste);cout<<"Tria3 "<<endl;Tria3 .export_connectivite();
-Wrapper_Maille_Tria6 Tria6 ;Tria6 .positionne(liste);cout<<"Tria6 "<<endl;Tria6 .export_connectivite();
-Wrapper_Maille_Quad4 Quad4 ;Quad4 .positionne(liste);cout<<"Quad4 "<<endl;Quad4 .export_connectivite();
-Wrapper_Maille_Quad8 Quad8 ;Quad8 .positionne(liste);cout<<"Quad8 "<<endl;Quad8 .export_connectivite();
-Wrapper_Maille_Tetra4 Tetra4 ;Tetra4 .positionne(liste);cout<<"Tetra4 "<<endl;Tetra4 .export_connectivite();
-Wrapper_Maille_Tetra10 Tetra10;Tetra10.positionne(liste);cout<<"Tetra10"<<endl;Tetra10.export_connectivite();
-Wrapper_Maille_Hexa8 Hexa8 ;Hexa8 .positionne(liste);cout<<"Hexa8 "<<endl;Hexa8 .export_connectivite();
-Wrapper_Maille_Hexa20 Hexa20 ;Hexa20 .positionne(liste);cout<<"Hexa20 "<<endl;Hexa20 .export_connectivite();
-Wrapper_Maille_Pyra5 Pyra5 ;Pyra5 .positionne(liste);cout<<"Pyra5 "<<endl;Pyra5 .export_connectivite();
-Wrapper_Maille_Pyra13 Pyra13 ;Pyra13 .positionne(liste);cout<<"Pyra13 "<<endl;Pyra13 .export_connectivite();
-Wrapper_Maille_Penta6 Penta6 ;Penta6 .positionne(liste);cout<<"Penta6 "<<endl;Penta6 .export_connectivite();
-Wrapper_Maille_Penta15 Penta15;Penta15.positionne(liste);cout<<"Penta15"<<endl;Penta15.export_connectivite();
-//*/
-
-//*
- const char * fromFileName = "ResultatSyrthes.med";
- const char * toFileName = "MaillageAster.med";
- const char * resultFileName = "ResultatInterpolation.med";
-
- const char * fromFieldName = "THERDEP_TEMP____________________";
-
- const char * fromMeshName = "MA";
- const char * toMeshName = "MAILLAGE_IDEAS";
- int handle;
-
- try {
-
- string flag="================[MAIN MESSAGES]================> ";
-
- cout<<flag<<"Lecture de la structure MED : "<<flush;
- MED fromMED (MED_DRIVER,fromFileName);
- cout<<"OK !"<<endl;
-
- // Utilisation completement débile, on ne devrait pas avoir a faire l'appel suivant
- fromMED.updateSupport();
-
- cout<<flag<<"Lecture du Mailllage Cible : "<<flush;
- MESH toMesh (MED_DRIVER,toFileName,toMeshName);
- cout<<"OK !"<<endl;
-
- cout<<flag<<"Lecture des pas de temps : "<<flush;
- deque<DT_IT_> pasDeTemps=fromMED.getFieldIteration (fromFieldName);
- cout<<"OK !"<<endl;
-
- deque<DT_IT_>::const_iterator currentStep;
-
- INTERPOLATION<3> * myInter ;
- FIELD<double> * toField ;
- int flagNewMapping = 1;
-
- for (currentStep=pasDeTemps.begin();currentStep!=pasDeTemps.end();currentStep++)
- {
- cout<<flag<<"Traitement du Step ( "<<flush<<(*currentStep).dt<<" ; "<<(*currentStep).it<<" ) : "<<endl;
-
- cout<<flag<<"Lecture du FIELD_ "<<flush;
- FIELD_ * fromField_ = fromMED.getField(fromFieldName,(*currentStep).dt,(*currentStep).it);
- cout<<"OK !"<<endl;
-
- cout<<flag<<"Transtypage en FIELD : "<<flush;
- FIELD<double> * fromField = dynamic_cast<FIELD<double> *>(fromField_);
- cout<<"OK !"<<endl;
-
- if (currentStep==pasDeTemps.begin())
- {
- //Utilisation completement débile, on ne devrait pas avoir a faire l'appel suivant
- RUN(fromField->getSupport()->getMesh()->read());
- }
-
- cout<<flag<<"Lecture des valeurs du FIELD : "<<flush;
- RUN(fromField->read());
- cout<<"OK !"<<endl;
-
- if (currentStep==pasDeTemps.begin())
- {
- cout<<flag<<"Préparation de l'interpolation pour le premier pas de temps : "<<flush;
- RUN(myInter = new INTERPOLATION<3>(*fromField,toMesh));
- cout<<"OK !"<<endl;
- cout<<flag<<"Interpolation effective du premier pas de temps : "<<flush;
- RUN(toField = myInter->interpolate(1,1));
- cout<<"OK !"<<endl;
- }
- else
- {
- cout<<flag<<"Interpolation nextStep : "<<flush;
- RUN(toField = myInter->interpolateNextStep(*fromField,flagNewMapping));
- cout<<"OK !"<<endl;
- }
-
- cout<<flag<<"Creation du driver d'écriture Field : "<<flush;
- toField->addDriver(MED_DRIVER,resultFileName,toField->getName());
- cout<<"OK !"<<endl;
-
- cout<<flag<<"Ecriture du Field résultat : "<<flush;
- toField->write();
- cout<<"OK !"<<endl;
-
- if (flagNewMapping==1)
- {
- cout<<flag<<"Creation du driver d'écriture Mesh : "<<flush;
- handle = toMesh.addDriver(MED_DRIVER,resultFileName,toMesh.getName()) ;
- cout<<"OK !"<<endl;
-
- cout<<flag<<"Ecriture du Mesh résultat : "<<flush;
- toMesh.write(handle);
- cout<<"OK !"<<endl;
- }
- }
-
- } catch (MEDEXCEPTION& ex){
- MESSAGE(ex.what()) ;
- }
-//*/
-}
+++ /dev/null
-#include "MEDMEM_Exception.hxx"
-#include "MEDMEM_define.hxx"
-
-#include "MEDMEM_Med.hxx"
-#include "MEDMEM_Field.hxx"
-#include "MEDMEM_Mesh.hxx"
-#include "MEDMEM_Interpolation.hxx"
-
-#include <deque>
-
-#include "stdio.h"
-
-main () {
-
- const char * fromFileName = "ResultatSyrthes.med";
- const char * toFileName = "MaillageAster.med";
-// const char * resultFileName = "ResultatInterpolation.med";
-
- const char * fromFieldName = "THERDEP_TEMP____________________";
-
- const char * fromMeshName = "MA";
- const char * toMeshName = "MAILLAGE_IDEAS";
-
- try {
-
- string flag="================[MAIN MESSAGES]================> ";
-
- cout<<flag<<"Lecture de la structure MED : "<<flush; MED fromMED (MED_DRIVER,fromFileName) ; cout<<"OK !"<<endl;
-
- // Utilisation completement débile, on ne devrait pas avoir a faire l'appel suivant
- fromMED.updateSupport();
-
- cout<<flag<<"Lecture du Maillage Source : "<<flush; MESH fromMesh (MED_DRIVER,fromFileName,fromMeshName) ; cout<<"OK !"<<endl;
- cout<<flag<<"Lecture du Mailllage Cible : "<<flush; MESH toMesh (MED_DRIVER,toFileName,toMeshName) ; cout<<"OK !"<<endl;
- cout<<flag<<"Lecture des pas de temps : "<<flush; deque<DT_IT_> pasDeTemps=fromMED.getFieldIteration (fromFieldName) ; cout<<"OK !"<<endl;
- cout<<flag<<"Lecture du FIELD_ au premier pas de temps : "<<flush; FIELD_ * fromField_ = fromMED.getField(fromFieldName,pasDeTemps[0].dt,pasDeTemps[0].it) ; cout<<"OK !"<<endl;
- cout<<flag<<"Transtypage en FIELD : "<<flush; FIELD<double> * fromField = dynamic_cast<FIELD<double> *>(fromField_) ; cout<<"OK !"<<endl;
-
- // Utilisation completement débile, on ne devrait pas avoir a faire l'appel suivant
- fromField->getSupport()->getMesh()->read();
-
- cout<<flag<<"Lecture des valeurs du FIELD : "<<flush; fromField->read() ; cout<<"OK !"<<endl;
- cout<<flag<<"Préparation de l'interpolation : "<<flush; INTERPOLATION<3> myInter (*fromField,toMesh) ; cout<<"OK !"<<endl;
- cout<<flag<<"Interpolation effective : "<<flush; FIELD<double> * toField = myInter.interpolate(1,1) ; cout<<"OK !"<<endl;
- cout<<flag<<"Creation du driver d'écriture : "<<flush; toField->addDriver(MED_DRIVER,toFileName,toField->getName()) ; cout<<"OK !"<<endl;
-// cout<<flag<<"Creation du driver d'écriture Field : "<<flush; toField->addDriver(MED_DRIVER,resultFileName,toField->getName()) ; cout<<"OK !"<<endl;
- cout<<flag<<"Ecriture du Field résultat : "<<flush; toField->write() ; cout<<"OK !"<<endl;
-// cout<<flag<<"Creation du driver d'écriture Mesh : "<<flush; toMesh.addDriver(MED_DRIVER,resultFileName,toMesh.getName()) ; cout<<"OK !"<<endl;
-// cout<<flag<<"Ecriture du Mesh résultat : "<<flush; toMesh.write(1) ; cout<<"OK !"<<endl;
-
- } catch (MEDEXCEPTION& ex){
- MESSAGE(ex.what()) ;
- }
-}
+++ /dev/null
-#include "MEDMEM_Exception.hxx"
-#include "MEDMEM_define.hxx"
-
-#include "MEDMEM_Med.hxx"
-#include "MEDMEM_Field.hxx"
-#include "MEDMEM_Mesh.hxx"
-#include "MEDMEM_Interpolation.hxx"
-
-#include <deque>
-
-#include "stdio.h"
-
-main () {
-
- const char * fromFileName = "ResultatSyrthes.med";
- const char * toFileName = "MaillageAster.med";
- const char * resultFileName = "ResultatInterpolation.med";
-
- const char * fromFieldName = "THERDEP_TEMP____________________";
-
- const char * fromMeshName = "MA";
- const char * toMeshName = "MAILLAGE_IDEAS";
- int handle;
-
- try {
-
- string flag="================[MAIN MESSAGES]================> ";
-
- cout<<flag<<"Lecture de la structure MED : "<<flush;
- MED fromMED (MED_DRIVER,fromFileName);
- cout<<"OK !"<<endl;
-
- // Utilisation completement débile, on ne devrait pas avoir a faire l'appel suivant
- fromMED.updateSupport();
-
- cout<<flag<<"Lecture du Mailllage Cible : "<<flush;
- MESH toMesh (MED_DRIVER,toFileName,toMeshName);
- cout<<"OK !"<<endl;
-
- cout<<flag<<"Lecture des pas de temps : "<<flush;
- deque<DT_IT_> pasDeTemps=fromMED.getFieldIteration (fromFieldName);
- cout<<"OK !"<<endl;
-
- deque<DT_IT_>::const_iterator currentStep;
-
- INTERPOLATION<3> * myInter ;
- FIELD<double> * toField ;
- int flagNewMapping = 1;
-
- for (currentStep=pasDeTemps.begin();currentStep!=pasDeTemps.end();currentStep++)
- {
- cout<<flag<<"Traitement du Step ( "<<flush<<(*currentStep).dt<<" ; "<<(*currentStep).it<<" ) : "<<endl;
-
- cout<<flag<<"Lecture du FIELD_ "<<flush;
- FIELD_ * fromField_ = fromMED.getField(fromFieldName,(*currentStep).dt,(*currentStep).it) ;
- cout<<"OK !"<<endl;
-
- cout<<flag<<"Transtypage en FIELD : "<<flush;
- FIELD<double> * fromField = dynamic_cast<FIELD<double> *>(fromField_);
- cout<<"OK !"<<endl;
-
- // Utilisation completement débile, on ne devrait pas avoir a faire l'appel suivant
- fromField->getSupport()->getMesh()->read();
-
- cout<<flag<<"Lecture des valeurs du FIELD : "<<flush; fromField->read();
- cout<<"OK !"<<endl;
-
- if (currentStep==pasDeTemps.begin())
- {
- cout<<flag<<"Préparation de l'interpolation pour le premier pas de temps : "<<flush;
- myInter = new INTERPOLATION<3>(*fromField,toMesh) ;
- cout<<"OK !"<<endl;
-
- cout<<flag<<"Interpolation effective du premier pas de temps : "<<flush;
- toField = myInter->interpolate(1,1);
- cout<<"OK !"<<endl;
- }
- else
- {
- cout<<flag<<"Interpolation nextStep : "<<flush;
- toField = myInter->interpolateNextStep(*fromField,flagNewMapping);
- cout<<"OK !"<<endl;
- }
-
- cout<<flag<<"Creation du driver d'écriture Field : "<<flush;
- toField->addDriver(MED_DRIVER,resultFileName,toField->getName());
- cout<<"OK !"<<endl;
-
- cout<<flag<<"Ecriture du Field résultat : "<<flush;
- toField->write();
- cout<<"OK !"<<endl;
-
- if (flagNewMapping==1)
- {
- cout<<flag<<"Creation du driver d'écriture Mesh : "<<flush;
- handle = toMesh.addDriver(MED_DRIVER,resultFileName,toMesh.getName()) ;
- cout<<"OK !"<<endl;
-
- cout<<flag<<"Ecriture du Mesh résultat : "<<flush;
- toMesh.write(handle);
- cout<<"OK !"<<endl;
- }
- }
-
- } catch (MEDEXCEPTION& ex){
- MESSAGE(ex.what()) ;
- }
-}
