src/INTERPOLATION/MEDMEM_WrapperField.hxx

   1 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 #ifndef MEDMEM_WRAPPER_FIELD_HXX
  23 #define MEDMEM_WRAPPER_FIELD_HXX
  24
  25 #include "MEDMEM_Field.hxx"
  26
  27 #include <vector>
  28
  29 //////////////////////////////////////////////////////////////////
  30 ///                                                            ///
  31 ///                 DECLARATIONS ET CODE                       ///
  32 ///                                                            ///
  33 //////////////////////////////////////////////////////////////////
  34
  35 /*********************************************************/
  36 /*                                                       */
  37 /*        Template Arithmétiques de Valdhuizen           */
  38 /*                                                       */
  39 /*********************************************************/
  40
  41 // permet de faire des opérations algébriques sur des Wrappers_MED_Field sans faire d'allocations inutiles
  42 // voir les articles de Valdhuizen pour la compréhension du processus
  43
  44 struct Plus
  45 {
  46 public :
  47         static double apply(double a,double b) {return a+b;}
  48 };
  49
  50 struct Multiply
  51 {
  52 public :
  53         static double apply(double a,double b) {return a*b;}
  54 };
  55
  56
  57 template <typename Left,typename Op, typename Right> struct X
  58 {
  59         Left left;
  60         Right right;
  61         X(Left l,Right r):left(l),right(r){}
  62         double operator[](int i)
  63                 {
  64                 return Op::apply(left[i],right[i]);
  65                 }
  66 };
  67
  68 template <typename Right> struct X<double,Multiply,Right>
  69 {
  70         double left;
  71         Right right;
  72         X(double l,Right r):left(l),right(r){}
  73         double operator[](int i)
  74                 {
  75                 return Multiply::apply(left,right[i]);
  76                 }
  77 };
  78
  79 template <class TYPE> class Valeur
  80 {
  81 protected :
  82         TYPE * valeurs;
  83         int nbr_valeurs;
  84         int a_detruire;
  85 public :
  86         Valeur();
  87         Valeur(TYPE * val,int nv);
  88         Valeur(int n);
  89         template <typename Left,typename Op,typename Right> Valeur(X<Left,Op,Right> expression);
  90         template <typename Left,typename Op,typename Right> void operator=(X<Left,Op,Right> expression);
  91         void operator=(Valeur v);
  92         Valeur(const Valeur &v);
  93         ~Valeur();
  94         TYPE operator[](int i);
  95         int SIZE() const;
  96         double NormeAbs();
  97 };
  98
  99 template <typename TYPE> X< Valeur<TYPE>,Plus,Valeur<TYPE> > operator+(Valeur<TYPE> v1,Valeur<TYPE> v2)
 100 {
 101 return X< Valeur<TYPE>,Plus,Valeur<TYPE> >(v1,v2);
 102 }
 103
 104 template <typename TYPE> X< double,Multiply,Valeur<double> > operator*(TYPE sca,Valeur<TYPE> v)
 105 {
 106 return X< TYPE,Multiply,Valeur<TYPE> >(sca,v);
 107 }
 108
 109 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)
 110 {
 111 return X< Valeur<TYPE>,Plus,X<L,O,R> >(v,expression);
 112 }
 113
 114 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)
 115 {
 116 return X< X<L,O,R>,Plus,Valeur<TYPE> >(expression,v);
 117 }
 118
 119 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 )
 120 {
 121 return X< X<Ll,Ol,Rl>,Plus,X<Lr,Or,Rr> >(el,er);
 122 }
 123
 124 template <typename  L, typename O, typename R> X< double,Multiply,X<L,O,R> > operator*(double sca,X<L,O,R> expression)
 125 {
 126 return X< double,Multiply,X<L,O,R> >(sca,expression);
 127 }
 128
 129 template <typename Left,typename Op,typename Right> X< double,Multiply,X<Left,Op,Right> > operator/(X<Left,Op,Right> l,double x)
 130 {
 131 return X< double,Multiply,X<Left,Op,Right> >(((double) 1/x),l);
 132 }
 133
 134 /*********************************************************/
 135 /*                                                       */
 136 /*                    Classe Valeur                      */
 137 /*                                                       */
 138 /*********************************************************/
 139
 140 // Problèmes : les constructeurs par copie ne sont pas satisfaisants
 141 // Valeur est symboliquement l'argument d'une classe formelle Vecteur<Valeur>
 142 // elle peut etre un réel ou un pointeur sur réel, simulant un vecteur de vecteur
 143
 144 template <class TYPE> Valeur<TYPE>::Valeur():valeurs(NULL),a_detruire(0){}
 145 template <class TYPE> Valeur<TYPE>::Valeur(TYPE * val,int nv):valeurs(val),nbr_valeurs(nv),a_detruire(0){} // A VERIFIER
 146 template <class TYPE> Valeur<TYPE>::Valeur(int n):nbr_valeurs(n),a_detruire(1)
 147 {
 148   valeurs=new TYPE[nbr_valeurs];
 149 }
 150 template <class TYPE> template <typename Left,typename Op,typename Right> Valeur<TYPE>::Valeur(X<Left,Op,Right> expression)
 151 {
 152   for (int i=0;i<nbr_valeurs;i++) valeurs[i]=expression[i];
 153 }
 154 template <class TYPE> template <typename Left,typename Op,typename Right> void Valeur<TYPE>::operator=(X<Left,Op,Right> expression)
 155 {
 156   for (int i=0;i<nbr_valeurs;i++) valeurs[i]=expression[i];
 157 }
 158 template <class TYPE> void Valeur<TYPE>::operator=(Valeur v)
 159 {
 160   for (int i=0;i<nbr_valeurs;i++) valeurs[i]=v[i];
 161 }
 162 template <class TYPE> Valeur<TYPE>::Valeur(const Valeur &v):nbr_valeurs(v.nbr_valeurs)
 163 {
 164   if (v.a_detruire)
 165     {
 166       a_detruire=1;
 167       valeurs=new TYPE[nbr_valeurs];
 168       for (int i=0;i<nbr_valeurs;i++) valeurs[i]=v.valeurs[i];
 169     }
 170   else
 171     {
 172       a_detruire=0;
 173       valeurs=v.valeurs;
 174     }
 175 }
 176 template <class TYPE> Valeur<TYPE>::~Valeur(){if (a_detruire) delete [] valeurs;}
 177 template <class TYPE> TYPE Valeur<TYPE>::operator[](int i){return valeurs[i];}
 178 template <class TYPE> int Valeur<TYPE>::SIZE() const {return nbr_valeurs;}
 179 template <class TYPE> double Valeur<TYPE>::NormeAbs()
 180 {
 181   int i;
 182   double tmp=0;
 183   for (i=0;i<nbr_valeurs;i++) tmp+=fabs(valeurs[i]);
 184   return tmp;
 185 }
 186
 187 template <class TYPE> ostream &operator<<(ostream &os,Valeur<TYPE> v)
 188         {
 189         os<<"("<<flush;
 190         for (int i=0;i<v.SIZE();i++) os<<" "<<v[i]<<flush;
 191         os<<" ) "<<flush;
 192         return os;
 193         }
 194
 195 /*********************************************************/
 196 /*                                                       */
 197 /*               Classe Wrapper_MED_Field                */
 198 /*                                                       */
 199 /*********************************************************/
 200
 201 // c'est la classe de Wrapping sur un objet FIELD<double> MEDMEMOIRE
 202
 203 class Wrapper_MED_Field
 204 {
 205 protected :
 206         int nbr_valeurs;
 207         int nbr_composantes;
 208         double * valeurs;
 209 public :
 210         Wrapper_MED_Field():valeurs(NULL){}
 211         Wrapper_MED_Field(int nv, int nc, double * v):nbr_valeurs(nv),nbr_composantes(nc),valeurs(v)
 212                 {
 213                 }
 214         Wrapper_MED_Field(const MEDMEM::FIELD<double,MEDMEM::FullInterlace> * medfield)
 215                 {
 216                 nbr_valeurs=medfield->getNumberOfValues();
 217                 nbr_composantes=medfield->getNumberOfComponents();
 218                 valeurs=const_cast<double *>(medfield->getValue());
 219                 }
 220         ~Wrapper_MED_Field(){}
 221         inline Valeur<double> operator[](int i)
 222                 {
 223                 return Valeur<double>(&valeurs[nbr_composantes*i],nbr_composantes);
 224                 }
 225         double * Get_Valeurs() {return valeurs;}
 226         inline int Get_Nbr_Valeurs() const {return nbr_valeurs;}
 227         inline int Get_Nbr_Composantes() const {return nbr_composantes;}
 228         friend ostream & operator<<(ostream &os, Wrapper_MED_Field);
 229 };
 230
 231 inline ostream & operator<<(ostream &os, Wrapper_MED_Field wmf)
 232 {
 233 for (int i=0;i<wmf.nbr_valeurs;i++) os<<"Wrapper_MED_Field["<<i<<"] = "<<wmf[i]<<endl;
 234 return os;
 235 }
 236
 237 #endif