X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FMEDCoupling%2FMEDCouplingTimeDiscretization.cxx;h=40f7921bd5f60c6e5a0a8a3b61d0e1c3683045a8;hb=69fd460430f4507abe451a07ff684688c3ae15e8;hp=dd334c4eb53ad2680b1f3621bc83fbfd535eeeb2;hpb=7f53ba0ad6eebec56c2936b923ac3ae728f41074;p=tools%2Fmedcoupling.git

diff --git a/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx b/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx
index dd334c4eb..40f7921bd 100644
--- a/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx
+++ b/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx
@@ -29,10 +29,11 @@
 
 using namespace MEDCoupling;
 
-template class MEDCouplingTimeDiscretizationTemplate<double>;
-template class MEDCouplingTimeDiscretizationTemplate<int>;
-
-const char MEDCouplingTimeDiscretizationInt::REPR[]="One time label.";
+template class MEDCoupling::MEDCouplingTimeDiscretizationTemplate<double>;
+template class MEDCoupling::MEDCouplingTimeDiscretizationTemplate<float>;
+template class MEDCoupling::MEDCouplingTimeDiscretizationSimple<float>;
+template class MEDCoupling::MEDCouplingTimeDiscretizationTemplate<int>;
+template class MEDCoupling::MEDCouplingTimeDiscretizationSimple<int>;
 
 const char MEDCouplingNoTimeLabel::EXCEPTION_MSG[]="MEDCouplingNoTimeLabel::setTime : no time info attached.";
 
@@ -117,73 +118,6 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::buildNewTimeReprFr
   return ret;
 }
 
