#define __MEDCOUPLINGTIMEDISCRETIZATION_TXX__
#include "MEDCouplingTimeDiscretization.hxx"
+#include "MEDCouplingMemArray.txx"
#include <cmath>
#include <sstream>
namespace MEDCoupling
{
+ template<class T>
+ const char MEDCouplingTimeDiscretizationSimple<T>::REPR[]="One time label.";
+
template<class T>
const double MEDCouplingTimeDiscretizationTemplate<T>::TIME_TOLERANCE_DFT=1.e-12;
if(_array)
_array->decrRef();
}
+
+ template<class T>
+ void MEDCouplingTimeDiscretizationTemplate<T>::setEndArray(typename Traits<T>::ArrayType *array, TimeLabel *owner)
+ {
+ throw INTERP_KERNEL::Exception("setEndArray not available for this type of time discretization !");
+ }
+
+ template<class T>
+ void MEDCouplingTimeDiscretizationTemplate<T>::setArrays(const std::vector<typename Traits<T>::ArrayType *>& arrays, TimeLabel *owner)
+ {
+ if(arrays.size()!=1)
+ throw INTERP_KERNEL::Exception("MEDCouplingTimeDiscretization::setArrays : number of arrays must be one.");
+ setArray(arrays.back(),owner);
+ }
+
+ template<class T>
+ const typename Traits<T>::ArrayType *MEDCouplingTimeDiscretizationTemplate<T>::getEndArray() const
+ {
+ throw INTERP_KERNEL::Exception("getEndArray not available for this type of time discretization !");
+ }
+
+ template<class T>
+ typename Traits<T>::ArrayType *MEDCouplingTimeDiscretizationTemplate<T>::getEndArray()
+ {
+ throw INTERP_KERNEL::Exception("getEndArray not available for this type of time discretization !");
+ }
+
+ template<class T>
+ void MEDCouplingTimeDiscretizationTemplate<T>::getArrays(std::vector<typename Traits<T>::ArrayType *>& arrays) const
+ {
+ arrays.resize(1);
+ arrays[0]=_array;
+ }
+
+ template<class T>
+ void MEDCouplingTimeDiscretizationTemplate<T>::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);
+ }
+ }
+
+ template<class T>
+ void MEDCouplingTimeDiscretizationTemplate<T>::getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const
+ {
+ tinyInfo.push_back(_time_tolerance);
+ }
+
+ template<class T>
+ void MEDCouplingTimeDiscretizationTemplate<T>::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
+ {
+ int nbOfCompo(_array->getNumberOfComponents());
+ for(int i=0;i<nbOfCompo;i++)
+ tinyInfo.push_back(_array->getInfoOnComponent(i));
+ }
+
+ template<class T>
+ void MEDCouplingTimeDiscretizationTemplate<T>::resizeForUnserialization(const std::vector<int>& tinyInfoI, std::vector<typename Traits<T>::ArrayType *>& arrays)
+ {
+ arrays.resize(1);
+ if(_array!=0)
+ _array->decrRef();
+ typename Traits<T>::ArrayType *arr=0;
+ if(tinyInfoI[0]!=-1 && tinyInfoI[1]!=-1)
+ {
+ arr=Traits<T>::ArrayType::New();
+ arr->alloc(tinyInfoI[0],tinyInfoI[1]);
+ }
+ _array=arr;
+ arrays[0]=arr;
+ }
+
+ template<class T>
+ void MEDCouplingTimeDiscretizationTemplate<T>::checkForUnserialization(const std::vector<int>& tinyInfoI, const std::vector<typename Traits<T>::ArrayType *>& 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();
+ }
+ }
+
+ template<class T>
+ void MEDCouplingTimeDiscretizationTemplate<T>::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]);
+ }
+
+ /////////////////////////
+
+ template<class T>
+ std::string MEDCouplingTimeDiscretizationSimple<T>::getStringRepr() const
+ {
+ std::ostringstream stream;
+ stream << REPR << " Time is defined by iteration=" << _tk.getIteration() << " order=" << _tk.getOrder() << " and time=" << _tk.getTimeValue() << ".";
+ stream << "\nTime unit is : \"" << this->_time_unit << "\"";
+ return stream.str();
+ }
+
+ template<class T>
+ double MEDCouplingTimeDiscretizationSimple<T>::getEndTime(int& iteration, int& order) const
+ {
+ throw INTERP_KERNEL::Exception("getEndTime : invalid for this type of time discr !");
+ }
+
+ template<class T>
+ void MEDCouplingTimeDiscretizationSimple<T>::setEndIteration(int it)
+ {
+ throw INTERP_KERNEL::Exception("setEndIteration : invalid for this type of time discr !");
+ }
+
+ template<class T>
+ void MEDCouplingTimeDiscretizationSimple<T>::setEndOrder(int order)
+ {
+ throw INTERP_KERNEL::Exception("setEndOrder : invalid for this type of time discr !");
+ }
+
+ template<class T>
+ void MEDCouplingTimeDiscretizationSimple<T>::setEndTimeValue(double time)
+ {
+ throw INTERP_KERNEL::Exception("setEndTimeValue : invalid for this type of time discr !");
+ }
+
+ template<class T>
+ void MEDCouplingTimeDiscretizationSimple<T>::setEndTime(double time, int iteration, int order)
+ {
+ throw INTERP_KERNEL::Exception("setEndTime : invalid for this type of time discr !");
+ }
+
+ template<class T>
+ MEDCouplingTimeDiscretizationSimple<T>::MEDCouplingTimeDiscretizationSimple(const MEDCouplingTimeDiscretizationSimple<T>& other, bool deepCopy):MEDCouplingTimeDiscretizationTemplate<T>(other,deepCopy),_tk(other._tk)
+ {
+ }
}
#endif
