From: ageay <ageay>
Date: Mon, 4 Oct 2010 14:52:42 +0000 (+0000)
Subject: Addition of several functionalities in fields.
X-Git-Tag: V5_1_main_FINAL~10
X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=refs%2Fheads%2FBR_medop;p=tools%2Fmedcoupling.git

Addition of several functionalities in fields.
---

diff --git a/src/MEDCoupling/MEDCouplingAutoRefCountObjectPtr.hxx b/src/MEDCoupling/MEDCouplingAutoRefCountObjectPtr.hxx
index 7dd470af8..1d65fd240 100644
--- a/src/MEDCoupling/MEDCouplingAutoRefCountObjectPtr.hxx
+++ b/src/MEDCoupling/MEDCouplingAutoRefCountObjectPtr.hxx
@@ -29,7 +29,7 @@ namespace ParaMEDMEM
   {
   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; }
diff --git a/src/MEDCoupling/MEDCouplingField.cxx b/src/MEDCoupling/MEDCouplingField.cxx
index 8982d4760..abcd4d22a 100644
--- a/src/MEDCoupling/MEDCouplingField.cxx
+++ b/src/MEDCoupling/MEDCouplingField.cxx
@@ -231,6 +231,10 @@ MEDCouplingField::~MEDCouplingField()
   delete _type;
 }
 
+MEDCouplingField::MEDCouplingField(MEDCouplingFieldDiscretization *type):_mesh(0),_type(type)
+{
+}
+
 MEDCouplingField::MEDCouplingField(TypeOfField type):_mesh(0),_type(MEDCouplingFieldDiscretization::New(type))
 {
 }
diff --git a/src/MEDCoupling/MEDCouplingField.hxx b/src/MEDCoupling/MEDCouplingField.hxx
index 8287acecd..e36951121 100644
--- a/src/MEDCoupling/MEDCouplingField.hxx
+++ b/src/MEDCoupling/MEDCouplingField.hxx
@@ -71,6 +71,7 @@ namespace ParaMEDMEM
   protected:
     MEDCouplingField(TypeOfField type);
     MEDCouplingField(const MEDCouplingField& other);
+    MEDCouplingField(MEDCouplingFieldDiscretization *type);
     virtual ~MEDCouplingField();
   protected:
     std::string _name;
diff --git a/src/MEDCoupling/MEDCouplingFieldDouble.cxx b/src/MEDCoupling/MEDCouplingFieldDouble.cxx
index e7f431fdf..10c8758f4 100644
--- a/src/MEDCoupling/MEDCouplingFieldDouble.cxx
+++ b/src/MEDCoupling/MEDCouplingFieldDouble.cxx
@@ -55,7 +55,7 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::cloneWithMesh(bool recDeepCpy) c
 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());
@@ -328,8 +328,8 @@ MEDCouplingFieldDouble::MEDCouplingFieldDouble(const MEDCouplingFieldDouble& oth
 {
 }
 
-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)
 {
 }
 
@@ -878,6 +878,108 @@ bool MEDCouplingFieldDouble::mergeNodes(double eps) throw(INTERP_KERNEL::Excepti
   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))
@@ -886,7 +988,7 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::mergeFields(const MEDCouplingFie
   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());
@@ -900,7 +1002,7 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::dotFields(const MEDCouplingField
     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;
 }
@@ -911,7 +1013,7 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::crossProductFields(const MEDCoup
     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;
 }
@@ -922,7 +1024,7 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::maxFields(const MEDCouplingField
     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;
 }
@@ -933,7 +1035,7 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::minFields(const MEDCouplingField
     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;
 }
@@ -944,7 +1046,7 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::addFields(const MEDCouplingField
     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;
 }
@@ -963,7 +1065,7 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::substractFields(const MEDCouplin
     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;
 }
@@ -982,7 +1084,7 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::multiplyFields(const MEDCoupling
     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;
 }
@@ -1001,7 +1103,7 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::divideFields(const MEDCouplingFi
     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;
 }
