LOT7: fix compilation at med_int==int64

[modules/med.git] / src / MEDCalculator / MEDCalculatorDBSliceField.cxx

diff --git a/src/MEDCalculator/MEDCalculatorDBSliceField.cxx b/src/MEDCalculator/MEDCalculatorDBSliceField.cxx
index 0a0327a7633caf52f0d3ec4c4231ec46b3ec8daf..460f2309659474d58c1aa372a150358b5ad8a6ca 100644 (file)
--- a/src/MEDCalculator/MEDCalculatorDBSliceField.cxx
+++ b/src/MEDCalculator/MEDCalculatorDBSliceField.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2016  CEA/DEN, EDF R&D
+// Copyright (C) 2007-2019  CEA/DEN, EDF R&D
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
@@ -95,7 +95,11 @@ MEDCalculatorDBSliceField::~MEDCalculatorDBSliceField()
 MEDCouplingFieldDouble *MEDCalculatorDBSliceField::getField(TypeOfField type, const std::string& fname, const std::string& mname, const std::string& fieldName) const
 {
   if(!_field)
-    _field=ReadField(type,fname.c_str(),mname.c_str(),0,fieldName.c_str(),_iteration,_order);
+    {
+      MCAuto<MEDCouplingField> tmpp(ReadField(type,fname.c_str(),mname.c_str(),0,fieldName.c_str(),_iteration,_order));
+      MCAuto<MEDCouplingFieldDouble> tmp(DynamicCast<MEDCouplingField,MEDCouplingFieldDouble>(tmpp));
+      _field=tmp.retn();
+    }
   return _field;
 }
 