-void MEDCouplingTimeDiscretization::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
-{
-  if(_array)
-    {
-      tinyInfo.push_back(_array->getNumberOfTuples());
-      tinyInfo.push_back(_array->getNumberOfComponents());
-    }
-  else
-    {
-      tinyInfo.push_back(-1);
-      tinyInfo.push_back(-1);
-    }
-}
-
-void MEDCouplingTimeDiscretization::resizeForUnserialization(const std::vector<int>& tinyInfoI, std::vector<DataArrayDouble *>& arrays)
-{
-  arrays.resize(1);
-  if(_array!=0)
-    _array->decrRef();
-  DataArrayDouble *arr=0;
-  if(tinyInfoI[0]!=-1 && tinyInfoI[1]!=-1)
-    {
-      arr=DataArrayDouble::New();
-      arr->alloc(tinyInfoI[0],tinyInfoI[1]);
-    }
-  _array=arr;
-  arrays[0]=arr;
-}
-
-void MEDCouplingTimeDiscretization::checkForUnserialization(const std::vector<int>& tinyInfoI, const std::vector<DataArrayDouble *>& arrays)
-{
-  static const char MSG[]="MEDCouplingTimeDiscretization::checkForUnserialization : arrays in input is expected to have size one !";
-  if(arrays.size()!=1)
-    throw INTERP_KERNEL::Exception(MSG);
-  if(_array!=0)
-    _array->decrRef();
-  _array=0;
-  if(tinyInfoI[0]!=-1 && tinyInfoI[1]!=-1)
-    {
-      if(!arrays[0])
-        throw INTERP_KERNEL::Exception(MSG);
-      arrays[0]->checkNbOfTuplesAndComp(tinyInfoI[0],tinyInfoI[1],MSG);
-      _array=arrays[0];
-      _array->incrRef();
-    }
-}
-
-void MEDCouplingTimeDiscretization::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<double>& tinyInfoD, const std::vector<std::string>& tinyInfoS)
-{
-  _time_tolerance=tinyInfoD[0];
-  int nbOfCompo=_array->getNumberOfComponents();
-  for(int i=0;i<nbOfCompo;i++)
-    _array->setInfoOnComponent(i,tinyInfoS[i]);
-}
-
-void MEDCouplingTimeDiscretization::getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const
-{
-  tinyInfo.push_back(_time_tolerance);
-}
-
-void MEDCouplingTimeDiscretization::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
-{
-  int nbOfCompo=_array->getNumberOfComponents();
-  for(int i=0;i<nbOfCompo;i++)
-    tinyInfo.push_back(_array->getInfoOnComponent(i));
-}
-
 bool MEDCouplingTimeDiscretization::isBefore(const MEDCouplingTimeDiscretization *other) const
 {
   int iteration,order;
@@ -200,9 +134,28 @@ bool MEDCouplingTimeDiscretization::isStrictlyBefore(const MEDCouplingTimeDiscre
   return time1<time2;
 }
 
+MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::computeVectorFieldCyl(const DataArrayDouble *coords, const double center[3], const double vect[3]) const
+{
+  MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
+  ret->setTimeUnit(getTimeUnit());
+  std::vector<DataArrayDouble *> arrays;
+  getArrays(arrays);
+  std::vector< MCAuto<DataArrayDouble> > arrays2(arrays.size());
+  for(std::size_t j=0;j<arrays.size();j++)
+    {
+      if(arrays[j])
+        arrays2[j]=arrays[j]->fromCartToCylGiven(coords,center,vect);
+    }
+  std::vector<DataArrayDouble *> arrays3(arrays.size());
+  for(std::size_t j=0;j<arrays.size();j++)
+    arrays3[j]=arrays2[j];
+  ret->setArrays(arrays3,0);
+  return ret;
+}
+
 MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::doublyContractedProduct() const
 {
-  MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+  MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
   ret->setTimeUnit(getTimeUnit());
   std::vector<DataArrayDouble *> arrays;
   getArrays(arrays);
@@ -211,8 +164,6 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::doublyContractedPr
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->doublyContractedProduct();
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
@@ -230,13 +181,11 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::determinant() cons
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->determinant();
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
     arrays3[j]=arrays2[j];
-  MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+  MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
   ret->setTimeUnit(getTimeUnit());
   ret->setArrays(arrays3,0);
   return ret;
@@ -251,13 +200,11 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::eigenValues() cons
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->eigenValues();
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
     arrays3[j]=arrays2[j];
-  MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+  MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
   ret->setTimeUnit(getTimeUnit());
   ret->setArrays(arrays3,0);
   return ret;
@@ -272,13 +219,11 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::eigenVectors() con
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->eigenVectors();
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
     arrays3[j]=arrays2[j];
-  MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+  MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
   ret->setTimeUnit(getTimeUnit());
   ret->setArrays(arrays3,0);
   return ret;
@@ -293,13 +238,11 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::inverse() const
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->inverse();
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
     arrays3[j]=arrays2[j];
-  MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+  MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
   ret->setTimeUnit(getTimeUnit());
   ret->setArrays(arrays3,0);
   return ret;
@@ -314,13 +257,11 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::trace() const
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->trace();
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
     arrays3[j]=arrays2[j];
-  MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+  MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
   ret->setTimeUnit(getTimeUnit());
   ret->setArrays(arrays3,0);
   return ret;
@@ -335,13 +276,11 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::deviator() const
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->deviator();
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
     arrays3[j]=arrays2[j];
-  MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+  MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
   ret->setTimeUnit(getTimeUnit());
   ret->setArrays(arrays3,0);
   return ret;
@@ -356,13 +295,11 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::magnitude() const
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->magnitude();
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
     arrays3[j]=arrays2[j];
-  MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+  MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
   ret->setTimeUnit(getTimeUnit());
   ret->setArrays(arrays3,0);
   return ret;
@@ -377,13 +314,11 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::negate() const
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->negate();
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
     arrays3[j]=arrays2[j];
-  MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+  MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
   ret->setTimeUnit(getTimeUnit());
   ret->setArrays(arrays3,0);
   return ret;
@@ -398,13 +333,11 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::maxPerTuple() cons
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->maxPerTuple();
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
     arrays3[j]=arrays2[j];
-  MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+  MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
   ret->setTimeUnit(getTimeUnit());
   ret->setArrays(arrays3,0);
   return ret;
@@ -419,13 +352,11 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::keepSelectedCompon
     {
       if(arrays[j])
         arrays2[j]=static_cast<DataArrayDouble *>(arrays[j]->keepSelectedComponents(compoIds));
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
     arrays3[j]=arrays2[j];
-  MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+  MEDCouplingTimeDiscretization *ret(MEDCouplingTimeDiscretization::New(getEnum()));
   ret->setTimeUnit(getTimeUnit());
   ret->setArrays(arrays3,0);
   return ret;
@@ -456,8 +387,6 @@ void MEDCouplingTimeDiscretization::changeNbOfComponents(int newNbOfComp, double
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->changeNbOfComponents(newNbOfComp,dftValue);
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
@@ -562,8 +491,6 @@ void MEDCouplingTimeDiscretization::applyFunc(int nbOfComp, FunctionToEvaluate f
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->applyFunc(nbOfComp,func);
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
@@ -598,8 +525,6 @@ void MEDCouplingTimeDiscretization::applyFuncCompo(int nbOfComp, const std::stri
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->applyFuncCompo(nbOfComp,func);
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
@@ -616,8 +541,6 @@ void MEDCouplingTimeDiscretization::applyFuncNamedCompo(int nbOfComp, const std:
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->applyFuncNamedCompo(nbOfComp,varsOrder,func);
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
@@ -634,8 +557,6 @@ void MEDCouplingTimeDiscretization::applyFunc(const std::string& func)
     {
       if(arrays[j])
         arrays2[j]=arrays[j]->applyFunc(func);
-      else
-        arrays2[j]=0;
     }
   std::vector<DataArrayDouble *> arrays3(arrays.size());
   for(std::size_t j=0;j<arrays.size();j++)
@@ -773,20 +694,8 @@ void MEDCouplingTimeKeeper::checkTimePresence(double time, double eps) const
 
 ////////////////////////
 
-MEDCouplingTimeDiscretizationInt::MEDCouplingTimeDiscretizationInt()
-{
-}
-
-MEDCouplingTimeDiscretizationInt::MEDCouplingTimeDiscretizationInt(const MEDCouplingTimeDiscretizationInt& other, bool deepCopy):MEDCouplingTimeDiscretizationTemplate<int>(other,deepCopy),_tk(other._tk)
-{
-}
-
-std::string MEDCouplingTimeDiscretizationInt::getStringRepr() const
+MEDCouplingTimeDiscretizationInt::MEDCouplingTimeDiscretizationInt(const MEDCouplingTimeDiscretizationInt& other, bool deepCopy):MEDCouplingTimeDiscretizationSimple<int>(other,deepCopy)
 {
-  std::ostringstream stream;
-  stream << REPR << " Time is defined by iteration=" << _tk.getIteration() << " order=" << _tk.getOrder() << " and time=" << _tk.getTimeValue() << ".";
-  stream << "\nTime unit is : \"" << _time_unit << "\"";
-  return stream.str();
 }
 
 MEDCouplingTimeDiscretizationInt *MEDCouplingTimeDiscretizationInt::performCopyOrIncrRef(bool deepCopy) const
@@ -844,29 +753,65 @@ bool MEDCouplingTimeDiscretizationInt::isEqualWithoutConsideringStr(const MEDCou
   return _array->isEqualWithoutConsideringStr(*(other->getArray()));
 }
 
-double MEDCouplingTimeDiscretizationInt::getEndTime(int& iteration, int& order) const
+////////////////////////
+
+MEDCouplingTimeDiscretizationFloat::MEDCouplingTimeDiscretizationFloat(const MEDCouplingTimeDiscretizationFloat& other, bool deepCopy):MEDCouplingTimeDiscretizationSimple<float>(other,deepCopy)
 {
-  throw INTERP_KERNEL::Exception("getEndTime : invalid for this type of time discr !");
 }
 
-void MEDCouplingTimeDiscretizationInt::setEndIteration(int it)
+MEDCouplingTimeDiscretizationFloat *MEDCouplingTimeDiscretizationFloat::performCopyOrIncrRef(bool deepCopy) const
 {
-  throw INTERP_KERNEL::Exception("setEndIteration : invalid for this type of time discr !");
+  return new MEDCouplingTimeDiscretizationFloat(*this,deepCopy);
 }
 
-void MEDCouplingTimeDiscretizationInt::setEndOrder(int order)
+MEDCouplingTimeDiscretizationFloat *MEDCouplingTimeDiscretizationFloat::New(TypeOfTimeDiscretization type)
 {
-  throw INTERP_KERNEL::Exception("setEndOrder : invalid for this type of time discr !");
+  switch(type)
+  {
+    case MEDCouplingTimeDiscretizationFloat::DISCRETIZATION:
+      return new MEDCouplingTimeDiscretizationFloat;
+    default:
+      throw INTERP_KERNEL::Exception("Time discretization not implemented yet for intergers !");
+  }
 }
 
-void MEDCouplingTimeDiscretizationInt::setEndTimeValue(double time)
+bool MEDCouplingTimeDiscretizationFloat::isEqualIfNotWhy(const MEDCouplingTimeDiscretizationTemplate<float> *other, float prec, std::string& reason) const
 {
-  throw INTERP_KERNEL::Exception("setEndTimeValue : invalid for this type of time discr !");
+  if(prec!=0)
+    throw INTERP_KERNEL::Exception("isEqualIfNotWhy : only precision equal to 0 supported for int !");
+  if(!other)
+    {
+      reason="Time discretization is NULL.";
+      return false;
+    }
+  const MEDCouplingTimeDiscretizationFloat *otherC(dynamic_cast<const MEDCouplingTimeDiscretizationFloat *>(other));
+  if(!otherC)
+    throw INTERP_KERNEL::Exception("isEqualIfNotWhy : other is not a MEDCouplingTimeDiscretizationFloat !");
+  if(!MEDCouplingTimeDiscretizationTemplate<float>::areStrictlyCompatible(other,reason))
+    return false;
+  if(!_tk.isEqualIfNotWhy(otherC->_tk,_time_tolerance,reason))
+    return false;
+  if(_array==other->getArray())
+    return true;
+  return _array->isEqualIfNotWhy(*other->getArray(),prec,reason);
 }
 
-void MEDCouplingTimeDiscretizationInt::setEndTime(double time, int iteration, int order)
+bool MEDCouplingTimeDiscretizationFloat::isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretizationTemplate<float> *other, float prec) const
 {
-  throw INTERP_KERNEL::Exception("setEndTime : invalid for this type of time discr !");
+  if(prec!=0)
+    throw INTERP_KERNEL::Exception("MEDCouplingTimeDiscretizationFloat::isEqualWithoutConsideringStr : only precision 0 is supported !");
+  const MEDCouplingTimeDiscretizationFloat *otherC(dynamic_cast<const MEDCouplingTimeDiscretizationFloat *>(other));
+  if(!otherC)
+    throw INTERP_KERNEL::Exception("isEqualWithoutConsideringStr : other is not a MEDCouplingTimeDiscretizationFloat !");
+  std::string tmp;
+  if(!areStrictlyCompatible(other,tmp))
+    return false;
+  std::string reason;
+  if(!_tk.isEqualIfNotWhy(otherC->_tk,_time_tolerance,reason))
+    return false;
+  if(_array==other->getArray())
+    return true;
+  return _array->isEqualWithoutConsideringStr(*(other->getArray()),prec);
 }
 
 ////////////////////////