diff --git a/src/MEDCoupling/MEDCouplingFieldDouble.hxx b/src/MEDCoupling/MEDCouplingFieldDouble.hxx
index d29f8c6ca..18d6d6ae8 100644
--- a/src/MEDCoupling/MEDCouplingFieldDouble.hxx
+++ b/src/MEDCoupling/MEDCouplingFieldDouble.hxx
@@ -53,12 +53,12 @@ namespace ParaMEDMEM
     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);
@@ -102,6 +102,17 @@ namespace ParaMEDMEM
     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); }
@@ -126,7 +137,7 @@ namespace ParaMEDMEM
   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;
diff --git a/src/MEDCoupling/MEDCouplingMemArray.cxx b/src/MEDCoupling/MEDCouplingMemArray.cxx
index 65d3d9ee3..67923bc7e 100644
--- a/src/MEDCoupling/MEDCouplingMemArray.cxx
+++ b/src/MEDCoupling/MEDCouplingMemArray.cxx
@@ -19,9 +19,11 @@
 
 #include "MEDCouplingMemArray.txx"
 
+#include "GenMathFormulae.hxx"
 #include "InterpKernelExprParser.hxx"
 
 #include <set>
+#include <cmath>
 #include <numeric>
 #include <functional>
 
@@ -223,6 +225,35 @@ DataArrayDouble *DataArrayDouble::substr(int tupleIdBg, int tupleIdEnd) const th
   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.
  */
@@ -330,6 +361,220 @@ double DataArrayDouble::accumulate(int compId) const
   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;
@@ -937,6 +1182,36 @@ DataArrayInt *DataArrayInt::substr(int tupleIdBg, int tupleIdEnd) const throw(IN
   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.
  */
diff --git a/src/MEDCoupling/MEDCouplingMemArray.hxx b/src/MEDCoupling/MEDCouplingMemArray.hxx
index 9e71e2db5..d3b57c927 100644
--- a/src/MEDCoupling/MEDCouplingMemArray.hxx
+++ b/src/MEDCoupling/MEDCouplingMemArray.hxx
@@ -128,6 +128,7 @@ namespace ParaMEDMEM
     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]; }
@@ -143,6 +144,16 @@ namespace ParaMEDMEM
     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);
@@ -195,6 +206,7 @@ namespace ParaMEDMEM
     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]; }
diff --git a/src/MEDCoupling/MEDCouplingPointSet.cxx b/src/MEDCoupling/MEDCouplingPointSet.cxx
index 709ae8ce2..e0dec42a8 100644
--- a/src/MEDCoupling/MEDCouplingPointSet.cxx
+++ b/src/MEDCoupling/MEDCouplingPointSet.cxx
@@ -388,7 +388,7 @@ void MEDCouplingPointSet::scale(const double *point, double factor)
  * - 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 !");
@@ -397,23 +397,7 @@ void MEDCouplingPointSet::changeSpaceDimension(int newSpaceDim) throw(INTERP_KER
   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();
diff --git a/src/MEDCoupling/MEDCouplingPointSet.hxx b/src/MEDCoupling/MEDCouplingPointSet.hxx
index 21f56317e..53aa5ea40 100644
--- a/src/MEDCoupling/MEDCouplingPointSet.hxx
+++ b/src/MEDCoupling/MEDCouplingPointSet.hxx
@@ -62,7 +62,7 @@ namespace ParaMEDMEM
     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);
diff --git a/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx b/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx
index aa2f1ed9c..734f46aa1 100644
--- a/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx
+++ b/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx
@@ -19,6 +19,7 @@
 
 #include "MEDCouplingTimeDiscretization.hxx"
 #include "MEDCouplingMemArray.hxx"
+#include "MEDCouplingAutoRefCountObjectPtr.hxx"
 
 #include <cmath>
 #include <iterator>
@@ -259,20 +260,229 @@ void MEDCouplingTimeDiscretization::getArrays(std::vector<DataArrayDouble *>& ar
 
 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;
@@ -578,22 +788,22 @@ bool MEDCouplingNoTimeLabel::isStrictlyBefore(const MEDCouplingTimeDiscretizatio
   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);
 }
