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.";
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;
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);
{
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++)
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
{
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++)
{
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++)
{
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++)
{
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++)
{
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++)
////////////////////////
-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
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);
}
////////////////////////
