src/MEDCoupling_Swig/MEDCouplingTypemaps.i

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony Geay (CEA/DEN)
  20
  21 #ifndef __MEDCOUPLINGTYPEMAPS_I__
  22 #define __MEDCOUPLINGTYPEMAPS_I__
  23
  24 #include "MEDCouplingDataArrayTypemaps.i"
  25 #include "MEDCouplingUMesh.hxx"
  26 #include "MEDCouplingCMesh.hxx"
  27 #include "MEDCouplingIMesh.hxx"
  28 #include "MEDCouplingCurveLinearMesh.hxx"
  29 #include "MEDCouplingMappedExtrudedMesh.hxx"
  30 #include "MEDCoupling1GTUMesh.hxx"
  31 #include "MEDCouplingFieldDiscretization.hxx"
  32 #include "MEDCouplingMultiFields.hxx"
  33 #include "MEDCouplingPartDefinition.hxx"
  34 #include "MEDCouplingCartesianAMRMesh.hxx"
  35
  36 static PyObject *convertMesh(MEDCoupling::MEDCouplingMesh *mesh, int owner) throw(INTERP_KERNEL::Exception)
  37 {
  38   PyObject *ret=0;
  39   if(!mesh)
  40     {
  41       Py_XINCREF(Py_None);
  42       return Py_None;
  43     }
  44   if(dynamic_cast<MEDCoupling::MEDCouplingUMesh *>(mesh))
  45     ret=SWIG_NewPointerObj((void*)mesh,SWIGTYPE_p_MEDCoupling__MEDCouplingUMesh,owner);
  46   if(dynamic_cast<MEDCoupling::MEDCoupling1SGTUMesh *>(mesh))
  47     ret=SWIG_NewPointerObj((void*)mesh,SWIGTYPE_p_MEDCoupling__MEDCoupling1SGTUMesh,owner);
  48   if(dynamic_cast<MEDCoupling::MEDCoupling1DGTUMesh *>(mesh))
  49     ret=SWIG_NewPointerObj((void*)mesh,SWIGTYPE_p_MEDCoupling__MEDCoupling1DGTUMesh,owner);
  50   if(dynamic_cast<MEDCoupling::MEDCouplingMappedExtrudedMesh *>(mesh))
  51     ret=SWIG_NewPointerObj((void*)mesh,SWIGTYPE_p_MEDCoupling__MEDCouplingMappedExtrudedMesh,owner);
  52   if(dynamic_cast<MEDCoupling::MEDCouplingCMesh *>(mesh))
  53     ret=SWIG_NewPointerObj((void*)mesh,SWIGTYPE_p_MEDCoupling__MEDCouplingCMesh,owner);
  54   if(dynamic_cast<MEDCoupling::MEDCouplingCurveLinearMesh *>(mesh))
  55     ret=SWIG_NewPointerObj((void*)mesh,SWIGTYPE_p_MEDCoupling__MEDCouplingCurveLinearMesh,owner);
  56   if(dynamic_cast<MEDCoupling::MEDCouplingIMesh *>(mesh))
  57     ret=SWIG_NewPointerObj((void*)mesh,SWIGTYPE_p_MEDCoupling__MEDCouplingIMesh,owner);
  58   if(!ret)
  59     throw INTERP_KERNEL::Exception("Not recognized type of mesh on downcast !");
  60   return ret;
  61 }
  62
  63 static PyObject *convertFieldDiscretization(MEDCoupling::MEDCouplingFieldDiscretization *fd, int owner) throw(INTERP_KERNEL::Exception)
  64 {
  65   PyObject *ret=0;
  66   if(!fd)
  67     {
  68       Py_XINCREF(Py_None);
  69       return Py_None;
  70     }
  71   if(dynamic_cast<MEDCoupling::MEDCouplingFieldDiscretizationP0 *>(fd))
  72     ret=SWIG_NewPointerObj(reinterpret_cast<void*>(fd),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDiscretizationP0,owner);
  73   if(dynamic_cast<MEDCoupling::MEDCouplingFieldDiscretizationP1 *>(fd))
  74     ret=SWIG_NewPointerObj(reinterpret_cast<void*>(fd),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDiscretizationP1,owner);
  75   if(dynamic_cast<MEDCoupling::MEDCouplingFieldDiscretizationGauss *>(fd))
  76     ret=SWIG_NewPointerObj(reinterpret_cast<void*>(fd),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDiscretizationGauss,owner);
  77   if(dynamic_cast<MEDCoupling::MEDCouplingFieldDiscretizationGaussNE *>(fd))
  78     ret=SWIG_NewPointerObj(reinterpret_cast<void*>(fd),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDiscretizationGaussNE,owner);
  79   if(dynamic_cast<MEDCoupling::MEDCouplingFieldDiscretizationKriging *>(fd))
  80     ret=SWIG_NewPointerObj(reinterpret_cast<void*>(fd),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDiscretizationKriging,owner);
  81   if(!ret)
  82     throw INTERP_KERNEL::Exception("Not recognized type of field discretization on downcast !");
  83   return ret;
  84 }
  85
  86 static PyObject* convertMultiFields(MEDCoupling::MEDCouplingMultiFields *mfs, int owner) throw(INTERP_KERNEL::Exception)
  87 {
  88   PyObject *ret=0;
  89   if(!mfs)
  90     {
  91       Py_XINCREF(Py_None);
  92       return Py_None;
  93     }
  94   if(dynamic_cast<MEDCoupling::MEDCouplingFieldOverTime *>(mfs))
  95     ret=SWIG_NewPointerObj((void*)mfs,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldOverTime,owner);
  96   else
  97     ret=SWIG_NewPointerObj((void*)mfs,SWIGTYPE_p_MEDCoupling__MEDCouplingMultiFields,owner);
  98   return ret;
  99 }
 100
 101 static PyObject *convertCartesianAMRMesh(MEDCoupling::MEDCouplingCartesianAMRMeshGen *mesh, int owner) throw(INTERP_KERNEL::Exception)
 102 {
 103   if(!mesh)
 104     {
 105       Py_XINCREF(Py_None);
 106       return Py_None;
 107     }
 108   if(dynamic_cast<MEDCoupling::MEDCouplingCartesianAMRMeshSub *>(mesh))
 109     {
 110       return SWIG_NewPointerObj(reinterpret_cast<void*>(mesh),SWIGTYPE_p_MEDCoupling__MEDCouplingCartesianAMRMeshSub,owner);
 111     }
 112   if(dynamic_cast<MEDCoupling::MEDCouplingCartesianAMRMesh *>(mesh))
 113     {
 114       return SWIG_NewPointerObj(reinterpret_cast<void*>(mesh),SWIGTYPE_p_MEDCoupling__MEDCouplingCartesianAMRMesh,owner);
 115     }
 116   throw INTERP_KERNEL::Exception("convertCartesianAMRMesh wrap : unrecognized type of cartesian AMR mesh !");
 117 }
 118
 119 static PyObject *convertDataForGodFather(MEDCoupling::MEDCouplingDataForGodFather *data, int owner) throw(INTERP_KERNEL::Exception)
 120 {
 121   if(!data)
 122     {
 123       Py_XINCREF(Py_None);
 124       return Py_None;
 125     }
 126   if(dynamic_cast<MEDCoupling::MEDCouplingAMRAttribute *>(data))
 127     {
 128       return SWIG_NewPointerObj(reinterpret_cast<void*>(data),SWIGTYPE_p_MEDCoupling__MEDCouplingAMRAttribute,owner);
 129     }
 130   throw INTERP_KERNEL::Exception("convertDataForGodFather wrap : unrecognized data type for AMR !");
 131 }
 132
 133 static PyObject *convertCartesianAMRPatch(MEDCoupling::MEDCouplingCartesianAMRPatchGen *patch, int owner) throw(INTERP_KERNEL::Exception)
 134 {
 135   if(!patch)
 136     {
 137       Py_XINCREF(Py_None);
 138       return Py_None;
 139     }
 140   if(dynamic_cast<MEDCoupling::MEDCouplingCartesianAMRPatchGF *>(patch))
 141     {
 142       return SWIG_NewPointerObj(reinterpret_cast<void*>(patch),SWIGTYPE_p_MEDCoupling__MEDCouplingCartesianAMRPatchGF,owner);
 143     }
 144   if(dynamic_cast<MEDCoupling::MEDCouplingCartesianAMRPatch *>(patch))
 145     {
 146       return SWIG_NewPointerObj(reinterpret_cast<void*>(patch),SWIGTYPE_p_MEDCoupling__MEDCouplingCartesianAMRPatch,owner);
 147     }
 148   throw INTERP_KERNEL::Exception("convertCartesianAMRPatch wrap : unrecognized type of cartesian AMR patch !");
 149 }
 150
 151 static MEDCoupling::MEDCouplingFieldDouble *MEDCoupling_MEDCouplingFieldDouble___add__Impl(MEDCoupling::MEDCouplingFieldDouble *self, PyObject *obj) throw(INTERP_KERNEL::Exception)
 152 {
 153   const char msg[]="Unexpected situation in MEDCouplingFieldDouble.__add__ ! Expecting a not null MEDCouplingFieldDouble or DataArrayDouble or DataArrayDoubleTuple instance, or a list of double, or a double.";
 154   const char msg2[]="in MEDCouplingFieldDouble.__add__ : self field has no Array of values set !";
 155   void *argp;
 156   //
 157   if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
 158     {
 159       MEDCoupling::MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
 160       if(other)
 161         return (*self)+(*other);
 162       else
 163         throw INTERP_KERNEL::Exception(msg);
 164     }
 165   //
 166   double val;
 167   MEDCoupling::DataArrayDouble *a;
 168   MEDCoupling::DataArrayDoubleTuple *aa;
 169   std::vector<double> bb;
 170   int sw;
 171   convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
 172   switch(sw)
 173     {
 174     case 1:
 175       {
 176         if(!self->getArray())
 177           throw INTERP_KERNEL::Exception(msg2);
 178         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=self->getArray()->deepCopy();
 179         ret->applyLin(1.,val);
 180         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 181         ret2->setArray(ret);
 182         return ret2.retn();
 183       }
 184     case 2:
 185       {
 186         if(!self->getArray())
 187           throw INTERP_KERNEL::Exception(msg2);
 188         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=MEDCoupling::DataArrayDouble::Add(self->getArray(),a);
 189         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 190         ret2->setArray(ret);
 191         return ret2.retn();
 192       }
 193     case 3:
 194       {
 195         if(!self->getArray())
 196           throw INTERP_KERNEL::Exception(msg2);
 197         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
 198         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=MEDCoupling::DataArrayDouble::Add(self->getArray(),aaa);
 199         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 200         ret2->setArray(ret);
 201         return ret2.retn();
 202       }
 203     case 4:
 204       {
 205         if(!self->getArray())
 206           throw INTERP_KERNEL::Exception(msg2);
 207         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> aaa=MEDCoupling::DataArrayDouble::New(); aaa->useArray(&bb[0],false,MEDCoupling::CPP_DEALLOC,1,(int)bb.size());
 208         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=MEDCoupling::DataArrayDouble::Add(self->getArray(),aaa);
 209         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 210         ret2->setArray(ret);
 211         return ret2.retn();
 212       }
 213     default:
 214       { throw INTERP_KERNEL::Exception(msg); }
 215     }
 216 }
 217
 218 static MEDCoupling::MEDCouplingFieldDouble *MEDCoupling_MEDCouplingFieldDouble___radd__Impl(MEDCoupling::MEDCouplingFieldDouble *self, PyObject *obj) throw(INTERP_KERNEL::Exception)
 219 {
 220   return MEDCoupling_MEDCouplingFieldDouble___add__Impl(self,obj);
 221 }
 222
 223 static MEDCoupling::MEDCouplingFieldDouble *MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(MEDCoupling::MEDCouplingFieldDouble *self, PyObject *obj) throw(INTERP_KERNEL::Exception)
 224 {
 225   const char msg[]="Unexpected situation in MEDCouplingFieldDouble.__rsub__ ! Expecting a not null MEDCouplingFieldDouble or DataArrayDouble or DataArrayDoubleTuple instance, or a list of double, or a double.";
 226   const char msg2[]="in MEDCouplingFieldDouble.__rsub__ : self field has no Array of values set !";
 227   void *argp;
 228   //
 229   if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
 230     {
 231       MEDCoupling::MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
 232       if(other)
 233         return (*other)-(*self);
 234       else
 235         throw INTERP_KERNEL::Exception(msg);
 236     }
 237   //
 238   double val;
 239   MEDCoupling::DataArrayDouble *a;
 240   MEDCoupling::DataArrayDoubleTuple *aa;
 241   std::vector<double> bb;
 242   int sw;
 243   convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
 244   switch(sw)
 245     {
 246     case 1:
 247       {
 248         if(!self->getArray())
 249           throw INTERP_KERNEL::Exception(msg2);
 250         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=self->getArray()->deepCopy();
 251         ret->applyLin(-1.,val);
 252         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 253         ret2->setArray(ret);
 254         return ret2.retn();
 255       }
 256     case 2:
 257       {
 258         if(!self->getArray())
 259           throw INTERP_KERNEL::Exception(msg2);
 260         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=MEDCoupling::DataArrayDouble::Substract(a,self->getArray());
 261         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 262         ret2->setArray(ret);
 263         return ret2.retn();
 264       }
 265     case 3:
 266       {
 267         if(!self->getArray())
 268           throw INTERP_KERNEL::Exception(msg2);
 269         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
 270         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=MEDCoupling::DataArrayDouble::Substract(aaa,self->getArray());
 271         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 272         ret2->setArray(ret);
 273         return ret2.retn();
 274       }
 275     case 4:
 276       {
 277         if(!self->getArray())
 278           throw INTERP_KERNEL::Exception(msg2);
 279         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> aaa=MEDCoupling::DataArrayDouble::New(); aaa->useArray(&bb[0],false,MEDCoupling::CPP_DEALLOC,1,(int)bb.size());
 280         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=MEDCoupling::DataArrayDouble::Substract(aaa,self->getArray());
 281         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 282         ret2->setArray(ret);
 283         return ret2.retn();
 284       }
 285     default:
 286       { throw INTERP_KERNEL::Exception(msg); }
 287     }
 288 }
 289
 290 static MEDCoupling::MEDCouplingFieldDouble *MEDCoupling_MEDCouplingFieldDouble___mul__Impl(MEDCoupling::MEDCouplingFieldDouble *self, PyObject *obj) throw(INTERP_KERNEL::Exception)
 291 {
 292   const char msg[]="Unexpected situation in MEDCouplingFieldDouble.__mul__ ! Expecting a not null MEDCouplingFieldDouble or DataArrayDouble or DataArrayDoubleTuple instance, or a list of double, or a double.";
 293   const char msg2[]="in MEDCouplingFieldDouble.__mul__ : self field has no Array of values set !";
 294   void *argp;
 295   //
 296   if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
 297     {
 298       MEDCoupling::MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
 299       if(other)
 300         return (*self)*(*other);
 301       else
 302         throw INTERP_KERNEL::Exception(msg);
 303     }
 304   //
 305   double val;
 306   MEDCoupling::DataArrayDouble *a;
 307   MEDCoupling::DataArrayDoubleTuple *aa;
 308   std::vector<double> bb;
 309   int sw;
 310   convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
 311   switch(sw)
 312     {
 313     case 1:
 314       {
 315         if(!self->getArray())
 316           throw INTERP_KERNEL::Exception(msg2);
 317         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=self->getArray()->deepCopy();
 318         ret->applyLin(val,0.);
 319         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 320         ret2->setArray(ret);
 321         return ret2.retn();
 322       }
 323     case 2:
 324       {
 325         if(!self->getArray())
 326           throw INTERP_KERNEL::Exception(msg2);
 327         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=MEDCoupling::DataArrayDouble::Multiply(self->getArray(),a);
 328         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 329         ret2->setArray(ret);
 330         return ret2.retn();
 331       }
 332     case 3:
 333       {
 334         if(!self->getArray())
 335           throw INTERP_KERNEL::Exception(msg2);
 336         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
 337         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=MEDCoupling::DataArrayDouble::Multiply(self->getArray(),aaa);
 338         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 339         ret2->setArray(ret);
 340         return ret2.retn();
 341       }
 342     case 4:
 343       {
 344         if(!self->getArray())
 345           throw INTERP_KERNEL::Exception(msg2);
 346         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> aaa=MEDCoupling::DataArrayDouble::New(); aaa->useArray(&bb[0],false,MEDCoupling::CPP_DEALLOC,1,(int)bb.size());
 347         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=MEDCoupling::DataArrayDouble::Multiply(self->getArray(),aaa);
 348         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 349         ret2->setArray(ret);
 350         return ret2.retn();
 351       }
 352     default:
 353       { throw INTERP_KERNEL::Exception(msg); }
 354     }
 355 }
 356
 357 MEDCoupling::MEDCouplingFieldDouble *MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(MEDCoupling::MEDCouplingFieldDouble *self, PyObject *obj) throw(INTERP_KERNEL::Exception)
 358 {
 359   return MEDCoupling_MEDCouplingFieldDouble___mul__Impl(self,obj);
 360 }
 361
 362 MEDCoupling::MEDCouplingFieldDouble *MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(MEDCoupling::MEDCouplingFieldDouble *self, PyObject *obj) throw(INTERP_KERNEL::Exception)
 363 {
 364   const char msg[]="Unexpected situation in MEDCouplingFieldDouble.__rdiv__ ! Expecting a not null MEDCouplingFieldDouble or DataArrayDouble or DataArrayDoubleTuple instance, or a list of double, or a double.";
 365   const char msg2[]="in MEDCouplingFieldDouble.__div__ : self field has no Array of values set !";
 366   void *argp;
 367   //
 368   if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
 369     {
 370       MEDCoupling::MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
 371       if(other)
 372         return (*other)/(*self);
 373       else
 374         throw INTERP_KERNEL::Exception(msg);
 375     }
 376   //
 377   double val;
 378   MEDCoupling::DataArrayDouble *a;
 379   MEDCoupling::DataArrayDoubleTuple *aa;
 380   std::vector<double> bb;
 381   int sw;
 382   convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
 383   switch(sw)
 384     {
 385     case 1:
 386       {
 387         if(!self->getArray())
 388           throw INTERP_KERNEL::Exception(msg2);
 389         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=self->getArray()->deepCopy();
 390         ret->applyInv(val);
 391         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 392         ret2->setArray(ret);
 393         return ret2.retn();
 394       }
 395     case 2:
 396       {
 397         if(!self->getArray())
 398           throw INTERP_KERNEL::Exception(msg2);
 399         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=MEDCoupling::DataArrayDouble::Divide(a,self->getArray());
 400         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 401         ret2->setArray(ret);
 402         return ret2.retn();
 403       }
 404     case 3:
 405       {
 406         if(!self->getArray())
 407           throw INTERP_KERNEL::Exception(msg2);
 408         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
 409         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=MEDCoupling::DataArrayDouble::Divide(aaa,self->getArray());
 410         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 411         ret2->setArray(ret);
 412         return ret2.retn();
 413       }
 414     case 4:
 415       {
 416         if(!self->getArray())
 417           throw INTERP_KERNEL::Exception(msg2);
 418         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> aaa=MEDCoupling::DataArrayDouble::New(); aaa->useArray(&bb[0],false,MEDCoupling::CPP_DEALLOC,1,(int)bb.size());
 419         MEDCoupling::MCAuto<MEDCoupling::DataArrayDouble> ret=MEDCoupling::DataArrayDouble::Divide(aaa,self->getArray());
 420         MEDCoupling::MCAuto<MEDCoupling::MEDCouplingFieldDouble> ret2=self->clone(false);
 421         ret2->setArray(ret);
 422         return ret2.retn();
 423       }
 424     default:
 425       { throw INTERP_KERNEL::Exception(msg); }
 426     }
 427 }
 428
 429 #endif