@@ -104,7 +108,7 @@ MEDCouplingFieldDouble *MEDCalculatorDBSliceField::getField(TypeOfField type, co
  */
 MEDCouplingFieldDouble *MEDCalculatorDBSliceField::getFieldWithoutQuestion(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const
 {
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
   return _field->keepSelectedComponents(tIds);
 }
 
@@ -120,20 +124,20 @@ MEDCouplingFieldDouble *MEDCalculatorDBSliceField::buildCstFromThis(double val,
 void MEDCalculatorDBSliceField::assign(const MEDCalculatorDBSliceField* other, int sizeCThis, const MEDCalculatorDBRangeSelection& thisC,
                                     int sizeCOther, const MEDCalculatorDBRangeSelection& otherC)
 {
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
-  std::vector<int> oIds=otherC.getIds(sizeCOther);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> oIds=otherC.getIds(sizeCOther);
   MCAuto<MEDCouplingFieldDouble> f1=other->_field->keepSelectedComponents(oIds);
   _field->setSelectedComponents(f1,tIds);
 }
 
-MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::add(const MEDCalculatorDBSliceField* other, const DataArrayInt *cc, const DataArrayInt *nc,
+MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::add(const MEDCalculatorDBSliceField* other, const DataArrayIdType *cc, const DataArrayIdType *nc,
                                                     int sizeCThis, const MEDCalculatorDBRangeSelection& thisC,
                                                     int sizeCOther, const MEDCalculatorDBRangeSelection& otherC) const
 {
   if(cc!=0 || nc!=0)
     throw INTERP_KERNEL::Exception("Slice::add : not implemented yet node/cell permutation !");
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
-  std::vector<int> oIds=otherC.getIds(sizeCOther);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> oIds=otherC.getIds(sizeCOther);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MCAuto<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
   f2->setMesh(f1->getMesh());
@@ -141,14 +145,14 @@ MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::add(const MEDCalculatorDBS
   return new MEDCalculatorDBSliceField(f3);
 }
 
-MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::substract(const MEDCalculatorDBSliceField* other, const DataArrayInt *cc, const DataArrayInt *nc,
+MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::substract(const MEDCalculatorDBSliceField* other, const DataArrayIdType *cc, const DataArrayIdType *nc,
                                                           int sizeCThis, const MEDCalculatorDBRangeSelection& thisC,
                                                           int sizeCOther, const MEDCalculatorDBRangeSelection& otherC) const
 {
   if(cc!=0 || nc!=0)
     throw INTERP_KERNEL::Exception("Slice::substract : not implemented yet node/cell permutation !");
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
-  std::vector<int> oIds=otherC.getIds(sizeCOther);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> oIds=otherC.getIds(sizeCOther);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MCAuto<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
   f2->setMesh(f1->getMesh());
@@ -156,14 +160,14 @@ MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::substract(const MEDCalcula
   return new MEDCalculatorDBSliceField(f3);
 }
 
-MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::multiply(const MEDCalculatorDBSliceField* other, const DataArrayInt *cc, const DataArrayInt *nc,
+MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::multiply(const MEDCalculatorDBSliceField* other, const DataArrayIdType *cc, const DataArrayIdType *nc,
                                                          int sizeCThis, const MEDCalculatorDBRangeSelection& thisC,
                                                          int sizeCOther, const MEDCalculatorDBRangeSelection& otherC) const
 {
   if(cc!=0 || nc!=0)
     throw INTERP_KERNEL::Exception("Slice::multiply : not implemented yet node/cell permutation !");
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
-  std::vector<int> oIds=otherC.getIds(sizeCOther);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> oIds=otherC.getIds(sizeCOther);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MCAuto<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
   f2->setMesh(f1->getMesh());
@@ -171,14 +175,14 @@ MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::multiply(const MEDCalculat
   return new MEDCalculatorDBSliceField(f3);
 }
 
-MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::divide(const MEDCalculatorDBSliceField* other, const DataArrayInt *cc, const DataArrayInt *nc,
+MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::divide(const MEDCalculatorDBSliceField* other, const DataArrayIdType *cc, const DataArrayIdType *nc,
                                                        int sizeCThis, const MEDCalculatorDBRangeSelection& thisC,
                                                        int sizeCOther, const MEDCalculatorDBRangeSelection& otherC) const
 {
   if(cc!=0 || nc!=0)
     throw INTERP_KERNEL::Exception("Slice::divide : not implemented yet node/cell permutation !");
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
-  std::vector<int> oIds=otherC.getIds(sizeCOther);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> oIds=otherC.getIds(sizeCOther);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MCAuto<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
   f2->setMesh(f1->getMesh());
@@ -189,8 +193,8 @@ MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::divide(const MEDCalculator
 MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::dot(const MEDCalculatorDBSliceField* other, int sizeCThis, const MEDCalculatorDBRangeSelection& thisC,
                                                     int sizeCOther, const MEDCalculatorDBRangeSelection& otherC) const
 {
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
-  std::vector<int> oIds=otherC.getIds(sizeCOther);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> oIds=otherC.getIds(sizeCOther);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MCAuto<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
   f2->setMesh(f1->getMesh());
@@ -201,8 +205,8 @@ MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::dot(const MEDCalculatorDBS
 MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::crossProduct(const MEDCalculatorDBSliceField* other, int sizeCThis, const MEDCalculatorDBRangeSelection& thisC,
                                                              int sizeCOther, const MEDCalculatorDBRangeSelection& otherC) const
 {
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
-  std::vector<int> oIds=otherC.getIds(sizeCOther);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> oIds=otherC.getIds(sizeCOther);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MCAuto<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
   f2->setMesh(f1->getMesh());
@@ -212,7 +216,7 @@ MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::crossProduct(const MEDCalc
 
 MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::doublyContractedProduct(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
 {
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MEDCouplingFieldDouble *f2=f1->doublyContractedProduct();
   return new MEDCalculatorDBSliceField(f2);
@@ -220,7 +224,7 @@ MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::doublyContractedProduct(in
 
 MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::determinant(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
 {
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MEDCouplingFieldDouble *f2=f1->determinant();
   return new MEDCalculatorDBSliceField(f2);
@@ -228,7 +232,7 @@ MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::determinant(int sizeCThis,
 
 MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::eigenValues(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
 {
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MEDCouplingFieldDouble *f2=f1->eigenValues();
   return new MEDCalculatorDBSliceField(f2);
@@ -236,7 +240,7 @@ MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::eigenValues(int sizeCThis,
 
 MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::eigenVectors(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
 {
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MEDCouplingFieldDouble *f2=f1->eigenVectors();
   return new MEDCalculatorDBSliceField(f2);
@@ -244,7 +248,7 @@ MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::eigenVectors(int sizeCThis
 
 MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::inverse(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
 {
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MEDCouplingFieldDouble *f2=f1->inverse();
   return new MEDCalculatorDBSliceField(f2);
@@ -252,7 +256,7 @@ MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::inverse(int sizeCThis, con
 
 MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::trace(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
 {
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MEDCouplingFieldDouble *f2=f1->trace();
   return new MEDCalculatorDBSliceField(f2);
@@ -260,7 +264,7 @@ MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::trace(int sizeCThis, const
 
 MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::deviator(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
 {
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MEDCouplingFieldDouble *f2=f1->deviator();
   return new MEDCalculatorDBSliceField(f2);
@@ -268,7 +272,7 @@ MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::deviator(int sizeCThis, co
 
 MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::magnitude(int sizeCThis, const MEDCalculatorDBRangeSelection& thisC) const throw(INTERP_KERNEL::Exception)
 {
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MEDCouplingFieldDouble *f2=f1->magnitude();
   return new MEDCalculatorDBSliceField(f2);
@@ -276,20 +280,20 @@ MEDCalculatorDBSliceField *MEDCalculatorDBSliceField::magnitude(int sizeCThis, c
 
 void MEDCalculatorDBSliceField::applyFunc(const char *func, int sizeCThis, const MEDCalculatorDBRangeSelection& thisC)
 {
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   f1->applyFunc(func);
   _field->setSelectedComponents(f1,tIds);
 }
 
-bool MEDCalculatorDBSliceField::isEqual(const MEDCalculatorDBSliceField* other, const DataArrayInt *cc, const DataArrayInt *nc,
+bool MEDCalculatorDBSliceField::isEqual(const MEDCalculatorDBSliceField* other, const DataArrayIdType *cc, const DataArrayIdType *nc,
                                      int sizeCThis, const MEDCalculatorDBRangeSelection& thisC,
                                      int sizeCOther, const MEDCalculatorDBRangeSelection& otherC, double prec) const
 {
   if(cc!=0 || nc!=0)
     throw INTERP_KERNEL::Exception("Slice::isEqual : not implemented yet node/cell permutation !");
-  std::vector<int> tIds=thisC.getIds(sizeCThis);
-  std::vector<int> oIds=otherC.getIds(sizeCOther);
+  std::vector<std::size_t> tIds=thisC.getIds(sizeCThis);
+  std::vector<std::size_t> oIds=otherC.getIds(sizeCOther);
   MCAuto<MEDCouplingFieldDouble> f1=_field->keepSelectedComponents(tIds);
   MCAuto<MEDCouplingFieldDouble> f2=other->_field->keepSelectedComponents(oIds);
   f2->setMesh(f1->getMesh());