{
public:
MEDCouplingAutoRefCountObjectPtr(const MEDCouplingAutoRefCountObjectPtr& other):_ptr(0) { referPtr(other._ptr); }
- MEDCouplingAutoRefCountObjectPtr(T *ptr):_ptr(ptr) { }
+ MEDCouplingAutoRefCountObjectPtr(T *ptr=0):_ptr(ptr) { }
~MEDCouplingAutoRefCountObjectPtr() { destroyPtr(); }
MEDCouplingAutoRefCountObjectPtr &operator=(const MEDCouplingAutoRefCountObjectPtr& other) { destroyPtr(); referPtr(other._ptr); return *this; }
MEDCouplingAutoRefCountObjectPtr &operator=(T *ptr) { destroyPtr(); _ptr=ptr; return *this; }
delete _type;
}
+MEDCouplingField::MEDCouplingField(MEDCouplingFieldDiscretization *type):_mesh(0),_type(type)
+{
+}
+
MEDCouplingField::MEDCouplingField(TypeOfField type):_mesh(0),_type(MEDCouplingFieldDiscretization::New(type))
{
}
protected:
MEDCouplingField(TypeOfField type);
MEDCouplingField(const MEDCouplingField& other);
+ MEDCouplingField(MEDCouplingFieldDiscretization *type);
virtual ~MEDCouplingField();
protected:
std::string _name;
MEDCouplingFieldDouble *MEDCouplingFieldDouble::buildNewTimeReprFromThis(TypeOfTimeDiscretization td, bool deepCpy) const
{
MEDCouplingTimeDiscretization *tdo=_time_discr->buildNewTimeReprFromThis(_time_discr,td,deepCpy);
- MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(getNature(),tdo,getTypeOfField());
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(getNature(),tdo,_type->clone());
ret->setMesh(getMesh());
ret->setName(getName());
ret->setDescription(getDescription());
{
}
-MEDCouplingFieldDouble::MEDCouplingFieldDouble(NatureOfField n, MEDCouplingTimeDiscretization *td, TypeOfField type):MEDCouplingField(type),
- _nature(n),_time_discr(td)
+MEDCouplingFieldDouble::MEDCouplingFieldDouble(NatureOfField n, MEDCouplingTimeDiscretization *td, MEDCouplingFieldDiscretization *type):MEDCouplingField(type),
+ _nature(n),_time_discr(td)
{
}
return true;
}
+MEDCouplingFieldDouble *MEDCouplingFieldDouble::doublyContractedProduct() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *td=_time_discr->doublyContractedProduct();
+ td->copyTinyAttrFrom(*_time_discr);
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(getNature(),td,_type->clone());
+ ret->setName("DoublyContractedProduct");
+ ret->setMesh(getMesh());
+ return ret;
+}
+
+MEDCouplingFieldDouble *MEDCouplingFieldDouble::determinant() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *td=_time_discr->determinant();
+ td->copyTinyAttrFrom(*_time_discr);
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(getNature(),td,_type->clone());
+ ret->setName("Determinant");
+ ret->setMesh(getMesh());
+ return ret;
+}
+
+MEDCouplingFieldDouble *MEDCouplingFieldDouble::eigenValues() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *td=_time_discr->eigenValues();
+ td->copyTinyAttrFrom(*_time_discr);
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(getNature(),td,_type->clone());
+ ret->setName("EigenValues");
+ ret->setMesh(getMesh());
+ return ret;
+}
+
+MEDCouplingFieldDouble *MEDCouplingFieldDouble::eigenVectors() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *td=_time_discr->eigenVectors();
+ td->copyTinyAttrFrom(*_time_discr);
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(getNature(),td,_type->clone());
+ ret->setName("EigenVectors");
+ ret->setMesh(getMesh());
+ return ret;
+}
+
+MEDCouplingFieldDouble *MEDCouplingFieldDouble::inverse() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *td=_time_discr->inverse();
+ td->copyTinyAttrFrom(*_time_discr);
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(getNature(),td,_type->clone());
+ ret->setName("Inversion");
+ ret->setMesh(getMesh());
+ return ret;
+}
+
+MEDCouplingFieldDouble *MEDCouplingFieldDouble::trace() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *td=_time_discr->trace();
+ td->copyTinyAttrFrom(*_time_discr);
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(getNature(),td,_type->clone());
+ ret->setName("Trace");
+ ret->setMesh(getMesh());
+ return ret;
+}
+
+MEDCouplingFieldDouble *MEDCouplingFieldDouble::deviator() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *td=_time_discr->deviator();
+ td->copyTinyAttrFrom(*_time_discr);
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(getNature(),td,_type->clone());
+ ret->setName("Trace");
+ ret->setMesh(getMesh());
+ return ret;
+}
+
+MEDCouplingFieldDouble *MEDCouplingFieldDouble::magnitude() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *td=_time_discr->magnitude();
+ td->copyTinyAttrFrom(*_time_discr);
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(getNature(),td,_type->clone());
+ ret->setName("Magnitude");
+ ret->setMesh(getMesh());
+ return ret;
+}
+
+MEDCouplingFieldDouble *MEDCouplingFieldDouble::maxPerTuple() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *td=_time_discr->maxPerTuple();
+ td->copyTinyAttrFrom(*_time_discr);
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(getNature(),td,_type->clone());
+ std::ostringstream oss;
+ oss << "Max_" << getName();
+ ret->setName(oss.str().c_str());
+ ret->setMesh(getMesh());
+ return ret;
+}
+
+void MEDCouplingFieldDouble::changeNbOfComponents(int newNbOfComp, double dftValue) throw(INTERP_KERNEL::Exception)
+{
+ _time_discr->changeNbOfComponents(newNbOfComp,dftValue);
+}
+
+void MEDCouplingFieldDouble::sortPerTuple(bool asc) throw(INTERP_KERNEL::Exception)
+{
+ _time_discr->sortPerTuple(asc);
+}
+
MEDCouplingFieldDouble *MEDCouplingFieldDouble::mergeFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2)
{
if(!f1->areCompatibleForMerge(f2))
const MEDCouplingMesh *m2=f2->getMesh();
MEDCouplingMesh *m=m1->mergeMyselfWith(m2);
MEDCouplingTimeDiscretization *td=f1->_time_discr->aggregate(f2->_time_discr);
- MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->getTypeOfField());
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->_type->clone());
ret->setMesh(m);
m->decrRef();
ret->setName(f1->getName());
throw INTERP_KERNEL::Exception("Fields are not compatible ; unable to apply dotFields on them !");
MEDCouplingTimeDiscretization *td=f1->_time_discr->dot(f2->_time_discr);
td->copyTinyAttrFrom(*f1->_time_discr);
- MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->getTypeOfField());
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->_type->clone());
ret->setMesh(f1->getMesh());
return ret;
}
throw INTERP_KERNEL::Exception("Fields are not compatible ; unable to apply crossProductFields on them !");
MEDCouplingTimeDiscretization *td=f1->_time_discr->crossProduct(f2->_time_discr);
td->copyTinyAttrFrom(*f1->_time_discr);
- MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->getTypeOfField());
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->_type->clone());
ret->setMesh(f1->getMesh());
return ret;
}
throw INTERP_KERNEL::Exception("Fields are not compatible ; unable to apply maxFields on them !");
MEDCouplingTimeDiscretization *td=f1->_time_discr->max(f2->_time_discr);
td->copyTinyAttrFrom(*f1->_time_discr);
- MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->getTypeOfField());
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->_type->clone());
ret->setMesh(f1->getMesh());
return ret;
}
throw INTERP_KERNEL::Exception("Fields are not compatible ; unable to apply minFields on them !");
MEDCouplingTimeDiscretization *td=f1->_time_discr->min(f2->_time_discr);
td->copyTinyAttrFrom(*f1->_time_discr);
- MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->getTypeOfField());
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->_type->clone());
ret->setMesh(f1->getMesh());
return ret;
}
throw INTERP_KERNEL::Exception("Fields are not compatible ; unable to apply addFields on them !");
MEDCouplingTimeDiscretization *td=f1->_time_discr->add(f2->_time_discr);
td->copyTinyAttrFrom(*f1->_time_discr);
- MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->getTypeOfField());
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->_type->clone());
ret->setMesh(f1->getMesh());
return ret;
}
throw INTERP_KERNEL::Exception("Fields are not compatible ; unable to apply substractFields on them !");
MEDCouplingTimeDiscretization *td=f1->_time_discr->substract(f2->_time_discr);
td->copyTinyAttrFrom(*f1->_time_discr);
- MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->getTypeOfField());
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->_type->clone());
ret->setMesh(f1->getMesh());
return ret;
}
throw INTERP_KERNEL::Exception("Fields are not compatible ; unable to apply multiplyFields on them !");
MEDCouplingTimeDiscretization *td=f1->_time_discr->multiply(f2->_time_discr);
td->copyTinyAttrFrom(*f1->_time_discr);
- MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->getTypeOfField());
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->_type->clone());
ret->setMesh(f1->getMesh());
return ret;
}
throw INTERP_KERNEL::Exception("Fields are not compatible ; unable to apply divideFields on them !");
MEDCouplingTimeDiscretization *td=f1->_time_discr->divide(f2->_time_discr);
td->copyTinyAttrFrom(*f1->_time_discr);
- MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->getTypeOfField());
+ MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(f1->getNature(),td,f1->_type->clone());
ret->setMesh(f1->getMesh());
return ret;
}
void checkCoherency() const throw(INTERP_KERNEL::Exception);
NatureOfField getNature() const { return _nature; }
void setNature(NatureOfField nat) throw(INTERP_KERNEL::Exception);
- void setTime(double val, int dt, int it) { _time_discr->setTime(val,dt,it); }
- void setStartTime(double val, int dt, int it) { _time_discr->setStartTime(val,dt,it); }
- void setEndTime(double val, int dt, int it) { _time_discr->setEndTime(val,dt,it); }
- double getTime(int& dt, int& it) const { return _time_discr->getTime(dt,it); }
- double getStartTime(int& dt, int& it) const { return _time_discr->getStartTime(dt,it); }
- double getEndTime(int& dt, int& it) const { return _time_discr->getEndTime(dt,it); }
+ void setTime(double val, int iteration, int order) { _time_discr->setTime(val,iteration,order); }
+ void setStartTime(double val, int iteration, int order) { _time_discr->setStartTime(val,iteration,order); }
+ void setEndTime(double val, int iteration, int order) { _time_discr->setEndTime(val,iteration,order); }
+ double getTime(int& iteration, int& order) const { return _time_discr->getTime(iteration,order); }
+ double getStartTime(int& iteration, int& order) const { return _time_discr->getStartTime(iteration,order); }
+ double getEndTime(int& iteration, int& order) const { return _time_discr->getEndTime(iteration,order); }
double getIJ(int tupleId, int compoId) const { return getArray()->getIJ(tupleId,compoId); }
double getIJK(int cellId, int nodeIdInCell, int compoId) const;
void setArray(DataArrayDouble *array);
void changeUnderlyingMesh(const MEDCouplingMesh *other, int levOfCheck, double prec) throw(INTERP_KERNEL::Exception);
void substractInPlaceDM(const MEDCouplingFieldDouble *f, int levOfCheck, double prec) throw(INTERP_KERNEL::Exception);
bool mergeNodes(double eps) throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *doublyContractedProduct() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *determinant() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *eigenValues() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *eigenVectors() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *inverse() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *trace() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *deviator() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *magnitude() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *maxPerTuple() const throw(INTERP_KERNEL::Exception);
+ void changeNbOfComponents(int newNbOfComp, double dftValue=0.) throw(INTERP_KERNEL::Exception);
+ void sortPerTuple(bool asc) throw(INTERP_KERNEL::Exception);
static MEDCouplingFieldDouble *mergeFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2);
static MEDCouplingFieldDouble *dotFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2);
MEDCouplingFieldDouble *dot(const MEDCouplingFieldDouble& other) const { return dotFields(this,&other); }
private:
MEDCouplingFieldDouble(TypeOfField type, TypeOfTimeDiscretization td);
MEDCouplingFieldDouble(const MEDCouplingFieldDouble& other, bool deepCpy);
- MEDCouplingFieldDouble(NatureOfField n, MEDCouplingTimeDiscretization *td, TypeOfField type);
+ MEDCouplingFieldDouble(NatureOfField n, MEDCouplingTimeDiscretization *td, MEDCouplingFieldDiscretization *type);
~MEDCouplingFieldDouble();
private:
NatureOfField _nature;
#include "MEDCouplingMemArray.txx"
+#include "GenMathFormulae.hxx"
#include "InterpKernelExprParser.hxx"
#include <set>
+#include <cmath>
#include <numeric>
#include <functional>
return ret;
}
+/*!
+ * This method builds a new instance of DataArrayDouble (to deal with) that is reduction or an extension of 'this'.
+ * if 'newNbOfComp' < this->getNumberOfComponents() a reduction is done and for each tuple 'newNbOfComp' first components are kept.
+ * If 'newNbOfComp' > this->getNumberOfComponents() an extension is done, and for each components i such that i > getNumberOfComponents() 'dftValue' parameter is taken.
+ */
+DataArrayDouble *DataArrayDouble::changeNbOfComponents(int newNbOfComp, double dftValue) const throw(INTERP_KERNEL::Exception)
+{
+ DataArrayDouble *ret=DataArrayDouble::New();
+ ret->alloc(getNumberOfTuples(),newNbOfComp);
+ const double *oldc=getConstPointer();
+ double *nc=ret->getPointer();
+ int nbOfTuples=getNumberOfTuples();
+ int oldNbOfComp=getNumberOfComponents();
+ int dim=std::min(oldNbOfComp,newNbOfComp);
+ for(int i=0;i<nbOfTuples;i++)
+ {
+ int j=0;
+ for(;j<dim;j++)
+ nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
+ for(;j<newNbOfComp;j++)
+ nc[newNbOfComp*i+j]=dftValue;
+ }
+ ret->setName(getName().c_str());
+ for(int i=0;i<dim;i++)
+ ret->setInfoOnComponent(i,getInfoOnComponent(i).c_str());
+ ret->setName(getName().c_str());
+ return ret;
+}
+
/*!
* This method is a generalization of DataArrayDouble::substr method because a not contigous range can be specified here.
*/
return ret;
}
+DataArrayDouble *DataArrayDouble::doublyContractedProduct() const throw(INTERP_KERNEL::Exception)
+{
+ int nbOfComp=getNumberOfComponents();
+ if(nbOfComp!=6)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::doublyContractedProduct : must be an array with exactly 6 components !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,1);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
+ *dest=src[0]*src[0]+src[1]*src[1]+src[2]*src[2]+2.*src[3]*src[3]+2.*src[4]*src[4]+2.*src[5]*src[5];
+ return ret;
+}
+
+DataArrayDouble *DataArrayDouble::determinant() const throw(INTERP_KERNEL::Exception)
+{
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,1);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ switch(getNumberOfComponents())
+ {
+ case 6:
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
+ *dest=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
+ return ret;
+ case 4:
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
+ *dest=src[0]*src[3]-src[1]*src[2];
+ return ret;
+ case 9:
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
+ *dest=src[0]*src[4]*src[8]+src[1]*src[5]*src[6]+src[2]*src[3]*src[7]-src[0]*src[5]*src[7]-src[1]*src[3]*src[8]-src[2]*src[4]*src[6];
+ return ret;
+ default:
+ ret->decrRef();
+ throw INTERP_KERNEL::Exception("DataArrayDouble::determinant : Invalid number of components ! must be in 4,6,9 !");
+ }
+}
+
+DataArrayDouble *DataArrayDouble::eigenValues() const throw(INTERP_KERNEL::Exception)
+{
+ int nbOfComp=getNumberOfComponents();
+ if(nbOfComp!=6)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::eigenValues : must be an array with exactly 6 components !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,3);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,dest+=3,src+=6)
+ INTERP_KERNEL::computeEigenValues6(src,dest);
+ return ret;
+}
+
+DataArrayDouble *DataArrayDouble::eigenVectors() const throw(INTERP_KERNEL::Exception)
+{
+ int nbOfComp=getNumberOfComponents();
+ if(nbOfComp!=6)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::eigenVectors : must be an array with exactly 6 components !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,9);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,src+=6)
+ {
+ double tmp[3];
+ INTERP_KERNEL::computeEigenValues6(src,tmp);
+ for(int j=0;j<3;j++,dest+=3)
+ INTERP_KERNEL::computeEigenVectorForEigenValue6(src,tmp[j],1e-12,dest);
+ }
+ return ret;
+}
+
+DataArrayDouble *DataArrayDouble::inverse() const throw(INTERP_KERNEL::Exception)
+{
+ int nbOfComp=getNumberOfComponents();
+ if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::inversion : must be an array with 4,6 or 9 components !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,nbOfComp);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+if(nbOfComp==6)
+ for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
+ {
+ double det=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
+ dest[0]=(src[1]*src[2]-src[4]*src[4])/det;
+ dest[1]=(src[0]*src[2]-src[5]*src[5])/det;
+ dest[2]=(src[0]*src[1]-src[3]*src[3])/det;
+ dest[3]=(src[5]*src[4]-src[3]*src[2])/det;
+ dest[4]=(src[5]*src[3]-src[0]*src[4])/det;
+ dest[5]=(src[3]*src[4]-src[1]*src[5])/det;
+ }
+ else if(nbOfComp==4)
+ for(int i=0;i<nbOfTuple;i++,dest+=4,src+=4)
+ {
+ double det=src[0]*src[3]-src[1]*src[2];
+ dest[0]=src[3]/det;
+ dest[1]=-src[1]/det;
+ dest[2]=-src[2]/det;
+ dest[3]=src[0]/det;
+ }
+ else
+ for(int i=0;i<nbOfTuple;i++,dest+=9,src+=9)
+ {
+ double det=src[0]*src[4]*src[8]+src[1]*src[5]*src[6]+src[2]*src[3]*src[7]-src[0]*src[5]*src[7]-src[1]*src[3]*src[8]-src[2]*src[4]*src[6];
+ dest[0]=(src[4]*src[8]-src[7]*src[5])/det;
+ dest[1]=(src[7]*src[2]-src[1]*src[8])/det;
+ dest[2]=(src[1]*src[5]-src[4]*src[2])/det;
+ dest[3]=(src[6]*src[5]-src[3]*src[8])/det;
+ dest[4]=(src[0]*src[8]-src[6]*src[2])/det;
+ dest[5]=(src[2]*src[3]-src[0]*src[5])/det;
+ dest[6]=(src[3]*src[7]-src[6]*src[4])/det;
+ dest[7]=(src[6]*src[1]-src[0]*src[7])/det;
+ dest[8]=(src[0]*src[4]-src[1]*src[3])/det;
+ }
+ return ret;
+}
+
+DataArrayDouble *DataArrayDouble::trace() const throw(INTERP_KERNEL::Exception)
+{
+ int nbOfComp=getNumberOfComponents();
+ if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::trace : must be an array with 4,6 or 9 components !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,1);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ if(nbOfComp==6)
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
+ *dest=src[0]+src[1]+src[2];
+ else if(nbOfComp==4)
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
+ *dest=src[0]+src[3];
+ else
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
+ *dest=src[0]+src[4]+src[8];
+ return ret;
+}
+
+DataArrayDouble *DataArrayDouble::deviator() const throw(INTERP_KERNEL::Exception)
+{
+ int nbOfComp=getNumberOfComponents();
+ if(nbOfComp!=6)
+ throw INTERP_KERNEL::Exception("DataArrayDouble::deviator : must be an array with exactly 6 components !");
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,6);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
+ {
+ double tr=(src[0]+src[1]+src[2])/3.;
+ dest[0]=src[0]-tr;
+ dest[1]=src[1]-tr;
+ dest[2]=src[2]-tr;
+ dest[3]=src[3];
+ dest[4]=src[4];
+ dest[5]=src[5];
+ }
+ return ret;
+}
+
+DataArrayDouble *DataArrayDouble::magnitude() const throw(INTERP_KERNEL::Exception)
+{
+ int nbOfComp=getNumberOfComponents();
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,1);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,dest++)
+ {
+ double sum=0.;
+ for(int j=0;j<nbOfComp;j++,src++)
+ sum+=(*src)*(*src);
+ *dest=sqrt(sum);
+ }
+ return ret;
+}
+
+DataArrayDouble *DataArrayDouble::maxPerTuple() const throw(INTERP_KERNEL::Exception)
+{
+ int nbOfComp=getNumberOfComponents();
+ DataArrayDouble *ret=DataArrayDouble::New();
+ int nbOfTuple=getNumberOfTuples();
+ ret->alloc(nbOfTuple,1);
+ const double *src=getConstPointer();
+ double *dest=ret->getPointer();
+ for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
+ *dest=*std::max_element(src,src+nbOfComp);
+ return ret;
+}
+
+void DataArrayDouble::sortPerTuple(bool asc) throw(INTERP_KERNEL::Exception)
+{
+ double *pt=getPointer();
+ int nbOfTuple=getNumberOfTuples();
+ int nbOfComp=getNumberOfComponents();
+ if(asc)
+ for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
+ std::sort(pt,pt+nbOfComp);
+ else
+ for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
+ std::sort(pt,pt+nbOfComp,std::greater<double>());
+ declareAsNew();
+}
+
void DataArrayDouble::applyLin(double a, double b, int compoId)
{
double *ptr=getPointer()+compoId;
return ret;
}
+/*!
+ * This method builds a new instance of DataArrayInt (to deal with) that is reduction or an extension of 'this'.
+ * if 'newNbOfComp' < this->getNumberOfComponents() a reduction is done and for each tuple 'newNbOfComp' first components are kept.
+ * If 'newNbOfComp' > this->getNumberOfComponents() an extension is done, and for each components i such that i > getNumberOfComponents() 'dftValue' parameter is taken.
+ */
+DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) const throw(INTERP_KERNEL::Exception)
+{
+ DataArrayInt *ret=DataArrayInt::New();
+ ret->alloc(getNumberOfTuples(),newNbOfComp);
+ const int *oldc=getConstPointer();
+ int *nc=ret->getPointer();
+ int nbOfTuples=getNumberOfTuples();
+ int oldNbOfComp=getNumberOfComponents();
+ int dim=std::min(oldNbOfComp,newNbOfComp);
+ for(int i=0;i<nbOfTuples;i++)
+ {
+ int j=0;
+ for(;j<dim;j++)
+ nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
+ for(;j<newNbOfComp;j++)
+ nc[newNbOfComp*i+j]=dftValue;
+ }
+ ret->setName(getName().c_str());
+ for(int i=0;i<dim;i++)
+ ret->setInfoOnComponent(i,getInfoOnComponent(i).c_str());
+ ret->setName(getName().c_str());
+ return ret;
+}
+
+
/*!
* This method is a generalization of DataArrayDouble::substr method because a not contigous range can be specified here.
*/
MEDCOUPLING_EXPORT void renumberInPlace(const int *old2New);
MEDCOUPLING_EXPORT DataArrayDouble *renumber(const int *old2New) const;
MEDCOUPLING_EXPORT DataArrayDouble *substr(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception);
+ MEDCOUPLING_EXPORT DataArrayDouble *changeNbOfComponents(int newNbOfComp, double dftValue) const throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT DataArrayDouble *selectByTupleId(const int *start, const int *end) const;
MEDCOUPLING_EXPORT void getTuple(int tupleId, double *res) const { std::copy(_mem.getConstPointerLoc(tupleId*_info_on_compo.size()),_mem.getConstPointerLoc((tupleId+1)*_info_on_compo.size()),res); }
MEDCOUPLING_EXPORT double getIJ(int tupleId, int compoId) const { return _mem[tupleId*_info_on_compo.size()+compoId]; }
MEDCOUPLING_EXPORT double getAverageValue() const throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT void accumulate(double *res) const;
MEDCOUPLING_EXPORT double accumulate(int compId) const;
+ MEDCOUPLING_EXPORT DataArrayDouble *doublyContractedProduct() const throw(INTERP_KERNEL::Exception);
+ MEDCOUPLING_EXPORT DataArrayDouble *determinant() const throw(INTERP_KERNEL::Exception);
+ MEDCOUPLING_EXPORT DataArrayDouble *eigenValues() const throw(INTERP_KERNEL::Exception);
+ MEDCOUPLING_EXPORT DataArrayDouble *eigenVectors() const throw(INTERP_KERNEL::Exception);
+ MEDCOUPLING_EXPORT DataArrayDouble *inverse() const throw(INTERP_KERNEL::Exception);
+ MEDCOUPLING_EXPORT DataArrayDouble *trace() const throw(INTERP_KERNEL::Exception);
+ MEDCOUPLING_EXPORT DataArrayDouble *deviator() const throw(INTERP_KERNEL::Exception);
+ MEDCOUPLING_EXPORT DataArrayDouble *magnitude() const throw(INTERP_KERNEL::Exception);
+ MEDCOUPLING_EXPORT DataArrayDouble *maxPerTuple() const throw(INTERP_KERNEL::Exception);
+ MEDCOUPLING_EXPORT void sortPerTuple(bool asc) throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT void applyLin(double a, double b, int compoId);
MEDCOUPLING_EXPORT DataArrayDouble *applyFunc(int nbOfComp, FunctionToEvaluate func) const throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT DataArrayDouble *applyFunc(int nbOfComp, const char *func) const throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT DataArrayInt *renumber(const int *old2New) const;
MEDCOUPLING_EXPORT bool isIdentity() const;
MEDCOUPLING_EXPORT DataArrayInt *substr(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception);
+ MEDCOUPLING_EXPORT DataArrayInt *changeNbOfComponents(int newNbOfComp, int dftValue) const throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT DataArrayInt *selectByTupleId(const int *start, const int *end) const;
MEDCOUPLING_EXPORT void getTuple(int tupleId, int *res) const { std::copy(_mem.getConstPointerLoc(tupleId*_info_on_compo.size()),_mem.getConstPointerLoc((tupleId+1)*_info_on_compo.size()),res); }
MEDCOUPLING_EXPORT int getIJ(int tupleId, int compoId) const { return _mem[tupleId*_info_on_compo.size()+compoId]; }
* - by ignoring each \f$ i^{th} \f$ components of each coord of nodes so that i >= 'newSpaceDim', 'newSpaceDim'<getSpaceDimension()
* If newSpaceDim==getSpaceDim() nothing is done by this method.
*/
-void MEDCouplingPointSet::changeSpaceDimension(int newSpaceDim) throw(INTERP_KERNEL::Exception)
+void MEDCouplingPointSet::changeSpaceDimension(int newSpaceDim, double dftValue) throw(INTERP_KERNEL::Exception)
{
if(getCoords()==0)
throw INTERP_KERNEL::Exception("changeSpaceDimension must be called on an MEDCouplingPointSet instance with coordinates set !");
int oldSpaceDim=getSpaceDimension();
if(newSpaceDim==oldSpaceDim)
return ;
- DataArrayDouble *newCoords=DataArrayDouble::New();
- newCoords->alloc(getCoords()->getNumberOfTuples(),newSpaceDim);
- const double *oldc=getCoords()->getConstPointer();
- double *nc=newCoords->getPointer();
- int nbOfNodes=getNumberOfNodes();
- int dim=std::min(oldSpaceDim,newSpaceDim);
- for(int i=0;i<nbOfNodes;i++)
- {
- int j=0;
- for(;j<dim;j++)
- nc[newSpaceDim*i+j]=oldc[i*oldSpaceDim+j];
- for(;j<newSpaceDim;j++)
- nc[newSpaceDim*i+j]=0.;
- }
- newCoords->setName(getCoords()->getName().c_str());
- for(int i=0;i<dim;i++)
- newCoords->setInfoOnComponent(i,getCoords()->getInfoOnComponent(i).c_str());
+ DataArrayDouble *newCoords=getCoords()->changeNbOfComponents(newSpaceDim,dftValue);
setCoords(newCoords);
newCoords->decrRef();
updateTime();
void rotate(const double *center, const double *vector, double angle);
void translate(const double *vector);
void scale(const double *point, double factor);
- void changeSpaceDimension(int newSpaceDim) throw(INTERP_KERNEL::Exception);
+ void changeSpaceDimension(int newSpaceDim, double dftVal=0.) throw(INTERP_KERNEL::Exception);
void tryToShareSameCoords(const MEDCouplingPointSet& other, double epsilon) throw(INTERP_KERNEL::Exception);
virtual void tryToShareSameCoordsPermute(const MEDCouplingPointSet& other, double epsilon) throw(INTERP_KERNEL::Exception) = 0;
void findNodesOnPlane(const double *pt, const double *vec, double eps, std::vector<int>& nodes) const throw(INTERP_KERNEL::Exception);
#include "MEDCouplingTimeDiscretization.hxx"
#include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingAutoRefCountObjectPtr.hxx"
#include <cmath>
#include <iterator>
bool MEDCouplingTimeDiscretization::isBefore(const MEDCouplingTimeDiscretization *other) const throw(INTERP_KERNEL::Exception)
{
- int dt,it;
- double time1=getEndTime(dt,it)-_time_tolerance;
- double time2=other->getStartTime(dt,it)+other->getTimeTolerance();
+ int iteration,order;
+ double time1=getEndTime(iteration,order)-_time_tolerance;
+ double time2=other->getStartTime(iteration,order)+other->getTimeTolerance();
return time1<=time2;
}
bool MEDCouplingTimeDiscretization::isStrictlyBefore(const MEDCouplingTimeDiscretization *other) const throw(INTERP_KERNEL::Exception)
{
- int dt,it;
- double time1=getEndTime(dt,it)+_time_tolerance;
- double time2=other->getStartTime(dt,it)-other->getTimeTolerance();
+ int iteration,order;
+ double time1=getEndTime(iteration,order)+_time_tolerance;
+ double time2=other->getStartTime(iteration,order)-other->getTimeTolerance();
return time1<time2;
}
+MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::doublyContractedProduct() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+ std::vector<DataArrayDouble *> arrays;
+ getArrays(arrays);
+ std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ {
+ if(arrays[j])
+ arrays2[j]=arrays[j]->doublyContractedProduct();
+ else
+ arrays2[j]=0;
+ }
+ std::vector<DataArrayDouble *> arrays3(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ arrays3[j]=arrays2[j];
+ ret->setArrays(arrays3,0);
+ return ret;
+}
+
+MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::determinant() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+ std::vector<DataArrayDouble *> arrays;
+ getArrays(arrays);
+ std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ {
+ if(arrays[j])
+ arrays2[j]=arrays[j]->determinant();
+ else
+ arrays2[j]=0;
+ }
+ std::vector<DataArrayDouble *> arrays3(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ arrays3[j]=arrays2[j];
+ ret->setArrays(arrays3,0);
+ return ret;
+}
+
+MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::eigenValues() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+ std::vector<DataArrayDouble *> arrays;
+ getArrays(arrays);
+ std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ {
+ if(arrays[j])
+ arrays2[j]=arrays[j]->eigenValues();
+ else
+ arrays2[j]=0;
+ }
+ std::vector<DataArrayDouble *> arrays3(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ arrays3[j]=arrays2[j];
+ ret->setArrays(arrays3,0);
+ return ret;
+}
+
+MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::eigenVectors() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+ std::vector<DataArrayDouble *> arrays;
+ getArrays(arrays);
+ std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ {
+ if(arrays[j])
+ arrays2[j]=arrays[j]->eigenVectors();
+ else
+ arrays2[j]=0;
+ }
+ std::vector<DataArrayDouble *> arrays3(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ arrays3[j]=arrays2[j];
+ ret->setArrays(arrays3,0);
+ return ret;
+}
+
+MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::inverse() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+ std::vector<DataArrayDouble *> arrays;
+ getArrays(arrays);
+ std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ {
+ if(arrays[j])
+ arrays2[j]=arrays[j]->inverse();
+ else
+ arrays2[j]=0;
+ }
+ std::vector<DataArrayDouble *> arrays3(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ arrays3[j]=arrays2[j];
+ ret->setArrays(arrays3,0);
+ return ret;
+}
+
+MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::trace() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+ std::vector<DataArrayDouble *> arrays;
+ getArrays(arrays);
+ std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ {
+ if(arrays[j])
+ arrays2[j]=arrays[j]->trace();
+ else
+ arrays2[j]=0;
+ }
+ std::vector<DataArrayDouble *> arrays3(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ arrays3[j]=arrays2[j];
+ ret->setArrays(arrays3,0);
+ return ret;
+}
+
+MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::deviator() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+ std::vector<DataArrayDouble *> arrays;
+ getArrays(arrays);
+ std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ {
+ if(arrays[j])
+ arrays2[j]=arrays[j]->deviator();
+ else
+ arrays2[j]=0;
+ }
+ std::vector<DataArrayDouble *> arrays3(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ arrays3[j]=arrays2[j];
+ ret->setArrays(arrays3,0);
+ return ret;
+}
+
+MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::magnitude() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+ std::vector<DataArrayDouble *> arrays;
+ getArrays(arrays);
+ std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ {
+ if(arrays[j])
+ arrays2[j]=arrays[j]->magnitude();
+ else
+ arrays2[j]=0;
+ }
+ std::vector<DataArrayDouble *> arrays3(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ arrays3[j]=arrays2[j];
+ ret->setArrays(arrays3,0);
+ return ret;
+}
+
+MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::maxPerTuple() const throw(INTERP_KERNEL::Exception)
+{
+ MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum());
+ std::vector<DataArrayDouble *> arrays;
+ getArrays(arrays);
+ std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ {
+ if(arrays[j])
+ arrays2[j]=arrays[j]->maxPerTuple();
+ else
+ arrays2[j]=0;
+ }
+ std::vector<DataArrayDouble *> arrays3(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ arrays3[j]=arrays2[j];
+ ret->setArrays(arrays3,0);
+ return ret;
+}
+
+void MEDCouplingTimeDiscretization::changeNbOfComponents(int newNbOfComp, double dftValue) throw(INTERP_KERNEL::Exception)
+{
+ std::vector<DataArrayDouble *> arrays;
+ getArrays(arrays);
+ std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > arrays2(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ {
+ if(arrays[j])
+ arrays2[j]=arrays[j]->changeNbOfComponents(newNbOfComp,dftValue);
+ else
+ arrays2[j]=0;
+ }
+ std::vector<DataArrayDouble *> arrays3(arrays.size());
+ for(int j=0;j<(int)arrays.size();j++)
+ arrays3[j]=arrays2[j];
+ setArrays(arrays3,0);
+}
+
+void MEDCouplingTimeDiscretization::sortPerTuple(bool asc) throw(INTERP_KERNEL::Exception)
+{
+ std::vector<DataArrayDouble *> arrays;
+ getArrays(arrays);
+ for(int j=0;j<(int)arrays.size();j++)
+ {
+ if(arrays[j])
+ arrays[j]->sortPerTuple(asc);
+ }
+}
+
void MEDCouplingTimeDiscretization::applyLin(double a, double b, int compoId)
{
std::vector<DataArrayDouble *> arrays;
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-double MEDCouplingNoTimeLabel::getStartTime(int& dt, int& it) const throw(INTERP_KERNEL::Exception)
+double MEDCouplingNoTimeLabel::getStartTime(int& iteration, int& order) const throw(INTERP_KERNEL::Exception)
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-double MEDCouplingNoTimeLabel::getEndTime(int& dt, int& it) const throw(INTERP_KERNEL::Exception)
+double MEDCouplingNoTimeLabel::getEndTime(int& iteration, int& order) const throw(INTERP_KERNEL::Exception)
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingNoTimeLabel::setStartTime(double time, int dt, int it) throw(INTERP_KERNEL::Exception)
+void MEDCouplingNoTimeLabel::setStartTime(double time, int iteration, int order) throw(INTERP_KERNEL::Exception)
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingNoTimeLabel::setEndTime(double time, int dt, int it) throw(INTERP_KERNEL::Exception)
+void MEDCouplingNoTimeLabel::setEndTime(double time, int iteration, int order) throw(INTERP_KERNEL::Exception)
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingNoTimeLabel::getValueOnDiscTime(int eltId, int dt, int it, double *value) const throw(INTERP_KERNEL::Exception)
+void MEDCouplingNoTimeLabel::getValueOnDiscTime(int eltId, int iteration, int order, double *value) const throw(INTERP_KERNEL::Exception)
{
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
MEDCouplingWithTimeStep::MEDCouplingWithTimeStep(const MEDCouplingWithTimeStep& other, bool deepCpy):MEDCouplingTimeDiscretization(other,deepCpy),
- _time(other._time),_dt(other._dt),_it(other._it)
+ _time(other._time),_iteration(other._iteration),_order(other._order)
{
}
-MEDCouplingWithTimeStep::MEDCouplingWithTimeStep():_time(0.),_dt(-1),_it(-1)
+MEDCouplingWithTimeStep::MEDCouplingWithTimeStep():_time(0.),_iteration(-1),_order(-1)
{
}
std::string MEDCouplingWithTimeStep::getStringRepr() const
{
std::ostringstream stream;
- stream << REPR << " Time is defined by dt=" << _dt << " it=" << _it << " and time=" << _time << ".";
+ stream << REPR << " Time is defined by iteration=" << _iteration << " order=" << _order << " and time=" << _time << ".";
return stream.str();
}
void MEDCouplingWithTimeStep::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
{
MEDCouplingTimeDiscretization::getTinySerializationIntInformation(tinyInfo);
- tinyInfo.push_back(_dt);
- tinyInfo.push_back(_it);
+ tinyInfo.push_back(_iteration);
+ tinyInfo.push_back(_order);
}
void MEDCouplingWithTimeStep::getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const
{
MEDCouplingTimeDiscretization::finishUnserialization(tinyInfoI,tinyInfoD,tinyInfoS);
_time=tinyInfoD[1];
- _dt=tinyInfoI[2];
- _it=tinyInfoI[3];
+ _iteration=tinyInfoI[2];
+ _order=tinyInfoI[3];
}
bool MEDCouplingWithTimeStep::areCompatible(const MEDCouplingTimeDiscretization *other) const
const MEDCouplingWithTimeStep *otherC=dynamic_cast<const MEDCouplingWithTimeStep *>(other);
if(!otherC)
return false;
- if(_dt!=otherC->_dt)
+ if(_iteration!=otherC->_iteration)
return false;
- if(_it!=otherC->_it)
+ if(_order!=otherC->_order)
return false;
if(std::fabs(_time-otherC->_time)>_time_tolerance)
return false;
MEDCouplingTimeDiscretization::copyTinyAttrFrom(other);
const MEDCouplingWithTimeStep& otherC=dynamic_cast<const MEDCouplingWithTimeStep& >(other);
_time=otherC._time;
- _dt=otherC._dt;
- _it=otherC._it;
+ _iteration=otherC._iteration;
+ _order=otherC._order;
}
MEDCouplingTimeDiscretization *MEDCouplingWithTimeStep::aggregate(const MEDCouplingTimeDiscretization *other) const
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingWithTimeStep::getValueOnDiscTime(int eltId, int dt, int it, double *value) const throw(INTERP_KERNEL::Exception)
+void MEDCouplingWithTimeStep::getValueOnDiscTime(int eltId, int iteration, int order, double *value) const throw(INTERP_KERNEL::Exception)
{
- if(_dt==dt && _it==it)
+ if(_iteration==iteration && _order==order)
if(_array)
_array->getTuple(eltId,value);
else
throw INTERP_KERNEL::Exception("No data on this discrete time.");
}
-MEDCouplingConstOnTimeInterval::MEDCouplingConstOnTimeInterval():_start_time(0.),_end_time(0.),_start_dt(-1),_end_dt(-1),_start_it(-1),_end_it(-1)
+MEDCouplingConstOnTimeInterval::MEDCouplingConstOnTimeInterval():_start_time(0.),_end_time(0.),_start_iteration(-1),_end_iteration(-1),_start_order(-1),_end_order(-1)
{
}
const MEDCouplingConstOnTimeInterval& otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval& >(other);
_start_time=otherC._start_time;
_end_time=otherC._end_time;
- _start_dt=otherC._start_dt;
- _end_dt=otherC._end_dt;
- _start_it=otherC._start_it;
- _end_it=otherC._end_it;
+ _start_iteration=otherC._start_iteration;
+ _end_iteration=otherC._end_iteration;
+ _start_order=otherC._start_order;
+ _end_order=otherC._end_order;
}
void MEDCouplingConstOnTimeInterval::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
{
MEDCouplingTimeDiscretization::getTinySerializationIntInformation(tinyInfo);
- tinyInfo.push_back(_start_dt);
- tinyInfo.push_back(_start_it);
- tinyInfo.push_back(_end_dt);
- tinyInfo.push_back(_end_it);
+ tinyInfo.push_back(_start_iteration);
+ tinyInfo.push_back(_start_order);
+ tinyInfo.push_back(_end_iteration);
+ tinyInfo.push_back(_end_order);
}
void MEDCouplingConstOnTimeInterval::getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const
MEDCouplingTimeDiscretization::finishUnserialization(tinyInfoI,tinyInfoD,tinyInfoS);
_start_time=tinyInfoD[1];
_end_time=tinyInfoD[2];
- _start_dt=tinyInfoI[2];
- _start_it=tinyInfoI[3];
- _end_dt=tinyInfoI[4];
- _end_it=tinyInfoI[5];
+ _start_iteration=tinyInfoI[2];
+ _start_order=tinyInfoI[3];
+ _end_iteration=tinyInfoI[4];
+ _end_order=tinyInfoI[5];
}
MEDCouplingConstOnTimeInterval::MEDCouplingConstOnTimeInterval(const MEDCouplingConstOnTimeInterval& other, bool deepCpy):
- MEDCouplingTimeDiscretization(other,deepCpy),_start_time(other._start_time),_end_time(other._end_time),_start_dt(other._start_dt),
- _end_dt(other._end_dt),_start_it(other._start_it),_end_it(other._end_it)
+ MEDCouplingTimeDiscretization(other,deepCpy),_start_time(other._start_time),_end_time(other._end_time),_start_iteration(other._start_iteration),
+ _end_iteration(other._end_iteration),_start_order(other._start_order),_end_order(other._end_order)
{
}
std::string MEDCouplingConstOnTimeInterval::getStringRepr() const
{
std::ostringstream stream;
- stream << REPR << " Time interval is defined by :\ndt_start=" << _start_dt << " it_start=" << _start_it << " and time_start=" << _start_time << "\n";
- stream << "dt_end=" << _end_dt << " it_end=" << _end_it << " and end_time=" << _end_time << "\n";
+ stream << REPR << " Time interval is defined by :\niteration_start=" << _start_iteration << " order_start=" << _start_order << " and time_start=" << _start_time << "\n";
+ stream << "iteration_end=" << _end_iteration << " order_end=" << _end_order << " and end_time=" << _end_time << "\n";
return stream.str();
}
const MEDCouplingConstOnTimeInterval *otherC=dynamic_cast<const MEDCouplingConstOnTimeInterval *>(other);
if(!otherC)
return false;
- if(_start_dt!=otherC->_start_dt)
+ if(_start_iteration!=otherC->_start_iteration)
return false;
- if(_start_it!=otherC->_start_it)
+ if(_start_order!=otherC->_start_order)
return false;
if(std::fabs(_start_time-otherC->_start_time)>_time_tolerance)
return false;
- if(_end_dt!=otherC->_end_dt)
+ if(_end_iteration!=otherC->_end_iteration)
return false;
- if(_end_it!=otherC->_end_it)
+ if(_end_order!=otherC->_end_order)
return false;
if(std::fabs(_end_time-otherC->_end_time)>_time_tolerance)
return false;
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
}
-void MEDCouplingConstOnTimeInterval::getValueOnDiscTime(int eltId, int dt, int it, double *value) const throw(INTERP_KERNEL::Exception)
+void MEDCouplingConstOnTimeInterval::getValueOnDiscTime(int eltId, int iteration, int order, double *value) const throw(INTERP_KERNEL::Exception)
{
- if(dt>=_start_dt && dt<=_end_dt)
+ if(iteration>=_start_iteration && iteration<=_end_iteration)
if(_array)
_array->getTuple(eltId,value);
else
if(time<_start_time-_time_tolerance || time>_end_time+_time_tolerance)
{
std::ostringstream stream;
- stream << "The field is defined between times " << _start_time << " and " << _end_time << " with tolerance ";
+ stream << "The field is defined between times " << _start_time << " and " << _end_time << " worderh tolerance ";
stream << _time_tolerance << " and trying to access on time = " << time;
throw INTERP_KERNEL::Exception(stream.str().c_str());
}
MEDCouplingTwoTimeSteps::MEDCouplingTwoTimeSteps(const MEDCouplingTwoTimeSteps& other, bool deepCpy):MEDCouplingTimeDiscretization(other,deepCpy),
_start_time(other._start_time),_end_time(other._end_time),
- _start_dt(other._start_dt),_end_dt(other._end_dt),
- _start_it(other._start_it),_end_it(other._end_it)
+ _start_iteration(other._start_iteration),_end_iteration(other._end_iteration),
+ _start_order(other._start_order),_end_order(other._end_order)
{
if(other._end_array)
_end_array=other._end_array->performCpy(deepCpy);
const MEDCouplingTwoTimeSteps& otherC=dynamic_cast<const MEDCouplingTwoTimeSteps& >(other);
_start_time=otherC._start_time;
_end_time=otherC._end_time;
- _start_dt=otherC._start_dt;
- _end_dt=otherC._end_dt;
- _start_it=otherC._start_it;
- _end_it=otherC._end_it;
+ _start_iteration=otherC._start_iteration;
+ _end_iteration=otherC._end_iteration;
+ _start_order=otherC._start_order;
+ _end_order=otherC._end_order;
}
void MEDCouplingTwoTimeSteps::copyTinyStringsFrom(const MEDCouplingTimeDiscretization& other)
const MEDCouplingTwoTimeSteps *otherC=dynamic_cast<const MEDCouplingTwoTimeSteps *>(other);
if(!otherC)
return false;
- if(_start_dt!=otherC->_start_dt)
+ if(_start_iteration!=otherC->_start_iteration)
return false;
- if(_end_dt!=otherC->_end_dt)
+ if(_end_iteration!=otherC->_end_iteration)
return false;
- if(_start_it!=otherC->_start_it)
+ if(_start_order!=otherC->_start_order)
return false;
- if(_end_it!=otherC->_end_it)
+ if(_end_order!=otherC->_end_order)
return false;
if(std::fabs(_start_time-otherC->_start_time)>_time_tolerance)
return false;
return MEDCouplingTimeDiscretization::isEqual(other,prec);
}
-MEDCouplingTwoTimeSteps::MEDCouplingTwoTimeSteps():_start_time(0.),_end_time(0.),_start_dt(-1),_end_dt(-1),_start_it(-1),_end_it(-1),_end_array(0)
+MEDCouplingTwoTimeSteps::MEDCouplingTwoTimeSteps():_start_time(0.),_end_time(0.),_start_iteration(-1),_end_iteration(-1),_start_order(-1),_end_order(-1),_end_array(0)
{
}
if(time<_start_time-_time_tolerance || time>_end_time+_time_tolerance)
{
std::ostringstream stream;
- stream << "The field is defined between times " << _start_time << " and " << _end_time << " with tolerance ";
+ stream << "The field is defined between times " << _start_time << " and " << _end_time << " worderh tolerance ";
stream << _time_tolerance << " and trying to access on time = " << time;
throw INTERP_KERNEL::Exception(stream.str().c_str());
}
void MEDCouplingTwoTimeSteps::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
{
MEDCouplingTimeDiscretization::getTinySerializationIntInformation(tinyInfo);
- tinyInfo.push_back(_start_dt);
- tinyInfo.push_back(_start_it);
- tinyInfo.push_back(_end_dt);
- tinyInfo.push_back(_end_it);
+ tinyInfo.push_back(_start_iteration);
+ tinyInfo.push_back(_start_order);
+ tinyInfo.push_back(_end_iteration);
+ tinyInfo.push_back(_end_order);
if(_end_array)
{
tinyInfo.push_back(_end_array->getNumberOfTuples());
MEDCouplingTimeDiscretization::finishUnserialization(tinyInfoI,tinyInfoD,tinyInfoS);
_start_time=tinyInfoD[1];
_end_time=tinyInfoD[2];
- _start_dt=tinyInfoI[2];
- _start_it=tinyInfoI[3];
- _end_dt=tinyInfoI[4];
- _end_it=tinyInfoI[5];
+ _start_iteration=tinyInfoI[2];
+ _start_order=tinyInfoI[3];
+ _end_iteration=tinyInfoI[4];
+ _end_order=tinyInfoI[5];
}
std::vector< const DataArrayDouble *> MEDCouplingTwoTimeSteps::getArraysForTime(double time) const throw(INTERP_KERNEL::Exception)
if(arrays.size()!=2)
throw INTERP_KERNEL::Exception("MEDCouplingTwoTimeSteps::setArrays : number of arrays must be two.");
setArray(arrays.front(),owner);
- setArray(arrays.back(),owner);
+ setEndArray(arrays.back(),owner);
}
MEDCouplingLinearTime::MEDCouplingLinearTime(const MEDCouplingLinearTime& other, bool deepCpy):MEDCouplingTwoTimeSteps(other,deepCpy)
std::string MEDCouplingLinearTime::getStringRepr() const
{
std::ostringstream stream;
- stream << REPR << " Time interval is defined by :\ndt_start=" << _start_dt << " it_start=" << _start_it << " and time_start=" << _start_time << "\n";
- stream << "dt_end=" << _end_dt << " it_end=" << _end_it << " and end_time=" << _end_time << "\n";
+ stream << REPR << " Time interval is defined by :\niteration_start=" << _start_iteration << " order_start=" << _start_order << " and time_start=" << _start_time << "\n";
+ stream << "iteration_end=" << _end_iteration << " order_end=" << _end_order << " and end_time=" << _end_time << "\n";
return stream.str();
}
std::transform(tmp.begin(),tmp.end(),value,value,std::plus<double>());
}
-void MEDCouplingLinearTime::getValueOnDiscTime(int eltId, int dt, int it, double *value) const throw(INTERP_KERNEL::Exception)
+void MEDCouplingLinearTime::getValueOnDiscTime(int eltId, int iteration, int order, double *value) const throw(INTERP_KERNEL::Exception)
{
- if(dt==_start_dt && it==_start_it)
+ if(iteration==_start_iteration && order==_start_order)
{
if(_array)
_array->getTuple(eltId,value);
else
- throw INTERP_KERNEL::Exception("dt it match with start time but no start array existing.");
+ throw INTERP_KERNEL::Exception("iteration order match with start time but no start array existing.");
}
- if(dt==_end_dt && it==_end_it)
+ if(iteration==_end_iteration && order==_end_order)
{
if(_end_array)
_end_array->getTuple(eltId,value);
else
- throw INTERP_KERNEL::Exception("dt it match with end time but no end array existing.");
+ throw INTERP_KERNEL::Exception("iteration order match with end time but no end array existing.");
}
else
throw INTERP_KERNEL::Exception(EXCEPTION_MSG);
virtual void getArrays(std::vector<DataArrayDouble *>& arrays) const;
virtual bool isBefore(const MEDCouplingTimeDiscretization *other) const throw(INTERP_KERNEL::Exception);
virtual bool isStrictlyBefore(const MEDCouplingTimeDiscretization *other) const throw(INTERP_KERNEL::Exception);
- double getTime(int& dt, int& it) const throw(INTERP_KERNEL::Exception) { return getStartTime(dt,it); }
- virtual double getStartTime(int& dt, int& it) const throw(INTERP_KERNEL::Exception) = 0;
- virtual double getEndTime(int& dt, int& it) const throw(INTERP_KERNEL::Exception) = 0;
- void setTime(double time, int dt, int it) throw(INTERP_KERNEL::Exception) { setStartTime(time,dt,it); }
- virtual void setStartTime(double time, int dt, int it) throw(INTERP_KERNEL::Exception) = 0;
- virtual void setEndTime(double time, int dt, int it) throw(INTERP_KERNEL::Exception) = 0;
+ double getTime(int& iteration, int& order) const throw(INTERP_KERNEL::Exception) { return getStartTime(iteration,order); }
+ virtual double getStartTime(int& iteration, int& order) const throw(INTERP_KERNEL::Exception) = 0;
+ virtual double getEndTime(int& iteration, int& order) const throw(INTERP_KERNEL::Exception) = 0;
+ void setTime(double time, int iteration, int order) throw(INTERP_KERNEL::Exception) { setStartTime(time,iteration,order); }
+ virtual void setStartTime(double time, int iteration, int order) throw(INTERP_KERNEL::Exception) = 0;
+ virtual void setEndTime(double time, int iteration, int order) throw(INTERP_KERNEL::Exception) = 0;
virtual void getValueOnTime(int eltId, double time, double *value) const throw(INTERP_KERNEL::Exception) = 0;
- virtual void getValueOnDiscTime(int eltId, int dt, int it, double *value) const throw(INTERP_KERNEL::Exception) = 0;
+ virtual void getValueOnDiscTime(int eltId, int iteration, int order, double *value) const throw(INTERP_KERNEL::Exception) = 0;
//
+ virtual MEDCouplingTimeDiscretization *doublyContractedProduct() const throw(INTERP_KERNEL::Exception);
+ virtual MEDCouplingTimeDiscretization *determinant() const throw(INTERP_KERNEL::Exception);
+ virtual MEDCouplingTimeDiscretization *eigenValues() const throw(INTERP_KERNEL::Exception);
+ virtual MEDCouplingTimeDiscretization *eigenVectors() const throw(INTERP_KERNEL::Exception);
+ virtual MEDCouplingTimeDiscretization *inverse() const throw(INTERP_KERNEL::Exception);
+ virtual MEDCouplingTimeDiscretization *trace() const throw(INTERP_KERNEL::Exception);
+ virtual MEDCouplingTimeDiscretization *deviator() const throw(INTERP_KERNEL::Exception);
+ virtual MEDCouplingTimeDiscretization *magnitude() const throw(INTERP_KERNEL::Exception);
+ virtual MEDCouplingTimeDiscretization *maxPerTuple() const throw(INTERP_KERNEL::Exception);
+ virtual void changeNbOfComponents(int newNbOfComp, double dftValue) throw(INTERP_KERNEL::Exception);
+ virtual void sortPerTuple(bool asc) throw(INTERP_KERNEL::Exception);
virtual void applyLin(double a, double b, int compoId);
virtual void applyFunc(int nbOfComp, FunctionToEvaluate func);
virtual void applyFunc(int nbOfComp, const char *func);
virtual void applyFunc(const char *func);
virtual void applyFuncFast32(const char *func);
virtual void applyFuncFast64(const char *func);
+
//
virtual ~MEDCouplingTimeDiscretization();
protected:
void getValueForTime(double time, const std::vector<double>& vals, double *res) const;
bool isBefore(const MEDCouplingTimeDiscretization *other) const throw(INTERP_KERNEL::Exception);
bool isStrictlyBefore(const MEDCouplingTimeDiscretization *other) const throw(INTERP_KERNEL::Exception);
- double getStartTime(int& dt, int& it) const throw(INTERP_KERNEL::Exception);
- double getEndTime(int& dt, int& it) const throw(INTERP_KERNEL::Exception);
- void setStartTime(double time, int dt, int it) throw(INTERP_KERNEL::Exception);
- void setEndTime(double time, int dt, int it) throw(INTERP_KERNEL::Exception);
+ double getStartTime(int& iteration, int& order) const throw(INTERP_KERNEL::Exception);
+ double getEndTime(int& iteration, int& order) const throw(INTERP_KERNEL::Exception);
+ void setStartTime(double time, int iteration, int order) throw(INTERP_KERNEL::Exception);
+ void setEndTime(double time, int iteration, int order) throw(INTERP_KERNEL::Exception);
void getValueOnTime(int eltId, double time, double *value) const throw(INTERP_KERNEL::Exception);
- void getValueOnDiscTime(int eltId, int dt, int it, double *value) const throw(INTERP_KERNEL::Exception);
+ void getValueOnDiscTime(int eltId, int iteration, int order, double *value) const throw(INTERP_KERNEL::Exception);
public:
static const TypeOfTimeDiscretization DISCRETIZATION=NO_TIME;
static const char REPR[];
MEDCouplingTimeDiscretization *performCpy(bool deepCpy) const;
void checkNoTimePresence() const throw(INTERP_KERNEL::Exception);
void checkTimePresence(double time) const throw(INTERP_KERNEL::Exception);
- void setStartTime(double time, int dt, int it) throw(INTERP_KERNEL::Exception) { _time=time; _dt=dt; _it=it; }
- void setEndTime(double time, int dt, int it) throw(INTERP_KERNEL::Exception) { _time=time; _dt=dt; _it=it; }
- double getStartTime(int& dt, int& it) const throw(INTERP_KERNEL::Exception) { dt=_dt; it=_it; return _time; }
- double getEndTime(int& dt, int& it) const throw(INTERP_KERNEL::Exception) { dt=_dt; it=_it; return _time; }
+ void setStartTime(double time, int iteration, int order) throw(INTERP_KERNEL::Exception) { _time=time; _iteration=iteration; _order=order; }
+ void setEndTime(double time, int iteration, int order) throw(INTERP_KERNEL::Exception) { _time=time; _iteration=iteration; _order=order; }
+ double getStartTime(int& iteration, int& order) const throw(INTERP_KERNEL::Exception) { iteration=_iteration; order=_order; return _time; }
+ double getEndTime(int& iteration, int& order) const throw(INTERP_KERNEL::Exception) { iteration=_iteration; order=_order; return _time; }
std::vector< const DataArrayDouble *> getArraysForTime(double time) const throw(INTERP_KERNEL::Exception);
void getValueForTime(double time, const std::vector<double>& vals, double *res) const;
void getValueOnTime(int eltId, double time, double *value) const throw(INTERP_KERNEL::Exception);
- void getValueOnDiscTime(int eltId, int dt, int it, double *value) const throw(INTERP_KERNEL::Exception);
+ void getValueOnDiscTime(int eltId, int iteration, int order, double *value) const throw(INTERP_KERNEL::Exception);
public:
static const TypeOfTimeDiscretization DISCRETIZATION=ONE_TIME;
static const char REPR[];
static const char EXCEPTION_MSG[];
protected:
double _time;
- int _dt;
- int _it;
+ int _iteration;
+ int _order;
};
class MEDCOUPLING_EXPORT MEDCouplingConstOnTimeInterval : public MEDCouplingTimeDiscretization
std::vector< const DataArrayDouble *> getArraysForTime(double time) const throw(INTERP_KERNEL::Exception);
void getValueForTime(double time, const std::vector<double>& vals, double *res) const;
void getValueOnTime(int eltId, double time, double *value) const throw(INTERP_KERNEL::Exception);
- void getValueOnDiscTime(int eltId, int dt, int it, double *value) const throw(INTERP_KERNEL::Exception);
+ void getValueOnDiscTime(int eltId, int iteration, int order, double *value) const throw(INTERP_KERNEL::Exception);
TypeOfTimeDiscretization getEnum() const { return DISCRETIZATION; }
std::string getStringRepr() const;
MEDCouplingTimeDiscretization *aggregate(const MEDCouplingTimeDiscretization *other) const;
void multiplyEqual(const MEDCouplingTimeDiscretization *other);
MEDCouplingTimeDiscretization *divide(const MEDCouplingTimeDiscretization *other) const;
void divideEqual(const MEDCouplingTimeDiscretization *other);
- void setStartTime(double time, int dt, int it) throw(INTERP_KERNEL::Exception) { _start_time=time; _start_dt=dt; _start_it=it; }
- void setEndTime(double time, int dt, int it) throw(INTERP_KERNEL::Exception) { _end_time=time; _end_dt=dt; _end_it=it; }
- double getStartTime(int& dt, int& it) const throw(INTERP_KERNEL::Exception) { dt=_start_dt; it=_start_it; return _start_time; }
- double getEndTime(int& dt, int& it) const throw(INTERP_KERNEL::Exception) { dt=_end_dt; it=_end_it; return _end_time; }
+ void setStartTime(double time, int iteration, int order) throw(INTERP_KERNEL::Exception) { _start_time=time; _start_iteration=iteration; _start_order=order; }
+ void setEndTime(double time, int iteration, int order) throw(INTERP_KERNEL::Exception) { _end_time=time; _end_iteration=iteration; _end_order=order; }
+ double getStartTime(int& iteration, int& order) const throw(INTERP_KERNEL::Exception) { iteration=_start_iteration; order=_start_order; return _start_time; }
+ double getEndTime(int& iteration, int& order) const throw(INTERP_KERNEL::Exception) { iteration=_end_iteration; order=_end_order; return _end_time; }
void checkNoTimePresence() const throw(INTERP_KERNEL::Exception);
void checkTimePresence(double time) const throw(INTERP_KERNEL::Exception);
public:
protected:
double _start_time;
double _end_time;
- int _start_dt;
- int _end_dt;
- int _start_it;
- int _end_it;
+ int _start_iteration;
+ int _end_iteration;
+ int _start_order;
+ int _end_order;
};
class MEDCOUPLING_EXPORT MEDCouplingTwoTimeSteps : public MEDCouplingTimeDiscretization
void checkTimePresence(double time) const throw(INTERP_KERNEL::Exception);
void getArrays(std::vector<DataArrayDouble *>& arrays) const;
void setEndArray(DataArrayDouble *array, TimeLabel *owner);
- void setStartTime(double time, int dt, int it) throw(INTERP_KERNEL::Exception) { _start_time=time; _start_dt=dt; _start_it=it; }
- void setEndTime(double time, int dt, int it) throw(INTERP_KERNEL::Exception) { _end_time=time; _end_dt=dt; _end_it=it; }
- double getStartTime(int& dt, int& it) const throw(INTERP_KERNEL::Exception) { dt=_start_dt; it=_start_it; return _start_time; }
- double getEndTime(int& dt, int& it) const throw(INTERP_KERNEL::Exception) { dt=_end_dt; it=_end_it; return _end_time; }
+ void setStartTime(double time, int iteration, int order) throw(INTERP_KERNEL::Exception) { _start_time=time; _start_iteration=iteration; _start_order=order; }
+ void setEndTime(double time, int iteration, int order) throw(INTERP_KERNEL::Exception) { _end_time=time; _end_iteration=iteration; _end_order=order; }
+ double getStartTime(int& iteration, int& order) const throw(INTERP_KERNEL::Exception) { iteration=_start_iteration; order=_start_order; return _start_time; }
+ double getEndTime(int& iteration, int& order) const throw(INTERP_KERNEL::Exception) { iteration=_end_iteration; order=_end_order; return _end_time; }
void getTinySerializationIntInformation(std::vector<int>& tinyInfo) const;
void getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const;
void getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const;
protected:
double _start_time;
double _end_time;
- int _start_dt;
- int _end_dt;
- int _start_it;
- int _end_it;
+ int _start_iteration;
+ int _end_iteration;
+ int _start_order;
+ int _end_order;
DataArrayDouble *_end_array;
};
bool areStrictlyCompatibleForMul(const MEDCouplingTimeDiscretization *other) const;
void getValueForTime(double time, const std::vector<double>& vals, double *res) const;
void getValueOnTime(int eltId, double time, double *value) const throw(INTERP_KERNEL::Exception);
- void getValueOnDiscTime(int eltId, int dt, int it, double *value) const throw(INTERP_KERNEL::Exception);
+ void getValueOnDiscTime(int eltId, int iteration, int order, double *value) const throw(INTERP_KERNEL::Exception);
MEDCouplingTimeDiscretization *aggregate(const MEDCouplingTimeDiscretization *other) const;
MEDCouplingTimeDiscretization *dot(const MEDCouplingTimeDiscretization *other) const;
MEDCouplingTimeDiscretization *crossProduct(const MEDCouplingTimeDiscretization *other) const;
CPPUNIT_TEST( testApplyLin1 );
CPPUNIT_TEST( testGetIdsInRange1 );
CPPUNIT_TEST( testBuildSubPart1 );
+ CPPUNIT_TEST( testDoublyContractedProduct1 );
+ CPPUNIT_TEST( testDeterminant1 );
+ CPPUNIT_TEST( testEigenValues1 );
+ CPPUNIT_TEST( testEigenVectors1 );
+ CPPUNIT_TEST( testInverse1 );
+ CPPUNIT_TEST( testTrace1 );
+ CPPUNIT_TEST( testDeviator1 );
+ CPPUNIT_TEST( testMagnitude1 );
+ CPPUNIT_TEST( testMaxPerTuple1 );
+ CPPUNIT_TEST( testChangeNbOfComponents );
+ CPPUNIT_TEST( testSortPerTuple1 );
//MEDCouplingBasicsTestInterp.cxx
CPPUNIT_TEST( test2DInterpP0P0_1 );
CPPUNIT_TEST( test2DInterpP0P0PL_1 );
void testApplyLin1();
void testGetIdsInRange1();
void testBuildSubPart1();
+ void testDoublyContractedProduct1();
+ void testDeterminant1();
+ void testEigenValues1();
+ void testEigenVectors1();
+ void testInverse1();
+ void testTrace1();
+ void testDeviator1();
+ void testMagnitude1();
+ void testMaxPerTuple1();
+ void testChangeNbOfComponents();
+ void testSortPerTuple1();
//MEDCouplingBasicsTestInterp.cxx
void test2DInterpP0P0_1();
void test2DInterpP0P0PL_1();
f1->decrRef();
mesh1->decrRef();
}
+
+void MEDCouplingBasicsTest::testDoublyContractedProduct1()
+{
+ MEDCouplingUMesh *mesh1=build2DTargetMesh_1();
+ MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
+ f1->setMesh(mesh1);
+ DataArrayDouble *array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),6);
+ const double arr1[30]={7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5};
+ std::copy(arr1,arr1+30,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ //
+ MEDCouplingFieldDouble *f2=f1->doublyContractedProduct();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(1,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples());
+ for(int i=0;i<5;i++)
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(3906.56,f2->getIJ(i,0),1e-9);
+ f2->decrRef();
+ //
+ mesh1->decrRef();
+ f1->decrRef();
+}
+
+void MEDCouplingBasicsTest::testDeterminant1()
+{
+ MEDCouplingUMesh *mesh1=build2DTargetMesh_1();
+ MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,CONST_ON_TIME_INTERVAL);
+ f1->setTime(2.3,5,6);
+ f1->setEndTime(3.8,7,3);
+ f1->setMesh(mesh1);
+ DataArrayDouble *array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),4);
+ const double arr1[20]={1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5};
+ std::copy(arr1,arr1+20,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ //4 components
+ f1->checkCoherency();
+ MEDCouplingFieldDouble *f2=f1->determinant();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(CONST_ON_TIME_INTERVAL,f2->getTimeDiscretization());
+ CPPUNIT_ASSERT_EQUAL(1,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfValues());
+ for(int i=0;i<5;i++)
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(-2.42,f2->getIJ(i,0),1e-13);
+ f2->decrRef();
+ f1->decrRef();
+ //6 components multi arrays with end array not defined
+ f1=MEDCouplingFieldDouble::New(ON_NODES,LINEAR_TIME);
+ f1->setTime(2.3,5,6);
+ f1->setEndTime(3.8,7,3);
+ f1->setMesh(mesh1);
+ array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfNodes(),6);
+ const double arr2[54]={1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7,
+ 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7};
+ std::copy(arr2,arr2+54,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ CPPUNIT_ASSERT_THROW(f1->checkCoherency(),INTERP_KERNEL::Exception);//no end array specified !
+ //
+ f2=f1->determinant();
+ CPPUNIT_ASSERT_EQUAL(LINEAR_TIME,f2->getTimeDiscretization());
+ CPPUNIT_ASSERT_EQUAL(1,f2->getArray()->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(9,f2->getNumberOfTuples());
+ for(int i=0;i<9;i++)
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(137.335,f2->getIJ(i,0),1e-10);
+ f2->decrRef();
+ //6 components multi arrays with end array defined
+ array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfNodes(),6);
+ const double arr3[54]={7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5,
+ 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5};
+ std::copy(arr3,arr3+54,array->getPointer());
+ f1->setEndArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ f2=f1->determinant();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(LINEAR_TIME,f2->getTimeDiscretization());
+ CPPUNIT_ASSERT_EQUAL(1,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(9,f2->getNumberOfTuples());
+ int it,order;
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(2.3,f2->getTime(it,order),1e-12);
+ CPPUNIT_ASSERT_EQUAL(5,it); CPPUNIT_ASSERT_EQUAL(6,order);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(3.8,f2->getEndTime(it,order),1e-12);
+ CPPUNIT_ASSERT_EQUAL(7,it); CPPUNIT_ASSERT_EQUAL(3,order);
+ for(int i=0;i<9;i++)
+ {
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(137.335,f2->getIJ(i,0),1e-10);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(1289.685,f2->getEndArray()->getIJ(i,0),1e-9);
+ }
+ f2->decrRef();
+ f1->decrRef();
+ //9 components
+ f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
+ f1->setTime(7.8,10,2);
+ f1->setMesh(mesh1);
+ array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),9);
+ const double arr4[45]={1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1};
+ std::copy(arr4,arr4+45,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ //
+ f1->checkCoherency();
+ f2=f1->determinant();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(ONE_TIME,f2->getTimeDiscretization());
+ CPPUNIT_ASSERT_EQUAL(1,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples());
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(7.8,f2->getTime(it,order),1e-12);
+ CPPUNIT_ASSERT_EQUAL(10,it); CPPUNIT_ASSERT_EQUAL(2,order);
+ for(int i=0;i<5;i++)
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(3.267,f2->getIJ(i,0),1e-13);
+ f2->decrRef();
+ //
+ mesh1->decrRef();
+ f1->decrRef();
+}
+
+void MEDCouplingBasicsTest::testEigenValues1()
+{
+ MEDCouplingUMesh *mesh1=build2DTargetMesh_1();
+ MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
+ f1->setMesh(mesh1);
+ DataArrayDouble *array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),6);
+ const double arr1[30]={1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7};
+ std::copy(arr1,arr1+30,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ //
+ MEDCouplingFieldDouble *f2=f1->eigenValues();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(3,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples());
+ const double expected1[3]={13.638813677891717,-4.502313844635971,-2.2364998332557486};
+ for(int i=0;i<5;i++)
+ {
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[0],f2->getIJ(i,0),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[1],f2->getIJ(i,1),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[2],f2->getIJ(i,2),1e-13);
+ }
+ f2->decrRef();
+ //
+ mesh1->decrRef();
+ f1->decrRef();
+}
+
+void MEDCouplingBasicsTest::testEigenVectors1()
+{
+ MEDCouplingUMesh *mesh1=build2DTargetMesh_1();
+ MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
+ f1->setMesh(mesh1);
+ DataArrayDouble *array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),6);
+ const double arr1[30]={1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7};
+ std::copy(arr1,arr1+30,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ //
+ MEDCouplingFieldDouble *f2=f1->eigenVectors();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(9,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples());
+ const double expected1[9]={
+ 0.5424262364180696, 0.5351201064614425, 0.6476266283176001,//eigenvect 0
+ 0.7381111277307373, 0.06458838384003074, -0.6715804522117897,//eigenvect 1
+ -0.4012053603397987, 0.8423032781211455, -0.3599436712889738//eigenvect 2
+ };
+ for(int i=0;i<5;i++)
+ {
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[0],f2->getIJ(i,0),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[1],f2->getIJ(i,1),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[2],f2->getIJ(i,2),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[3],f2->getIJ(i,3),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[4],f2->getIJ(i,4),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[5],f2->getIJ(i,5),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[6],f2->getIJ(i,6),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[7],f2->getIJ(i,7),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[8],f2->getIJ(i,8),1e-13);
+ }
+ f2->decrRef();
+ //
+ mesh1->decrRef();
+ f1->decrRef();
+}
+
+void MEDCouplingBasicsTest::testInverse1()
+{
+ MEDCouplingUMesh *mesh1=build2DTargetMesh_1();
+ MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
+ f1->setMesh(mesh1);
+ DataArrayDouble *array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),9);
+ const double arr1[45]={1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1};
+ std::copy(arr1,arr1+45,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ //
+ MEDCouplingFieldDouble *f2=f1->inverse();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(9,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples());
+ const double expected1[9]={-2.6538108356290113, 2.855831037649208, -1.1111111111111067, 3.461891643709813, -4.775022956841121, 2.2222222222222143, -1.1111111111111054, 2.222222222222214, -1.1111111111111072};
+ for(int i=0;i<5;i++)
+ {
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[0],f2->getIJ(i,0),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[1],f2->getIJ(i,1),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[2],f2->getIJ(i,2),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[3],f2->getIJ(i,3),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[4],f2->getIJ(i,4),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[5],f2->getIJ(i,5),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[6],f2->getIJ(i,6),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[7],f2->getIJ(i,7),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[8],f2->getIJ(i,8),1e-13);
+ }
+ f2->decrRef();
+ //
+ array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),6);
+ const double arr3[30]={7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5};
+ std::copy(arr3,arr3+30,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ //
+ f2=f1->inverse();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(6,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples());
+ const double expected3[6]={-0.3617705098531818, -0.8678630828458127, -0.026843764174972983, 0.5539957431465833, 0.13133439560823013, -0.05301294502145887};
+ for(int i=0;i<5;i++)
+ {
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[0],f2->getIJ(i,0),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[1],f2->getIJ(i,1),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[2],f2->getIJ(i,2),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[3],f2->getIJ(i,3),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[4],f2->getIJ(i,4),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[5],f2->getIJ(i,5),1e-13);
+ }
+ f2->decrRef();
+ //
+ array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),4);
+ const double arr2[20]={1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5};
+ std::copy(arr2,arr2+20,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ //
+ f2=f1->inverse();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(4,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples());
+ const double expected2[4]={-1.8595041322314059, 0.9504132231404963, 1.404958677685951, -0.49586776859504156};
+ for(int i=0;i<5;i++)
+ {
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[0],f2->getIJ(i,0),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[1],f2->getIJ(i,1),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[2],f2->getIJ(i,2),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[3],f2->getIJ(i,3),1e-13);
+ }
+ f2->decrRef();
+ //
+ mesh1->decrRef();
+ f1->decrRef();
+}
+
+void MEDCouplingBasicsTest::testTrace1()
+{
+ MEDCouplingUMesh *mesh1=build2DTargetMesh_1();
+ MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
+ f1->setMesh(mesh1);
+ DataArrayDouble *array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),9);
+ const double arr1[45]={1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1};
+ std::copy(arr1,arr1+45,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ //
+ MEDCouplingFieldDouble *f2=f1->trace();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(1,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples());
+ for(int i=0;i<5;i++)
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(15.9,f2->getIJ(i,0),1e-13);
+ f2->decrRef();
+ //
+ array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),6);
+ const double arr3[30]={7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5};
+ std::copy(arr3,arr3+30,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ //
+ f2=f1->trace();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(1,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples());
+ for(int i=0;i<5;i++)
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(25.8,f2->getIJ(i,0),1e-13);
+ f2->decrRef();
+ //
+ array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),4);
+ const double arr2[20]={1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5};
+ std::copy(arr2,arr2+20,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ //
+ f2=f1->trace();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(1,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples());
+ for(int i=0;i<5;i++)
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(5.7,f2->getIJ(i,0),1e-13);
+ f2->decrRef();
+ //
+ mesh1->decrRef();
+ f1->decrRef();
+}
+
+void MEDCouplingBasicsTest::testDeviator1()
+{
+ MEDCouplingUMesh *mesh1=build2DTargetMesh_1();
+ MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
+ f1->setMesh(mesh1);
+ DataArrayDouble *array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),6);
+ const double arr1[30]={1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7};
+ std::copy(arr1,arr1+30,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ //
+ MEDCouplingFieldDouble *f2=f1->deviator();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(6,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples());
+ const double expected1[6]={-1.1,0.,1.1,4.5,5.6,6.7};
+ for(int i=0;i<5;i++)
+ {
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[0],f2->getIJ(i,0),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[1],f2->getIJ(i,1),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[2],f2->getIJ(i,2),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[3],f2->getIJ(i,3),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[4],f2->getIJ(i,4),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[5],f2->getIJ(i,5),1e-13);
+ }
+ f2->decrRef();
+ //
+ mesh1->decrRef();
+ f1->decrRef();
+}
+
+void MEDCouplingBasicsTest::testMagnitude1()
+{
+ MEDCouplingUMesh *mesh1=build2DTargetMesh_1();
+ MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
+ f1->setMesh(mesh1);
+ DataArrayDouble *array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),5);
+ const double arr1[25]={1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6};
+ std::copy(arr1,arr1+25,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ //
+ MEDCouplingFieldDouble *f2=f1->magnitude();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(1,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples());
+ for(int i=0;i<5;i++)
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(8.3606219864313918,f2->getIJ(i,0),1e-13);
+ f2->decrRef();
+ //
+ mesh1->decrRef();
+ f1->decrRef();
+}
+
+void MEDCouplingBasicsTest::testMaxPerTuple1()
+{
+ MEDCouplingUMesh *mesh1=build2DTargetMesh_1();
+ MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
+ f1->setMesh(mesh1);
+ DataArrayDouble *array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),5);
+ const double arr1[25]={1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4};
+ std::copy(arr1,arr1+25,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ //
+ MEDCouplingFieldDouble *f2=f1->maxPerTuple();
+ f2->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(1,f2->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples());
+ for(int i=0;i<5;i++)
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(5.6,f2->getIJ(i,0),1e-13);
+ f2->decrRef();
+ //
+ mesh1->decrRef();
+ f1->decrRef();
+}
+
+void MEDCouplingBasicsTest::testChangeNbOfComponents()
+{
+ MEDCouplingUMesh *mesh1=build2DTargetMesh_1();
+ MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
+ f1->setMesh(mesh1);
+ DataArrayDouble *array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),5);
+ const double arr1[25]={1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4};
+ std::copy(arr1,arr1+25,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ //
+ f1->changeNbOfComponents(3,7.77);
+ f1->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(3,f1->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f1->getNumberOfTuples());
+ const double expected1[15]={1.2,2.3,3.4, 1.2,3.4,4.5, 3.4,4.5,5.6, 5.6,1.2,2.3, 4.5,5.6,1.2};
+ for(int i=0;i<15;i++)
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f1->getIJ(0,i),1e-13);
+ f1->changeNbOfComponents(4,7.77);
+ f1->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(4,f1->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f1->getNumberOfTuples());
+ const double expected2[20]={1.2,2.3,3.4,7.77, 1.2,3.4,4.5,7.77, 3.4,4.5,5.6,7.77, 5.6,1.2,2.3,7.77, 4.5,5.6,1.2,7.77};
+ for(int i=0;i<20;i++)
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f1->getIJ(0,i),1e-13);
+ //
+ mesh1->decrRef();
+ f1->decrRef();
+}
+
+void MEDCouplingBasicsTest::testSortPerTuple1()
+{
+ MEDCouplingUMesh *mesh1=build2DTargetMesh_1();
+ MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
+ f1->setMesh(mesh1);
+ DataArrayDouble *array=DataArrayDouble::New();
+ array->alloc(mesh1->getNumberOfCells(),5);
+ const double arr1[25]={1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4};
+ std::copy(arr1,arr1+25,array->getPointer());
+ f1->setArray(array);
+ array->decrRef();
+ f1->checkCoherency();
+ //
+ f1->sortPerTuple(true);
+ f1->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(5,f1->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f1->getNumberOfTuples());
+ for(int i=0;i<5;i++)
+ {
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[0],f1->getIJ(i,0),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[1],f1->getIJ(i,1),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[2],f1->getIJ(i,2),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[3],f1->getIJ(i,3),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[4],f1->getIJ(i,4),1e-13);
+ }
+ //
+ f1->sortPerTuple(false);
+ f1->checkCoherency();
+ CPPUNIT_ASSERT_EQUAL(5,f1->getNumberOfComponents());
+ CPPUNIT_ASSERT_EQUAL(5,f1->getNumberOfTuples());
+ for(int i=0;i<5;i++)
+ {
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[4],f1->getIJ(i,0),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[3],f1->getIJ(i,1),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[2],f1->getIJ(i,2),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[1],f1->getIJ(i,3),1e-13);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(arr1[0],f1->getIJ(i,4),1e-13);
+ }
+ //
+ mesh1->decrRef();
+ f1->decrRef();
+}
self.failUnlessEqual(expected3[8:13],m2C.getNodalConnectivity().getValues()[8:13]);
self.failUnlessEqual(expected4,m2C.getNodalConnectivityIndex().getValues());
pass
+
+ def testDoublyContractedProduct1(self):
+ mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
+ f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
+ f1.setMesh(mesh1);
+ array=DataArrayDouble.New();
+ arr1=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
+ array.setValues(arr1,mesh1.getNumberOfCells(),6);
+ f1.setArray(array);
+ f1.checkCoherency();
+ #
+ f2=f1.doublyContractedProduct();
+ f2.checkCoherency();
+ self.assertEqual(1,f2.getNumberOfComponents());
+ self.assertEqual(5,f2.getNumberOfTuples());
+ for i in xrange(5):
+ self.assertAlmostEqual(3906.56,f2.getIJ(i,0),9);
+ pass
+ #
+ pass
+
+ def testDeterminant1(self):
+ mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
+ f1=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL);
+ f1.setTime(2.3,5,6);
+ f1.setEndTime(3.8,7,3);
+ f1.setMesh(mesh1);
+ array=DataArrayDouble.New();
+ arr1=[1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5]
+ array.setValues(arr1,mesh1.getNumberOfCells(),4);
+ f1.setArray(array);
+ #4 components
+ f1.checkCoherency();
+ f2=f1.determinant();
+ f2.checkCoherency();
+ self.assertEqual(CONST_ON_TIME_INTERVAL,f2.getTimeDiscretization());
+ self.assertEqual(1,f2.getNumberOfComponents());
+ self.assertEqual(5,f2.getNumberOfValues());
+ for i in xrange(5):
+ self.assertAlmostEqual(-2.42,f2.getIJ(i,0),13);
+ pass
+ #6 components multi arrays with end array not defined
+ f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME);
+ f1.setTime(2.3,5,6);
+ f1.setEndTime(3.8,7,3);
+ f1.setMesh(mesh1);
+ array=DataArrayDouble.New();
+ arr2=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7,
+ 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
+ array.setValues(arr2,mesh1.getNumberOfNodes(),6);
+ f1.setArray(array);
+ self.assertRaises(Exception,f1.checkCoherency);#no end array specified !
+ #
+ f2=f1.determinant();
+ self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
+ self.assertEqual(1,f2.getArray().getNumberOfComponents());
+ self.assertEqual(9,f2.getNumberOfTuples());
+ for i in xrange(9):
+ self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
+ pass
+ #6 components multi arrays with end array defined
+ array=DataArrayDouble.New();
+ arr3=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5,
+ 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
+ array.setValues(arr3,mesh1.getNumberOfNodes(),6);
+ f1.setEndArray(array);
+ f1.checkCoherency();
+ f2=f1.determinant();
+ f2.checkCoherency();
+ self.assertEqual(LINEAR_TIME,f2.getTimeDiscretization());
+ self.assertEqual(1,f2.getNumberOfComponents());
+ self.assertEqual(9,f2.getNumberOfTuples());
+ time2,it,order=f2.getTime()
+ self.assertAlmostEqual(2.3,time2,12);
+ self.assertEqual(5,it);
+ self.assertEqual(6,order);
+ time2,it,order=f2.getEndTime()
+ self.assertAlmostEqual(3.8,time2,12);
+ self.assertEqual(7,it);
+ self.assertEqual(3,order);
+ for i in xrange(9):
+ self.assertAlmostEqual(137.335,f2.getIJ(i,0),10);
+ self.assertAlmostEqual(1289.685,f2.getEndArray().getIJ(i,0),9);
+ pass
+ #9 components
+ f1=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME);
+ f1.setTime(7.8,10,2);
+ f1.setMesh(mesh1);
+ array=DataArrayDouble.New();
+ arr4=[1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1]
+ array.setValues(arr4,mesh1.getNumberOfCells(),9);
+ f1.setArray(array);
+ #
+ f1.checkCoherency();
+ f2=f1.determinant();
+ f2.checkCoherency();
+ self.assertEqual(ONE_TIME,f2.getTimeDiscretization());
+ self.assertEqual(1,f2.getNumberOfComponents());
+ self.assertEqual(5,f2.getNumberOfTuples());
+ time2,it,order=f2.getTime()
+ self.assertAlmostEqual(7.8,time2,12);
+ self.assertEqual(10,it);
+ self.assertEqual(2,order);
+ for i in xrange(5):
+ self.assertAlmostEqual(3.267,f2.getIJ(i,0),13);
+ pass
+ pass
+
+ def testEigenValues1(self):
+ mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
+ f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
+ f1.setMesh(mesh1);
+ array=DataArrayDouble.New();
+ arr1=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
+ array.setValues(arr1,mesh1.getNumberOfCells(),6);
+ f1.setArray(array);
+ f1.checkCoherency();
+ #
+ f2=f1.eigenValues();
+ f2.checkCoherency();
+ self.assertEqual(3,f2.getNumberOfComponents());
+ self.assertEqual(5,f2.getNumberOfTuples());
+ expected1=[13.638813677891717,-4.502313844635971,-2.2364998332557486]
+ for i in xrange(5):
+ self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
+ self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
+ self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
+ pass
+ pass
+
+ def testEigenVectors1(self):
+ mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
+ f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
+ f1.setMesh(mesh1);
+ array=DataArrayDouble.New();
+ arr1=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
+ array.setValues(arr1,mesh1.getNumberOfCells(),6);
+ f1.setArray(array);
+ f1.checkCoherency();
+ #
+ f2=f1.eigenVectors();
+ f2.checkCoherency();
+ self.assertEqual(9,f2.getNumberOfComponents());
+ self.assertEqual(5,f2.getNumberOfTuples());
+ expected1=[0.5424262364180696, 0.5351201064614425, 0.6476266283176001,#eigenvect 0
+ 0.7381111277307373, 0.06458838384003074, -0.6715804522117897,#eigenvect 1
+ -0.4012053603397987, 0.8423032781211455, -0.3599436712889738#eigenvect 2
+ ]
+ for i in xrange(5):
+ self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),1e-13);
+ self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),1e-13);
+ self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),1e-13);
+ self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),1e-13);
+ self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),1e-13);
+ self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),1e-13);
+ self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),1e-13);
+ self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),1e-13);
+ self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),1e-13);
+ pass
+ #
+ pass
+
+ def testInverse1(self):
+ mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
+ f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
+ f1.setMesh(mesh1);
+ array=DataArrayDouble.New();
+ arr1=[1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1]
+ array.setValues(arr1,mesh1.getNumberOfCells(),9);
+ f1.setArray(array);
+ f1.checkCoherency();
+ #
+ f2=f1.inverse();
+ f2.checkCoherency();
+ self.assertEqual(9,f2.getNumberOfComponents());
+ self.assertEqual(5,f2.getNumberOfTuples());
+ expected1=[-2.6538108356290113, 2.855831037649208, -1.1111111111111067, 3.461891643709813, -4.775022956841121, 2.2222222222222143, -1.1111111111111054, 2.222222222222214, -1.1111111111111072]
+ for i in xrange(5):
+ self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
+ self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
+ self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
+ self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
+ self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
+ self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
+ self.assertAlmostEqual(expected1[6],f2.getIJ(i,6),13);
+ self.assertAlmostEqual(expected1[7],f2.getIJ(i,7),13);
+ self.assertAlmostEqual(expected1[8],f2.getIJ(i,8),13);
+ pass
+ #
+ array=DataArrayDouble.New();
+ arr3=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
+ array.setValues(arr3,mesh1.getNumberOfCells(),6);
+ f1.setArray(array);
+ f1.checkCoherency();
+ #
+ f2=f1.inverse();
+ f2.checkCoherency();
+ self.assertEqual(6,f2.getNumberOfComponents());
+ self.assertEqual(5,f2.getNumberOfTuples());
+ expected3=[-0.3617705098531818, -0.8678630828458127, -0.026843764174972983, 0.5539957431465833, 0.13133439560823013, -0.05301294502145887]
+ for i in xrange(5):
+ self.assertAlmostEqual(expected3[0],f2.getIJ(i,0),13);
+ self.assertAlmostEqual(expected3[1],f2.getIJ(i,1),13);
+ self.assertAlmostEqual(expected3[2],f2.getIJ(i,2),13);
+ self.assertAlmostEqual(expected3[3],f2.getIJ(i,3),13);
+ self.assertAlmostEqual(expected3[4],f2.getIJ(i,4),13);
+ self.assertAlmostEqual(expected3[5],f2.getIJ(i,5),13);
+ pass
+ #
+ array=DataArrayDouble.New();
+ arr2=[1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5]
+ array.setValues(arr2,mesh1.getNumberOfCells(),4);
+ f1.setArray(array);
+ f1.checkCoherency();
+ #
+ f2=f1.inverse();
+ f2.checkCoherency();
+ self.assertEqual(4,f2.getNumberOfComponents());
+ self.assertEqual(5,f2.getNumberOfTuples());
+ expected2=[-1.8595041322314059, 0.9504132231404963, 1.404958677685951, -0.49586776859504156]
+ for i in xrange(5):
+ self.assertAlmostEqual(expected2[0],f2.getIJ(i,0),13);
+ self.assertAlmostEqual(expected2[1],f2.getIJ(i,1),13);
+ self.assertAlmostEqual(expected2[2],f2.getIJ(i,2),13);
+ self.assertAlmostEqual(expected2[3],f2.getIJ(i,3),13);
+ pass
+ #
+ pass
+
+ def testTrace1(self):
+ mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
+ f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
+ f1.setMesh(mesh1);
+ array=DataArrayDouble.New();
+ arr1=[1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1, 1.2,2.3,3.4,4.5,5.6,6.7,7.8,8.9,9.1]
+ array.setValues(arr1,mesh1.getNumberOfCells(),9);
+ f1.setArray(array);
+ f1.checkCoherency();
+ #
+ f2=f1.trace();
+ f2.checkCoherency();
+ self.assertEqual(1,f2.getNumberOfComponents());
+ self.assertEqual(5,f2.getNumberOfTuples());
+ for i in xrange(5):
+ self.assertAlmostEqual(15.9,f2.getIJ(i,0),13);
+ pass
+ #
+ array=DataArrayDouble.New();
+ arr3=[7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5, 7.8,8.9,9.1,10.2,23.4,34.5]
+ array.setValues(arr3,mesh1.getNumberOfCells(),6);
+ f1.setArray(array);
+ f1.checkCoherency();
+ #
+ f2=f1.trace();
+ f2.checkCoherency();
+ self.assertEqual(1,f2.getNumberOfComponents());
+ self.assertEqual(5,f2.getNumberOfTuples());
+ for i in xrange(5):
+ self.assertAlmostEqual(25.8,f2.getIJ(i,0),13);
+ pass
+ #
+ array=DataArrayDouble.New();
+ arr2=[1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5, 1.2,2.3,3.4,4.5]
+ array.setValues(arr2,mesh1.getNumberOfCells(),4);
+ f1.setArray(array);
+ f1.checkCoherency();
+ #
+ f2=f1.trace();
+ f2.checkCoherency();
+ self.assertEqual(1,f2.getNumberOfComponents());
+ self.assertEqual(5,f2.getNumberOfTuples());
+ for i in xrange(5):
+ self.assertAlmostEqual(5.7,f2.getIJ(i,0),13);
+ pass
+ #
+ pass
+
+ def testDeviator1(self):
+ mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
+ f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
+ f1.setMesh(mesh1);
+ array=DataArrayDouble.New();
+ arr1=[1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7, 1.2,2.3,3.4,4.5,5.6,6.7]
+ array.setValues(arr1,mesh1.getNumberOfCells(),6);
+ f1.setArray(array);
+ f1.checkCoherency();
+ #
+ f2=f1.deviator();
+ f2.checkCoherency();
+ self.assertEqual(6,f2.getNumberOfComponents());
+ self.assertEqual(5,f2.getNumberOfTuples());
+ expected1=[-1.1,0.,1.1,4.5,5.6,6.7]
+ for i in xrange(5):
+ self.assertAlmostEqual(expected1[0],f2.getIJ(i,0),13);
+ self.assertAlmostEqual(expected1[1],f2.getIJ(i,1),13);
+ self.assertAlmostEqual(expected1[2],f2.getIJ(i,2),13);
+ self.assertAlmostEqual(expected1[3],f2.getIJ(i,3),13);
+ self.assertAlmostEqual(expected1[4],f2.getIJ(i,4),13);
+ self.assertAlmostEqual(expected1[5],f2.getIJ(i,5),13);
+ pass
+ #
+ pass
+
+ def testMagnitude1(self):
+ mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
+ f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
+ f1.setMesh(mesh1);
+ array=DataArrayDouble.New();
+ arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6, 1.2,2.3,3.4,4.5,5.6]
+ array.setValues(arr1,mesh1.getNumberOfCells(),5);
+ f1.setArray(array);
+ f1.checkCoherency();
+ #
+ f2=f1.magnitude();
+ f2.checkCoherency();
+ self.assertEqual(1,f2.getNumberOfComponents());
+ self.assertEqual(5,f2.getNumberOfTuples());
+ for i in xrange(5):
+ self.assertAlmostEqual(8.3606219864313918,f2.getIJ(i,0),13);
+ pass
+ #
+ pass
+
+ def testMaxPerTuple1(self):
+ mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
+ f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
+ f1.setMesh(mesh1);
+ array=DataArrayDouble.New();
+ arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4]
+ array.setValues(arr1,mesh1.getNumberOfCells(),5);
+ f1.setArray(array);
+ f1.checkCoherency();
+ #
+ f2=f1.maxPerTuple();
+ f2.checkCoherency();
+ self.assertEqual(1,f2.getNumberOfComponents());
+ self.assertEqual(5,f2.getNumberOfTuples());
+ for i in xrange(5):
+ self.assertAlmostEqual(5.6,f2.getIJ(i,0),13);
+ pass
+ #
+ pass
+
+ def testChangeNbOfComponents(self):
+ mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
+ f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
+ f1.setMesh(mesh1);
+ array=DataArrayDouble.New();
+ arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4]
+ array.setValues(arr1,mesh1.getNumberOfCells(),5);
+ f1.setArray(array);
+ f1.checkCoherency();
+ #
+ f1.changeNbOfComponents(3,7.77);
+ f1.checkCoherency();
+ self.assertEqual(3,f1.getNumberOfComponents());
+ self.assertEqual(5,f1.getNumberOfTuples());
+ expected1=[1.2,2.3,3.4, 1.2,3.4,4.5, 3.4,4.5,5.6, 5.6,1.2,2.3, 4.5,5.6,1.2]
+ for i in xrange(15):
+ self.assertAlmostEqual(expected1[i],f1.getIJ(0,i),13);
+ pass
+ f1.changeNbOfComponents(4,7.77);
+ f1.checkCoherency();
+ self.assertEqual(4,f1.getNumberOfComponents());
+ self.assertEqual(5,f1.getNumberOfTuples());
+ expected2=[1.2,2.3,3.4,7.77, 1.2,3.4,4.5,7.77, 3.4,4.5,5.6,7.77, 5.6,1.2,2.3,7.77, 4.5,5.6,1.2,7.77]
+ for i in xrange(20):
+ self.assertAlmostEqual(expected2[i],f1.getIJ(0,i),13);
+ pass
+ #
+ pass
+
+ def testSortPerTuple1(self):
+ mesh1=MEDCouplingDataForTest.build2DTargetMesh_1();
+ f1=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME);
+ f1.setMesh(mesh1);
+ array=DataArrayDouble.New();
+ arr1=[1.2,2.3,3.4,4.5,5.6, 1.2,3.4,4.5,5.6,2.3, 3.4,4.5,5.6,1.2,2.3, 5.6,1.2,2.3,3.4,4.5, 4.5,5.6,1.2,2.3,3.4]
+ array.setValues(arr1,mesh1.getNumberOfCells(),5);
+ f1.setArray(array);
+ f1.checkCoherency();
+ #
+ f1.sortPerTuple(True);
+ f1.checkCoherency();
+ self.assertEqual(5,f1.getNumberOfComponents());
+ self.assertEqual(5,f1.getNumberOfTuples());
+ for i in xrange(5):
+ self.assertAlmostEqual(arr1[0],f1.getIJ(i,0),13);
+ self.assertAlmostEqual(arr1[1],f1.getIJ(i,1),13);
+ self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
+ self.assertAlmostEqual(arr1[3],f1.getIJ(i,3),13);
+ self.assertAlmostEqual(arr1[4],f1.getIJ(i,4),13);
+ pass
+ #
+ f1.sortPerTuple(False);
+ f1.checkCoherency();
+ self.assertEqual(5,f1.getNumberOfComponents());
+ self.assertEqual(5,f1.getNumberOfTuples());
+ for i in xrange(5):
+ self.assertAlmostEqual(arr1[4],f1.getIJ(i,0),13);
+ self.assertAlmostEqual(arr1[3],f1.getIJ(i,1),13);
+ self.assertAlmostEqual(arr1[2],f1.getIJ(i,2),13);
+ self.assertAlmostEqual(arr1[1],f1.getIJ(i,3),13);
+ self.assertAlmostEqual(arr1[0],f1.getIJ(i,4),13);
+ pass
+ #
+ pass
def setUp(self):
pass
%newobject ParaMEDMEM::MEDCouplingField::buildWeightingField;
%newobject ParaMEDMEM::MEDCouplingFieldDouble::New;
%newobject ParaMEDMEM::MEDCouplingFieldDouble::mergeFields;
+%newobject ParaMEDMEM::MEDCouplingFieldDouble::doublyContractedProduct;
+%newobject ParaMEDMEM::MEDCouplingFieldDouble::determinant;
+%newobject ParaMEDMEM::MEDCouplingFieldDouble::eigenValues;
+%newobject ParaMEDMEM::MEDCouplingFieldDouble::eigenVectors;
+%newobject ParaMEDMEM::MEDCouplingFieldDouble::inverse;
+%newobject ParaMEDMEM::MEDCouplingFieldDouble::trace;
+%newobject ParaMEDMEM::MEDCouplingFieldDouble::deviator;
+%newobject ParaMEDMEM::MEDCouplingFieldDouble::magnitude;
+%newobject ParaMEDMEM::MEDCouplingFieldDouble::maxPerTuple;
%newobject ParaMEDMEM::MEDCouplingFieldDouble::dotFields;
%newobject ParaMEDMEM::MEDCouplingFieldDouble::dot;
%newobject ParaMEDMEM::MEDCouplingFieldDouble::crossProductFields;
%newobject ParaMEDMEM::DataArrayInt::deepCopy;
%newobject ParaMEDMEM::DataArrayInt::performCpy;
%newobject ParaMEDMEM::DataArrayInt::substr;
+%newobject ParaMEDMEM::DataArrayInt::changeNbOfComponents;
%newobject ParaMEDMEM::DataArrayInt::selectByTupleId;
%newobject ParaMEDMEM::DataArrayDouble::aggregate;
%newobject ParaMEDMEM::DataArrayDouble::dot;
%newobject ParaMEDMEM::DataArrayDouble::multiply;
%newobject ParaMEDMEM::DataArrayDouble::divide;
%newobject ParaMEDMEM::DataArrayDouble::substr;
+%newobject ParaMEDMEM::DataArrayDouble::changeNbOfComponents;
%newobject ParaMEDMEM::DataArrayDouble::getIdsInRange;
%newobject ParaMEDMEM::DataArrayDouble::selectByTupleId;
%newobject ParaMEDMEM::DataArrayDouble::applyFunc;
+%newobject ParaMEDMEM::DataArrayDouble::doublyContractedProduct;
+%newobject ParaMEDMEM::DataArrayDouble::determinant;
+%newobject ParaMEDMEM::DataArrayDouble::eigenValues;
+%newobject ParaMEDMEM::DataArrayDouble::eigenVectors;
+%newobject ParaMEDMEM::DataArrayDouble::inverse;
+%newobject ParaMEDMEM::DataArrayDouble::trace;
+%newobject ParaMEDMEM::DataArrayDouble::deviator;
+%newobject ParaMEDMEM::DataArrayDouble::magnitude;
+%newobject ParaMEDMEM::DataArrayDouble::maxPerTuple;
%newobject ParaMEDMEM::MEDCouplingFieldDouble::clone;
%newobject ParaMEDMEM::MEDCouplingFieldDouble::cloneWithMesh;
%newobject ParaMEDMEM::MEDCouplingFieldDouble::buildNewTimeReprFromThis;
class DataArrayDouble;
class MEDCouplingFieldDouble;
- class MEDCOUPLING_EXPORT MEDCouplingMesh : public RefCountObject, public TimeLabel
+ class MEDCouplingMesh : public RefCountObject, public TimeLabel
{
public:
void setName(const char *name) { _name=name; }
static MEDCouplingMesh *mergeMeshes(const MEDCouplingMesh *mesh1, const MEDCouplingMesh *mesh2);
%extend
{
+ std::string __str__() const
+ {
+ return self->simpleRepr();
+ }
+
void renumberCells(PyObject *li, bool check) throw(INTERP_KERNEL::Exception)
{
int size;
double getCaracteristicDimension() const;
void translate(const double *vector);
void scale(const double *point, double factor);
- void changeSpaceDimension(int newSpaceDim) throw(INTERP_KERNEL::Exception);
+ void changeSpaceDimension(int newSpaceDim, double dftVal=0.) throw(INTERP_KERNEL::Exception);
void tryToShareSameCoords(const MEDCouplingPointSet& other, double epsilon) throw(INTERP_KERNEL::Exception);
virtual void tryToShareSameCoordsPermute(const MEDCouplingPointSet& other, double epsilon) throw(INTERP_KERNEL::Exception) = 0;
static DataArrayDouble *mergeNodesArray(const MEDCouplingPointSet *m1, const MEDCouplingPointSet *m2);
virtual DataArrayInt *zipCoordsTraducer() = 0;
%extend
{
+ std::string __str__() const
+ {
+ return self->simpleRepr();
+ }
+
PyObject *buildNewNumberingFromCommNodesFrmt(const DataArrayInt *comm, const DataArrayInt *commIndex) const
{
int newNbOfNodes;
bool isPresenceOfQuadratic() const;
void convertQuadraticCellsToLinear() throw(INTERP_KERNEL::Exception);
%extend {
+ std::string __str__() const
+ {
+ return self->simpleRepr();
+ }
+
int getCellContainingPoint(PyObject *p, double eps) const
{
int sz;
static MEDCouplingExtrudedMesh *New(const MEDCouplingUMesh *mesh3D, MEDCouplingUMesh *mesh2D, int cell2DId) throw(INTERP_KERNEL::Exception);
MEDCouplingUMesh *build3DUnstructuredMesh() const;
%extend {
+ std::string __str__() const
+ {
+ return self->simpleRepr();
+ }
PyObject *getMesh2D() const
{
MEDCouplingUMesh *ret=self->getMesh2D();
DataArrayDouble *coordsY=0,
DataArrayDouble *coordsZ=0);
void setCoordsAt(int i, DataArrayDouble *arr) throw(INTERP_KERNEL::Exception);
+ %extend {
+ std::string __str__() const
+ {
+ return self->simpleRepr();
+ }
+ }
};
}
%extend ParaMEDMEM::DataArrayDouble
{
+ std::string __str__() const
+ {
+ return self->repr();
+ }
+
void setValues(PyObject *li, int nbOfTuples, int nbOfElsPerTuple)
{
int sz;
%extend ParaMEDMEM::DataArrayInt
{
+ std::string __str__() const
+ {
+ return self->repr();
+ }
+
void setValues(PyObject *li, int nbOfTuples, int nbOfElsPerTuple)
{
int size;
double getIJK(int cellId, int nodeIdInCell, int compoId) const;
void setArray(DataArrayDouble *array) throw(INTERP_KERNEL::Exception);
void setEndArray(DataArrayDouble *array) throw(INTERP_KERNEL::Exception);
- void setTime(double val, int dt, int it) throw(INTERP_KERNEL::Exception);
- void setStartTime(double val, int dt, int it) throw(INTERP_KERNEL::Exception);
- void setEndTime(double val, int dt, int it) throw(INTERP_KERNEL::Exception);
+ void setTime(double val, int iteration, int order) throw(INTERP_KERNEL::Exception);
+ void setStartTime(double val, int iteration, int order) throw(INTERP_KERNEL::Exception);
+ void setEndTime(double val, int iteration, int order) throw(INTERP_KERNEL::Exception);
DataArrayDouble *getArray() const throw(INTERP_KERNEL::Exception);
DataArrayDouble *getEndArray() const throw(INTERP_KERNEL::Exception);
void applyLin(double a, double b, int compoId) throw(INTERP_KERNEL::Exception);
void changeUnderlyingMesh(const MEDCouplingMesh *other, int levOfCheck, double prec) throw(INTERP_KERNEL::Exception);
void substractInPlaceDM(const MEDCouplingFieldDouble *f, int levOfCheck, double prec) throw(INTERP_KERNEL::Exception);
bool mergeNodes(double eps) throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *doublyContractedProduct() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *determinant() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *eigenValues() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *eigenVectors() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *inverse() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *trace() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *deviator() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *magnitude() const throw(INTERP_KERNEL::Exception);
+ MEDCouplingFieldDouble *maxPerTuple() const throw(INTERP_KERNEL::Exception);
+ void changeNbOfComponents(int newNbOfComp, double dftValue=0.) throw(INTERP_KERNEL::Exception);
+ void sortPerTuple(bool asc) throw(INTERP_KERNEL::Exception);
void applyFunc(int nbOfComp, const char *func) throw(INTERP_KERNEL::Exception);
void applyFunc(const char *func) throw(INTERP_KERNEL::Exception);
void applyFuncFast32(const char *func) throw(INTERP_KERNEL::Exception);
MEDCouplingFieldDouble *operator/(const MEDCouplingFieldDouble& other) const throw(INTERP_KERNEL::Exception);
const MEDCouplingFieldDouble &operator/=(const MEDCouplingFieldDouble& other) throw(INTERP_KERNEL::Exception);
%extend {
+ std::string __str__() const
+ {
+ return self->simpleRepr();
+ }
PyObject *getValueOn(PyObject *sl) const throw(INTERP_KERNEL::Exception)
{
int sz;