@@ -603,32 +813,32 @@ void MEDCouplingNoTimeLabel::getValueOnTime(int eltId, double time, double *valu
   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
@@ -641,8 +851,8 @@ void MEDCouplingWithTimeStep::finishUnserialization(const std::vector<int>& tiny
 {
   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
@@ -674,9 +884,9 @@ bool MEDCouplingWithTimeStep::isEqual(const MEDCouplingTimeDiscretization *other
   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;
@@ -688,8 +898,8 @@ void MEDCouplingWithTimeStep::copyTinyAttrFrom(const MEDCouplingTimeDiscretizati
   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
@@ -896,9 +1106,9 @@ void MEDCouplingWithTimeStep::getValueOnTime(int eltId, double time, double *val
     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
@@ -907,7 +1117,7 @@ void MEDCouplingWithTimeStep::getValueOnDiscTime(int eltId, int dt, int it, doub
     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)
 {
 }
 
@@ -917,19 +1127,19 @@ void MEDCouplingConstOnTimeInterval::copyTinyAttrFrom(const MEDCouplingTimeDiscr
   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
@@ -944,23 +1154,23 @@ void MEDCouplingConstOnTimeInterval::finishUnserialization(const std::vector<int
   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();
 }
 
@@ -1015,15 +1225,15 @@ bool MEDCouplingConstOnTimeInterval::isEqual(const MEDCouplingTimeDiscretization
   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;
@@ -1041,9 +1251,9 @@ void MEDCouplingConstOnTimeInterval::getValueOnTime(int eltId, double time, doub
     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
@@ -1062,7 +1272,7 @@ void MEDCouplingConstOnTimeInterval::checkTimePresence(double time) const throw(
   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());
     }
@@ -1236,8 +1446,8 @@ void MEDCouplingConstOnTimeInterval::divideEqual(const MEDCouplingTimeDiscretiza
 
 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);
@@ -1258,10 +1468,10 @@ void MEDCouplingTwoTimeSteps::copyTinyAttrFrom(const MEDCouplingTimeDiscretizati
   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)
@@ -1295,13 +1505,13 @@ bool MEDCouplingTwoTimeSteps::isEqual(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;
@@ -1313,7 +1523,7 @@ bool MEDCouplingTwoTimeSteps::isEqual(const MEDCouplingTimeDiscretization *other
   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)
 {
 }
 
@@ -1333,7 +1543,7 @@ void MEDCouplingTwoTimeSteps::checkTimePresence(double time) const throw(INTERP_
   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());
     }
@@ -1363,10 +1573,10 @@ void MEDCouplingTwoTimeSteps::setEndArray(DataArrayDouble *array, TimeLabel *own
 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());
@@ -1425,10 +1635,10 @@ void MEDCouplingTwoTimeSteps::finishUnserialization(const std::vector<int>& tiny
   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)
@@ -1449,7 +1659,7 @@ void MEDCouplingTwoTimeSteps::setArrays(const std::vector<DataArrayDouble *>& ar
   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)
@@ -1463,8 +1673,8 @@ MEDCouplingLinearTime::MEDCouplingLinearTime()
 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();
 }
 
@@ -1536,21 +1746,21 @@ void MEDCouplingLinearTime::getValueOnTime(int eltId, double time, double *value
   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);
diff --git a/src/MEDCoupling/MEDCouplingTimeDiscretization.hxx b/src/MEDCoupling/MEDCouplingTimeDiscretization.hxx
index 7c15d06d2..d128ec7a5 100644
--- a/src/MEDCoupling/MEDCouplingTimeDiscretization.hxx
+++ b/src/MEDCoupling/MEDCouplingTimeDiscretization.hxx
@@ -84,21 +84,33 @@ namespace ParaMEDMEM
     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:
@@ -139,12 +151,12 @@ namespace ParaMEDMEM
     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[];
@@ -184,14 +196,14 @@ namespace ParaMEDMEM
     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[];
@@ -199,8 +211,8 @@ namespace ParaMEDMEM
     static const char EXCEPTION_MSG[];
   protected:
     double _time;
-    int _dt;
-    int _it;
+    int _iteration;
+    int _order;
   };
 
   class MEDCOUPLING_EXPORT MEDCouplingConstOnTimeInterval : public MEDCouplingTimeDiscretization
@@ -221,7 +233,7 @@ namespace ParaMEDMEM
     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;
@@ -237,10 +249,10 @@ namespace ParaMEDMEM
     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:
@@ -251,10 +263,10 @@ namespace ParaMEDMEM
   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
@@ -274,10 +286,10 @@ namespace ParaMEDMEM
     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;
@@ -290,10 +302,10 @@ namespace ParaMEDMEM
   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;
   };
 
@@ -312,7 +324,7 @@ namespace ParaMEDMEM
     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;
diff --git a/src/MEDCoupling/Test/MEDCouplingBasicsTest.hxx b/src/MEDCoupling/Test/MEDCouplingBasicsTest.hxx
index 23deef32e..71651417b 100644
--- a/src/MEDCoupling/Test/MEDCouplingBasicsTest.hxx
+++ b/src/MEDCoupling/Test/MEDCouplingBasicsTest.hxx
@@ -111,6 +111,17 @@ namespace ParaMEDMEM
     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 );
@@ -250,6 +261,17 @@ namespace ParaMEDMEM
     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();
diff --git a/src/MEDCoupling/Test/MEDCouplingBasicsTest2.cxx b/src/MEDCoupling/Test/MEDCouplingBasicsTest2.cxx
index eca5b836e..af5ec9aa4 100644
--- a/src/MEDCoupling/Test/MEDCouplingBasicsTest2.cxx
+++ b/src/MEDCoupling/Test/MEDCouplingBasicsTest2.cxx
@@ -1395,3 +1395,493 @@ void MEDCouplingBasicsTest::testBuildSubPart1()
   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();
+}
diff --git a/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py b/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py
index a764cbfcb..6b058c1ac 100644
--- a/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py
+++ b/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py
@@ -2888,6 +2888,413 @@ class MEDCouplingBasicsTest(unittest.TestCase):
         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
diff --git a/src/MEDCoupling_Swig/libMEDCoupling_Swig.i b/src/MEDCoupling_Swig/libMEDCoupling_Swig.i
index 5226abd7e..dd638bb81 100644
--- a/src/MEDCoupling_Swig/libMEDCoupling_Swig.i
+++ b/src/MEDCoupling_Swig/libMEDCoupling_Swig.i
@@ -60,6 +60,15 @@ using namespace INTERP_KERNEL;
 %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;
@@ -80,6 +89,7 @@ using namespace INTERP_KERNEL;
 %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;
@@ -89,9 +99,19 @@ using namespace INTERP_KERNEL;
 %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;
@@ -164,7 +184,7 @@ namespace ParaMEDMEM
   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; }
@@ -200,6 +220,11 @@ namespace ParaMEDMEM
     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;
@@ -242,7 +267,7 @@ namespace ParaMEDMEM
       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);
@@ -264,6 +289,11 @@ namespace ParaMEDMEM
       virtual DataArrayInt *zipCoordsTraducer() = 0;
       %extend 
          {
+           std::string __str__() const
+           {
+             return self->simpleRepr();
+           }
+           
            PyObject *buildNewNumberingFromCommNodesFrmt(const DataArrayInt *comm, const DataArrayInt *commIndex) const
            {
              int newNbOfNodes;
@@ -421,6 +451,11 @@ namespace ParaMEDMEM
     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;
@@ -616,6 +651,10 @@ namespace ParaMEDMEM
     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();
@@ -645,11 +684,22 @@ namespace ParaMEDMEM
                    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;
@@ -666,6 +716,11 @@ namespace ParaMEDMEM
 
 %extend ParaMEDMEM::DataArrayInt
  {
+   std::string __str__() const
+   {
+     return self->repr();
+   }
+
    void setValues(PyObject *li, int nbOfTuples, int nbOfElsPerTuple)
    {
      int size;
@@ -780,9 +835,9 @@ namespace ParaMEDMEM
     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);
@@ -795,6 +850,17 @@ namespace ParaMEDMEM
     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);
@@ -827,6 +893,10 @@ namespace ParaMEDMEM
     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;