From: ageay Date: Thu, 20 Jan 2011 09:31:14 +0000 (+0000) Subject: *** empty log message *** X-Git-Tag: V6_main_FINAL~1104 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=77fce568551c1da23a1654b22fad0ca7c9df0a95;p=tools%2Fmedcoupling.git *** empty log message *** --- diff --git a/src/MEDCoupling/MEDCouplingAutoRefCountObjectPtr.hxx b/src/MEDCoupling/MEDCouplingAutoRefCountObjectPtr.hxx index 9a30b7d8f..61bbdc3da 100644 --- a/src/MEDCoupling/MEDCouplingAutoRefCountObjectPtr.hxx +++ b/src/MEDCoupling/MEDCouplingAutoRefCountObjectPtr.hxx @@ -31,6 +31,7 @@ namespace ParaMEDMEM MEDCouplingAutoRefCountObjectPtr(const MEDCouplingAutoRefCountObjectPtr& other):_ptr(0) { referPtr(other._ptr); } MEDCouplingAutoRefCountObjectPtr(T *ptr=0):_ptr(ptr) { } ~MEDCouplingAutoRefCountObjectPtr() { destroyPtr(); } + bool operator==(const MEDCouplingAutoRefCountObjectPtr& other) { return _ptr==other._ptr; } MEDCouplingAutoRefCountObjectPtr &operator=(const MEDCouplingAutoRefCountObjectPtr& other) { if(_ptr!=other._ptr) { destroyPtr(); referPtr(other._ptr); } return *this; } MEDCouplingAutoRefCountObjectPtr &operator=(T *ptr) { if(_ptr!=ptr) { destroyPtr(); _ptr=ptr; } return *this; } T *operator->() { return _ptr ; } diff --git a/src/MEDCoupling/MEDCouplingCMesh.cxx b/src/MEDCoupling/MEDCouplingCMesh.cxx index 17c5dfaf4..3c8ce1a41 100644 --- a/src/MEDCoupling/MEDCouplingCMesh.cxx +++ b/src/MEDCoupling/MEDCouplingCMesh.cxx @@ -361,6 +361,7 @@ std::string MEDCouplingCMesh::simpleRepr() const { std::ostringstream ret; ret << "Cartesian mesh with name : \"" << getName() << "\"\n"; + ret << "Description of mesh : \"" << getDescription() << "\"\n"; ret << "Mesh and SpaceDimension dimension : " << getSpaceDimension() << "\n\nArrays :\n________\n\n"; if(_x_array) { diff --git a/src/MEDCoupling/MEDCouplingDefinitionTime.cxx b/src/MEDCoupling/MEDCouplingDefinitionTime.cxx new file mode 100644 index 000000000..95eaf6f3d --- /dev/null +++ b/src/MEDCoupling/MEDCouplingDefinitionTime.cxx @@ -0,0 +1,298 @@ +// Copyright (C) 2007-2010 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#include "MEDCouplingDefinitionTime.hxx" +#include "MEDCouplingFieldDouble.hxx" + +#include + +using namespace ParaMEDMEM; + +MEDCouplingDefinitionTimeSlice *MEDCouplingDefinitionTimeSlice::New(const MEDCouplingFieldDouble *f, int meshId, const std::vector& arrId, int fieldId) throw(INTERP_KERNEL::Exception) +{ + static const char msg[]="TimeSlice::New : mismatch of arrays number of a fieldDouble and its policy !!! Internal error !!!"; + if(!f) + throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTimeSlice::New : empty field !"); + switch(f->getTimeDiscretization()) + { + case ONE_TIME: + { + if(arrId.size()!=1) + throw INTERP_KERNEL::Exception(msg); + return new MEDCouplingDefinitionTimeSliceInst(f,meshId,arrId[0],fieldId); + } + case CONST_ON_TIME_INTERVAL: + { + if(arrId.size()!=1) + throw INTERP_KERNEL::Exception(msg); + return new MEDCouplingDefinitionTimeSliceCstOnTI(f,meshId,arrId[0],fieldId); + } + case LINEAR_TIME: + { + if(arrId.size()!=2) + throw INTERP_KERNEL::Exception(msg); + return new MEDCouplingDefinitionTimeSliceLT(f,meshId,arrId[0],arrId[1],fieldId); + } + case NO_TIME: + throw INTERP_KERNEL::Exception("Invalide time discretization ! NO_TIME ! Impossible to build a definition time slice !"); + default: + throw INTERP_KERNEL::Exception("Invalide time discretization : Not recognized !"); + } +} + +int MEDCouplingDefinitionTimeSlice::getStartId() const +{ + return _array_id; +} + +int MEDCouplingDefinitionTimeSlice::getEndId() const +{ + return _array_id; +} + +void MEDCouplingDefinitionTimeSlice::appendRepr(std::ostream& stream) const +{ + stream << " *** MeshId : " << _mesh_id << " ArrayId : " << _array_id; +} + +MEDCouplingDefinitionTimeSlice::MEDCouplingDefinitionTimeSlice(const MEDCouplingFieldDouble *f, int meshId, int arrId, int fieldId) throw(INTERP_KERNEL::Exception):_mesh_id(meshId),_array_id(arrId),_field_id(fieldId) +{ + int tmp1,tmp2; + double t1=f->getStartTime(tmp1,tmp2); + double t2=f->getEndTime(tmp1,tmp2); + if(t2getStartTime(); + double o2=other->getEndTime(); + return o1>t1-eps && o2getStartTime(); + double o2=other->getEndTime(); + return (o1t2-eps && o2>t2-eps); +} + +bool MEDCouplingDefinitionTimeSlice::isAfterMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const +{ + double t2=getEndTime(); + double o1=other->getStartTime(); + double o2=other->getEndTime(); + return (o1>t2-eps && o2>t2-eps); +} + +bool MEDCouplingDefinitionTimeSlice::isBeforeMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const +{ + double t1=getStartTime(); + double o1=other->getStartTime(); + double o2=other->getEndTime(); + return (o1getStartTime(tmp1,tmp2); + double t2=f->getEndTime(tmp1,tmp2); + double eps=f->getTimeTolerance(); + if(fabs(t1-t2)>eps) + throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTimeSliceInst : times differs in this"); + _instant=t1; +} + +bool MEDCouplingDefinitionTimeSliceCstOnTI::isContaining(double tmp, double eps) const +{ + return _start-eps>tmp && _end+epsgetStartTime(tmp1,tmp2); + double t2=f->getEndTime(tmp1,tmp2); + _start=t1; + _end=t2; +} + +bool MEDCouplingDefinitionTimeSliceLT::isContaining(double tmp, double eps) const +{ + return _start-eps>tmp && _end+epsgetStartTime(tmp1,tmp2); + double t2=f->getEndTime(tmp1,tmp2); + _start=t1; + _end=t2; +} + +MEDCouplingDefinitionTime::MEDCouplingDefinitionTime() +{ +} + +MEDCouplingDefinitionTime::MEDCouplingDefinitionTime(const std::vector& fs, const std::vector& meshRefs, const std::vector >& arrRefs) throw(INTERP_KERNEL::Exception) +{ + std::size_t sz=fs.size(); + if(sz!=arrRefs.size()) + throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime constructor : internal error ! should never happen !"); + _slices.resize(sz); + for(std::size_t i=0;igetTimeTolerance(); + for(std::size_t i=1;iisAfterMe(_slices[i],_eps)) + throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime constructors : the sequences of fields does NOT defines a stricly ascendant monotonic time sequence !"); + // double t1=ref->getEndTime(); + // double t2=_slices[i]->getStartTime(); + // if(fabs(t1-t2)<_eps) + // if(ref->getEndId() != _slices[i]->getStartId()) + // throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime constructor : 2 slices refers to the same time and underlying arrays differs !"); + ref=_slices[i]; + } +} + +void MEDCouplingDefinitionTime::getIdsOnTimeRight(double tm, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const throw(INTERP_KERNEL::Exception) +{ + std::vector meshIds; + std::vector arrIds; + std::vector arrIdsInField; + std::vector fieldIds; + getIdsOnTime(tm,meshIds,arrIds,arrIdsInField,fieldIds); + meshId=meshIds.back(); + arrId=arrIds.back(); + arrIdInField=arrIdsInField.back(); + fieldId=fieldIds.back(); +} + +void MEDCouplingDefinitionTime::getIdsOnTimeLeft(double tm, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const throw(INTERP_KERNEL::Exception) +{ + std::vector meshIds; + std::vector arrIds; + std::vector arrIdsInField; + std::vector fieldIds; + getIdsOnTime(tm,meshIds,arrIds,arrIdsInField,fieldIds); + meshId=meshIds.front(); + arrId=arrIds.front(); + arrIdInField=arrIdsInField.front(); + fieldId=fieldIds.front(); +} + +void MEDCouplingDefinitionTime::getIdsOnTime(double tm, std::vector& meshIds, std::vector& arrIds, std::vector& arrIdsInField, std::vector& fieldIds) const throw(INTERP_KERNEL::Exception) +{ + std::vector ids; + int id=0; + for(std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_slices.begin();it!=_slices.end();it++,id++) + if((*it)->isContaining(tm,_eps)) + ids.push_back(id); + if(ids.empty()) + throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime::getIdsOnTime : No matching slice for such time !"); + int sz=ids.size(); + if(sz>2) + throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime::getIdsOnTime : Too many slices match this time !"); + //tony +} + +void MEDCouplingDefinitionTime::appendRepr(std::ostream& stream) const +{ + stream << "Time definition :\n"; + for(std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_slices.begin();it!=_slices.end();it++) + { + stream << " - "; + (*it)->appendRepr(stream); + stream << std::endl; + } +} diff --git a/src/MEDCoupling/MEDCouplingDefinitionTime.hxx b/src/MEDCoupling/MEDCouplingDefinitionTime.hxx new file mode 100644 index 000000000..490e428a5 --- /dev/null +++ b/src/MEDCoupling/MEDCouplingDefinitionTime.hxx @@ -0,0 +1,119 @@ +// Copyright (C) 2007-2010 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#ifndef __PARAMEDMEM_MEDCOUPLINGDEFINITIONTIME_HXX__ +#define __PARAMEDMEM_MEDCOUPLINGDEFINITIONTIME_HXX__ + +#include "MEDCouplingRefCountObject.hxx" +#include "MEDCouplingAutoRefCountObjectPtr.hxx" + +#include "InterpKernelException.hxx" + +#include +#include + +namespace ParaMEDMEM +{ + class MEDCouplingFieldDouble; + + class MEDCouplingDefinitionTimeSlice : public RefCountObject + { + public: + static MEDCouplingDefinitionTimeSlice *New(const MEDCouplingFieldDouble *f, int meshId, const std::vector& arrId, int fieldId) throw(INTERP_KERNEL::Exception); + int getArrayId() const { return _array_id; } + virtual bool isContaining(double tmp, double eps) const = 0; + virtual int getStartId() const; + virtual int getEndId() const; + virtual void appendRepr(std::ostream& stream) const; + virtual double getStartTime() const = 0; + virtual double getEndTime() const = 0; + bool isFullyIncludedInMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const; + bool isOverllapingWithMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const; + bool isAfterMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const; + bool isBeforeMe(const MEDCouplingDefinitionTimeSlice *other, double eps) const; + protected: + MEDCouplingDefinitionTimeSlice(const MEDCouplingFieldDouble *f, int meshId, int arrId, int fieldId) throw(INTERP_KERNEL::Exception); + protected: + int _mesh_id; + int _array_id; + int _field_id; + }; + + class MEDCouplingDefinitionTimeSliceInst : public MEDCouplingDefinitionTimeSlice + { + public: + bool isContaining(double tmp, double eps) const; + void appendRepr(std::ostream& stream) const; + double getStartTime() const; + double getEndTime() const; + public: + MEDCouplingDefinitionTimeSliceInst(const MEDCouplingFieldDouble *f, int meshId, int arrId, int fieldId) throw(INTERP_KERNEL::Exception); + protected: + double _instant; + }; + + class MEDCouplingDefinitionTimeSliceCstOnTI : public MEDCouplingDefinitionTimeSlice + { + public: + bool isContaining(double tmp, double eps) const; + void appendRepr(std::ostream& stream) const; + double getStartTime() const; + double getEndTime() const; + public: + MEDCouplingDefinitionTimeSliceCstOnTI(const MEDCouplingFieldDouble *f, int meshId, int arrId, int fieldId) throw(INTERP_KERNEL::Exception); + protected: + double _start; + double _end; + }; + + + class MEDCouplingDefinitionTimeSliceLT : public MEDCouplingDefinitionTimeSlice + { + public: + bool isContaining(double tmp, double eps) const; + void appendRepr(std::ostream& stream) const; + double getStartTime() const; + double getEndTime() const; + int getEndId() const; + public: + MEDCouplingDefinitionTimeSliceLT(const MEDCouplingFieldDouble *f, int meshId, int arrId, int arr2Id, int fieldId) throw(INTERP_KERNEL::Exception); + protected: + int _array_id_end; + double _start; + double _end; + }; + + class MEDCouplingDefinitionTime + { + public: + MEDCouplingDefinitionTime(); + MEDCouplingDefinitionTime(const std::vector& fs, const std::vector& meshRefs, const std::vector >& arrRefs) throw(INTERP_KERNEL::Exception); + double getTimeResolution() const { return _eps; } + void getIdsOnTimeRight(double tm, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const throw(INTERP_KERNEL::Exception); + void getIdsOnTimeLeft(double tm, int& meshId, int& arrId, int& arrIdInField, int& fieldId) const throw(INTERP_KERNEL::Exception); + void appendRepr(std::ostream& stream) const; + private: + void getIdsOnTime(double tm, std::vector& meshIds, std::vector& arrIds, std::vector& arrIdsInField, std::vector& fieldIds) const throw(INTERP_KERNEL::Exception); + private: + double _eps; + std::vector< MEDCouplingAutoRefCountObjectPtr > _slices; + }; +} + +#endif diff --git a/src/MEDCoupling/MEDCouplingExtrudedMesh.cxx b/src/MEDCoupling/MEDCouplingExtrudedMesh.cxx index 0005977fd..c288087c1 100644 --- a/src/MEDCoupling/MEDCouplingExtrudedMesh.cxx +++ b/src/MEDCoupling/MEDCouplingExtrudedMesh.cxx @@ -257,6 +257,7 @@ std::string MEDCouplingExtrudedMesh::simpleRepr() const { std::ostringstream ret; ret << "3D Extruded mesh from a 2D Surf Mesh with name : \"" << getName() << "\"\n"; + ret << "Description of mesh : \"" << getDescription() << "\"\n"; ret << "Cell id where 1D mesh has been deduced : " << _cell_2D_id << "\n"; ret << "Number of cells : " << getNumberOfCells() << "(" << _mesh2D->getNumberOfCells() << "x" << _mesh1D->getNumberOfCells() << ")\n"; ret << "1D Mesh info : _____________________\n\n\n"; @@ -269,6 +270,7 @@ std::string MEDCouplingExtrudedMesh::advancedRepr() const { std::ostringstream ret; ret << "3D Extruded mesh from a 2D Surf Mesh with name : \"" << getName() << "\"\n"; + ret << "Description of mesh : \"" << getDescription() << "\"\n"; ret << "Cell id where 1D mesh has been deduced : " << _cell_2D_id << "\n"; ret << "Number of cells : " << getNumberOfCells() << "(" << _mesh2D->getNumberOfCells() << "x" << _mesh1D->getNumberOfCells() << ")\n"; ret << "1D Mesh info : _____________________\n\n\n"; diff --git a/src/MEDCoupling/MEDCouplingFieldDouble.cxx b/src/MEDCoupling/MEDCouplingFieldDouble.cxx index 87a875b33..31f12c1e0 100644 --- a/src/MEDCoupling/MEDCouplingFieldDouble.cxx +++ b/src/MEDCoupling/MEDCouplingFieldDouble.cxx @@ -18,6 +18,7 @@ // #include "MEDCouplingFieldDouble.hxx" +#include "MEDCouplingFieldTemplate.hxx" #include "MEDCouplingUMesh.hxx" #include "MEDCouplingTimeDiscretization.hxx" #include "MEDCouplingFieldDiscretization.hxx" @@ -35,6 +36,21 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::New(TypeOfField type, TypeOfTime return new MEDCouplingFieldDouble(type,td); } +MEDCouplingFieldDouble *MEDCouplingFieldDouble::New(const MEDCouplingFieldTemplate *ft, TypeOfTimeDiscretization td) +{ + return new MEDCouplingFieldDouble(ft,td); +} + +void MEDCouplingFieldDouble::setTimeUnit(const char *unit) +{ + _time_discr->setTimeUnit(unit); +} + +const char *MEDCouplingFieldDouble::getTimeUnit() const +{ + return _time_discr->getTimeUnit(); +} + MEDCouplingFieldDouble *MEDCouplingFieldDouble::clone(bool recDeepCpy) const { return new MEDCouplingFieldDouble(*this,recDeepCpy); @@ -59,7 +75,7 @@ MEDCouplingFieldDouble *MEDCouplingFieldDouble::deepCpy() const MEDCouplingFieldDouble *MEDCouplingFieldDouble::buildNewTimeReprFromThis(TypeOfTimeDiscretization td, bool deepCpy) const { - MEDCouplingTimeDiscretization *tdo=_time_discr->buildNewTimeReprFromThis(_time_discr,td,deepCpy); + MEDCouplingTimeDiscretization *tdo=_time_discr->buildNewTimeReprFromThis(td,deepCpy); MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(getNature(),tdo,_type->clone()); ret->setMesh(getMesh()); ret->setName(getName()); @@ -380,6 +396,11 @@ MEDCouplingFieldDouble::MEDCouplingFieldDouble(TypeOfField type, TypeOfTimeDiscr { } +MEDCouplingFieldDouble::MEDCouplingFieldDouble(const MEDCouplingFieldTemplate *ft, TypeOfTimeDiscretization td):MEDCouplingField(*ft), + _time_discr(MEDCouplingTimeDiscretization::New(td)) +{ +} + MEDCouplingFieldDouble::MEDCouplingFieldDouble(const MEDCouplingFieldDouble& other, bool deepCpy):MEDCouplingField(other), _time_discr(other._time_discr->performCpy(deepCpy)) { @@ -905,6 +926,11 @@ void MEDCouplingFieldDouble::setEndArray(DataArrayDouble *array) _time_discr->setEndArray(array,this); } +void MEDCouplingFieldDouble::setArrays(const std::vector& arrs) throw(INTERP_KERNEL::Exception) +{ + _time_discr->setArrays(arrs,this); +} + void MEDCouplingFieldDouble::getTinySerializationStrInformation(std::vector& tinyInfo) const { tinyInfo.clear(); diff --git a/src/MEDCoupling/MEDCouplingFieldDouble.hxx b/src/MEDCoupling/MEDCouplingFieldDouble.hxx index 5d898e590..2ac2ed485 100644 --- a/src/MEDCoupling/MEDCouplingFieldDouble.hxx +++ b/src/MEDCoupling/MEDCouplingFieldDouble.hxx @@ -27,10 +27,15 @@ namespace ParaMEDMEM { + class MEDCouplingFieldTemplate; + class MEDCOUPLING_EXPORT MEDCouplingFieldDouble : public MEDCouplingField { public: static MEDCouplingFieldDouble *New(TypeOfField type, TypeOfTimeDiscretization td=NO_TIME); + static MEDCouplingFieldDouble *New(const MEDCouplingFieldTemplate *ft, TypeOfTimeDiscretization td=NO_TIME); + void setTimeUnit(const char *unit); + const char *getTimeUnit() const; void copyTinyStringsFrom(const MEDCouplingFieldDouble *other) throw(INTERP_KERNEL::Exception); void copyTinyAttrFrom(const MEDCouplingFieldDouble *other) throw(INTERP_KERNEL::Exception); std::string simpleRepr() const; @@ -74,8 +79,10 @@ namespace ParaMEDMEM double getIJK(int cellId, int nodeIdInCell, int compoId) const; void setArray(DataArrayDouble *array); void setEndArray(DataArrayDouble *array); + void setArrays(const std::vector& arrs) throw(INTERP_KERNEL::Exception); DataArrayDouble *getArray() const { return _time_discr->getArray(); } DataArrayDouble *getEndArray() const { return _time_discr->getEndArray(); } + std::vector getArrays() const { std::vector ret; _time_discr->getArrays(ret); return ret; } double accumulate(int compId) const; void accumulate(double *res) const; double getMaxValue() const throw(INTERP_KERNEL::Exception); @@ -159,8 +166,12 @@ namespace ParaMEDMEM MEDCouplingFieldDouble *operator/(const MEDCouplingFieldDouble& other) const throw(INTERP_KERNEL::Exception) { return DivideFields(this,&other); } const MEDCouplingFieldDouble &operator/=(const MEDCouplingFieldDouble& other) throw(INTERP_KERNEL::Exception); static MEDCouplingFieldDouble *DivideFields(const MEDCouplingFieldDouble *f1, const MEDCouplingFieldDouble *f2) throw(INTERP_KERNEL::Exception); + public: + const MEDCouplingTimeDiscretization *getTimeDiscretizationUnderGround() const { return _time_discr; } + MEDCouplingTimeDiscretization *getTimeDiscretizationUnderGround() { return _time_discr; } private: MEDCouplingFieldDouble(TypeOfField type, TypeOfTimeDiscretization td); + MEDCouplingFieldDouble(const MEDCouplingFieldTemplate *ft, TypeOfTimeDiscretization td); MEDCouplingFieldDouble(const MEDCouplingFieldDouble& other, bool deepCpy); MEDCouplingFieldDouble(NatureOfField n, MEDCouplingTimeDiscretization *td, MEDCouplingFieldDiscretization *type); ~MEDCouplingFieldDouble(); diff --git a/src/MEDCoupling/MEDCouplingFieldOverTime.cxx b/src/MEDCoupling/MEDCouplingFieldOverTime.cxx new file mode 100644 index 000000000..b8978b053 --- /dev/null +++ b/src/MEDCoupling/MEDCouplingFieldOverTime.cxx @@ -0,0 +1,161 @@ +// Copyright (C) 2007-2010 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#include "MEDCouplingFieldOverTime.hxx" +#include "MEDCouplingMesh.hxx" + +#include + +using namespace ParaMEDMEM; + +MEDCouplingFieldOverTime *MEDCouplingFieldOverTime::New(const std::vector& fs) throw(INTERP_KERNEL::Exception) +{ + return new MEDCouplingFieldOverTime(fs); +} + +double MEDCouplingFieldOverTime::getTimeTolerance() const throw(INTERP_KERNEL::Exception) +{ + std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_fs.begin(); + if(_fs.empty()) + throw INTERP_KERNEL::Exception("MEDCouplingFieldOverTime::getTimeTolerance : empty set !"); + for(;it!=_fs.end();it++) + if((const MEDCouplingFieldDouble *)(*it)!=0) + return (*it)->getTimeTolerance(); + throw INTERP_KERNEL::Exception("MEDCouplingFieldOverTime::getTimeTolerance : only empty fields in this !"); +} + +void MEDCouplingFieldOverTime::checkCoherency() const throw(INTERP_KERNEL::Exception) +{ + MEDCouplingMultiFields::checkCoherency(); + std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_fs.begin(); + for(;it!=_fs.end();it++) + if((*it)->getTimeDiscretization()==NO_TIME) + { + std::ostringstream oss; oss << "MEDCouplingFieldOverTime::checkCoherency : At rank #" << std::distance(_fs.begin(),it) << " the field has no time !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } + if(_fs.empty()) + return ; + it=_fs.begin(); + const MEDCouplingFieldDouble& ref=*(*(it++)); + int tt1,tt2; + double reft=ref.getEndTime(tt1,tt2); + double eps=getTimeTolerance(); + int id=1; + for(;it!=_fs.end();it++,id++) + { + if(!ref.getMesh()->areCompatibleForMerge((*it)->getMesh())) + { + std::ostringstream oss; oss << "Field slice at rank #" << id << " is not compatible with the first !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } + double curt=(*it)->getStartTime(tt1,tt2); + if(curtgetEndTime(tt1,tt2); + } +} + +std::string MEDCouplingFieldOverTime::simpleRepr() const +{ + std::ostringstream ret; + ret << "MEDCouplingFieldOverTime with name : \"" << getName() << "\"\n"; + ret << "Description of MEDCouplingFieldOverTime is : \"" << getDescription() << "\"\n"; + ret << "Number of discretization : " << _fs.size() << "\n"; + ret << "Number of different meshes : "; + std::vector ms; + std::vector refms; + try + { + ms=getDifferentMeshes(refms); + ret << ms.size() << "\n"; + } + catch(INTERP_KERNEL::Exception& e) + { ret << "Current instance is INVALID !\n"; } + try + { + MEDCouplingDefinitionTime dt=getDefinitionTimeZone(); + dt.appendRepr(ret); + } + catch(INTERP_KERNEL::Exception& e) + { ret << "Definition zone is INVALID !\n"; } + return ret.str(); +} + +bool MEDCouplingFieldOverTime::isEqual(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const +{ + if(!MEDCouplingMultiFields::isEqual(other,meshPrec,valsPrec)) + return false; + const MEDCouplingFieldOverTime *otherC=dynamic_cast(other); + if(!otherC) + return false; + // to implement + return true; +} + +bool MEDCouplingFieldOverTime::isEqualWithoutConsideringStr(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const +{ + if(!MEDCouplingMultiFields::isEqualWithoutConsideringStr(other,meshPrec,valsPrec)) + return false; + const MEDCouplingFieldOverTime *otherC=dynamic_cast(other); + if(!otherC) + return false; + // to implement + return true; +} + +std::vector MEDCouplingFieldOverTime::getMeshes() const throw(INTERP_KERNEL::Exception) +{ + checkCoherency(); + return MEDCouplingMultiFields::getMeshes(); +} + +std::vector MEDCouplingFieldOverTime::getDifferentMeshes(std::vector& refs) const throw(INTERP_KERNEL::Exception) +{ + checkCoherency(); + return MEDCouplingMultiFields::getDifferentMeshes(refs); +} + +std::vector MEDCouplingFieldOverTime::getArrays() const throw(INTERP_KERNEL::Exception) +{ + checkCoherency(); + return MEDCouplingMultiFields::getArrays(); +} + +std::vector MEDCouplingFieldOverTime::getDifferentArrays(std::vector< std::vector >& refs) const throw(INTERP_KERNEL::Exception) +{ + checkCoherency(); + return MEDCouplingMultiFields::getDifferentArrays(refs); +} + +MEDCouplingDefinitionTime MEDCouplingFieldOverTime::getDefinitionTimeZone() const +{ + std::vector< std::vector > tmp; + getDifferentArrays(tmp); + std::vector tmp2(_fs.begin(),_fs.end()); + std::vector tmp3; + getDifferentMeshes(tmp3); + return MEDCouplingDefinitionTime(tmp2,tmp3,tmp); +} + +MEDCouplingFieldOverTime::MEDCouplingFieldOverTime(const std::vector& fs) throw(INTERP_KERNEL::Exception):MEDCouplingMultiFields(fs) +{ + checkCoherency(); +} + diff --git a/src/MEDCoupling/MEDCouplingFieldOverTime.hxx b/src/MEDCoupling/MEDCouplingFieldOverTime.hxx new file mode 100644 index 000000000..565fdbb9d --- /dev/null +++ b/src/MEDCoupling/MEDCouplingFieldOverTime.hxx @@ -0,0 +1,50 @@ +// Copyright (C) 2007-2010 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#ifndef __PARAMEDMEM_MEDCOUPLINGFIELDOVERTIME_HXX__ +#define __PARAMEDMEM_MEDCOUPLINGFIELDOVERTIME_HXX__ + +#include "MEDCouplingMultiFields.hxx" +#include "MEDCouplingDefinitionTime.hxx" +#include "MEDCouplingFieldDouble.hxx" + +#include + +namespace ParaMEDMEM +{ + class MEDCouplingFieldOverTime : public MEDCouplingMultiFields + { + public: + static MEDCouplingFieldOverTime *New(const std::vector& fs) throw(INTERP_KERNEL::Exception); + void checkCoherency() const throw(INTERP_KERNEL::Exception); + double getTimeTolerance() const throw(INTERP_KERNEL::Exception); + std::string simpleRepr() const; + bool isEqual(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const; + bool isEqualWithoutConsideringStr(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const; + std::vector getMeshes() const throw(INTERP_KERNEL::Exception); + std::vector getDifferentMeshes(std::vector& refs) const throw(INTERP_KERNEL::Exception); + std::vector getArrays() const throw(INTERP_KERNEL::Exception); + std::vector getDifferentArrays(std::vector< std::vector >& refs) const throw(INTERP_KERNEL::Exception); + MEDCouplingDefinitionTime getDefinitionTimeZone() const; + private: + MEDCouplingFieldOverTime(const std::vector& fs) throw(INTERP_KERNEL::Exception); + }; +} + +#endif diff --git a/src/MEDCoupling/MEDCouplingFieldTemplate.cxx b/src/MEDCoupling/MEDCouplingFieldTemplate.cxx index 91b2b333c..33ca9bdf5 100644 --- a/src/MEDCoupling/MEDCouplingFieldTemplate.cxx +++ b/src/MEDCoupling/MEDCouplingFieldTemplate.cxx @@ -18,6 +18,7 @@ // #include "MEDCouplingFieldTemplate.hxx" +#include "MEDCouplingMesh.hxx" #include "MEDCouplingFieldDouble.hxx" #include "MEDCouplingFieldDiscretization.hxx" @@ -51,6 +52,25 @@ void MEDCouplingFieldTemplate::checkCoherency() const throw(INTERP_KERNEL::Excep throw INTERP_KERNEL::Exception("MEDCouplingFieldTemplate::checkCoherency : Empty mesh !"); } +std::string MEDCouplingFieldTemplate::simpleRepr() const +{ + std::ostringstream ret; + ret << "FieldTemplate with name : \"" << getName() << "\"\n"; + ret << "Description of field is : \"" << getDescription() << "\"\n"; + ret << "FieldTemplate space discretization is : " << _type->getStringRepr() << "\n"; + ret << "FieldTemplate nature of field is : " << MEDCouplingNatureOfField::getRepr(_nature) << "\n"; + if(_mesh) + ret << "Mesh support information :\n__________________________\n" << _mesh->simpleRepr(); + else + ret << "Mesh support information : No mesh set !\n"; + return ret.str(); +} + +std::string MEDCouplingFieldTemplate::advancedRepr() const +{ + return simpleRepr(); +} + void MEDCouplingFieldTemplate::getTinySerializationIntInformation(std::vector& tinyInfo) const { tinyInfo.clear(); diff --git a/src/MEDCoupling/MEDCouplingFieldTemplate.hxx b/src/MEDCoupling/MEDCouplingFieldTemplate.hxx index 5a4e47a36..f72815ce5 100644 --- a/src/MEDCoupling/MEDCouplingFieldTemplate.hxx +++ b/src/MEDCoupling/MEDCouplingFieldTemplate.hxx @@ -31,6 +31,8 @@ namespace ParaMEDMEM public: static MEDCouplingFieldTemplate *New(const MEDCouplingFieldDouble *f) throw(INTERP_KERNEL::Exception); static MEDCouplingFieldTemplate *New(TypeOfField type); + std::string simpleRepr() const; + std::string advancedRepr() const; void checkCoherency() const throw(INTERP_KERNEL::Exception); // void getTinySerializationIntInformation(std::vector& tinyInfo) const; diff --git a/src/MEDCoupling/MEDCouplingMemArray.cxx b/src/MEDCoupling/MEDCouplingMemArray.cxx index bdb858bf9..443a7e5c8 100644 --- a/src/MEDCoupling/MEDCouplingMemArray.cxx +++ b/src/MEDCoupling/MEDCouplingMemArray.cxx @@ -1470,6 +1470,76 @@ void DataArrayDouble::divideEqual(const DataArrayDouble *other) throw(INTERP_KER declareAsNew(); } +/*! + * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class. + * Server side. + */ +void DataArrayDouble::getTinySerializationIntInformation(std::vector& tinyInfo) const +{ + tinyInfo.resize(2); + if(isAllocated()) + { + tinyInfo[0]=getNumberOfTuples(); + tinyInfo[1]=getNumberOfComponents(); + } + else + { + tinyInfo[0]=-1; + tinyInfo[1]=-1; + } +} + +/*! + * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class. + * Server side. + */ +void DataArrayDouble::getTinySerializationStrInformation(std::vector& tinyInfo) const +{ + if(isAllocated()) + { + int nbOfCompo=getNumberOfComponents(); + tinyInfo.resize(nbOfCompo+1); + tinyInfo[0]=getName(); + for(int i=0;i& tinyInfoI) +{ + int nbOfTuple=tinyInfoI[0]; + int nbOfComp=tinyInfoI[1]; + if(nbOfTuple!=-1 || nbOfComp!=-1) + { + alloc(nbOfTuple,nbOfComp); + return true; + } + return false; +} + +/*! + * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class. + */ +void DataArrayDouble::finishUnserialization(const std::vector& tinyInfoI, const std::vector& tinyInfoS) +{ + setName(tinyInfoS[0].c_str()); + if(isAllocated()) + { + int nbOfCompo=getNumberOfComponents(); + for(int i=0;iuseArray(pt2,true,CPP_DEALLOC,nbTuples,1); + return ret; +} + /*! * This method checks that 'this' is with numberofcomponents == 1 and that it is equal to * stdext::iota() of size getNumberOfTuples. This method is particalary usefull for DataArrayInt instances diff --git a/src/MEDCoupling/MEDCouplingMemArray.hxx b/src/MEDCoupling/MEDCouplingMemArray.hxx index cf24a438c..3298a5b2f 100644 --- a/src/MEDCoupling/MEDCouplingMemArray.hxx +++ b/src/MEDCoupling/MEDCouplingMemArray.hxx @@ -209,6 +209,11 @@ namespace ParaMEDMEM MEDCOUPLING_EXPORT void divideEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception); //! nothing to do here because this class does not aggregate any TimeLabel instance. MEDCOUPLING_EXPORT void updateTime() { } + public: + void getTinySerializationIntInformation(std::vector& tinyInfo) const; + void getTinySerializationStrInformation(std::vector& tinyInfo) const; + bool resizeForUnserialization(const std::vector& tinyInfoI); + void finishUnserialization(const std::vector& tinyInfoI, const std::vector& tinyInfoS); private: DataArrayDouble() { } private: @@ -253,6 +258,7 @@ namespace ParaMEDMEM MEDCOUPLING_EXPORT DataArrayInt *renumberAndReduce(const int *old2NewBg, int newNbOfTuple) const; MEDCOUPLING_EXPORT DataArrayInt *selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const; MEDCOUPLING_EXPORT DataArrayInt *selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const throw(INTERP_KERNEL::Exception); + MEDCOUPLING_EXPORT DataArrayInt *checkAndPreparePermutation() const throw(INTERP_KERNEL::Exception); MEDCOUPLING_EXPORT bool isIdentity() const; MEDCOUPLING_EXPORT bool isUniform(int val) const; MEDCOUPLING_EXPORT DataArrayInt *substr(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception); diff --git a/src/MEDCoupling/MEDCouplingMesh.cxx b/src/MEDCoupling/MEDCouplingMesh.cxx index 81ccda0b7..4cd5dde75 100644 --- a/src/MEDCoupling/MEDCouplingMesh.cxx +++ b/src/MEDCoupling/MEDCouplingMesh.cxx @@ -39,7 +39,7 @@ bool MEDCouplingMesh::isStructured() const bool MEDCouplingMesh::isEqual(const MEDCouplingMesh *other, double prec) const { - return _name==other->_name; + return _name==other->_name && _description==other->_description; } /*! @@ -183,6 +183,7 @@ MEDCouplingFieldDouble *MEDCouplingMesh::fillFromAnalytic(TypeOfField t, int nbO void MEDCouplingMesh::copyTinyStringsFrom(const MEDCouplingMesh *other) throw(INTERP_KERNEL::Exception) { _name=other->_name; + _description=other->_description; } /*! diff --git a/src/MEDCoupling/MEDCouplingMesh.hxx b/src/MEDCoupling/MEDCouplingMesh.hxx index 27c5cb6ad..8c883beb1 100644 --- a/src/MEDCoupling/MEDCouplingMesh.hxx +++ b/src/MEDCoupling/MEDCouplingMesh.hxx @@ -48,6 +48,8 @@ namespace ParaMEDMEM public: void setName(const char *name) { _name=name; } const char *getName() const { return _name.c_str(); } + void setDescription(const char *descr) { _description=descr; } + const char *getDescription() const { return _description.c_str(); } virtual MEDCouplingMesh *deepCpy() const = 0; virtual MEDCouplingMeshType getType() const = 0; bool isStructured() const; @@ -104,10 +106,11 @@ namespace ParaMEDMEM const std::vector& littleStrings) = 0; protected: MEDCouplingMesh() { } - MEDCouplingMesh(const MEDCouplingMesh& other):_name(other._name) { } + MEDCouplingMesh(const MEDCouplingMesh& other):_name(other._name),_description(other._description) { } virtual ~MEDCouplingMesh() { } private: std::string _name; + std::string _description; }; } diff --git a/src/MEDCoupling/MEDCouplingMultiFields.cxx b/src/MEDCoupling/MEDCouplingMultiFields.cxx new file mode 100644 index 000000000..aaf3d6f98 --- /dev/null +++ b/src/MEDCoupling/MEDCouplingMultiFields.cxx @@ -0,0 +1,439 @@ +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#include "MEDCouplingMultiFields.hxx" +#include "MEDCouplingFieldTemplate.hxx" +#include "MEDCouplingFieldDouble.hxx" +#include "MEDCouplingMesh.hxx" +#include "MEDCouplingAutoRefCountObjectPtr.hxx" + +using namespace ParaMEDMEM; + +MEDCouplingMultiFields *MEDCouplingMultiFields::New(const std::vector& fs) throw(INTERP_KERNEL::Exception) +{ + return new MEDCouplingMultiFields(fs); +} + +MEDCouplingMultiFields *MEDCouplingMultiFields::New() +{ + return new MEDCouplingMultiFields; +} + +MEDCouplingMultiFields *MEDCouplingMultiFields::deepCpy() const +{ + return new MEDCouplingMultiFields(*this); +} + +bool MEDCouplingMultiFields::isEqual(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const +{ + std::size_t sz=_fs.size(); + if(sz!=other->_fs.size()) + return false; + for(std::size_t i=0;i_fs[i]; + if(f1!=f2) + { + if(f1==0 || f2==0) + return false; + if(!_fs[i]->isEqual(other->_fs[i],meshPrec,valsPrec)) + return false; + } + } + std::vector refs1,refs2; + std::vector ms1=getDifferentMeshes(refs1); + std::vector ms2=other->getDifferentMeshes(refs2); + if(ms1.size()!=ms2.size()) + return false; + if(refs1!=refs2) + return false; + std::vector< std::vector > refs3,refs4; + std::vector das1=getDifferentArrays(refs3); + std::vector das2=getDifferentArrays(refs4); + if(das1.size()!=das2.size()) + return false; + if(refs3!=refs4) + return false; + return true; +} + +std::string MEDCouplingMultiFields::getName() const +{ + std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_fs.begin(); + for(;it!=_fs.end();it++) + if((const MEDCouplingFieldDouble *)(*it)) + return (*it)->getName(); + return std::string(); +} + +std::string MEDCouplingMultiFields::getDescription() const +{ + std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_fs.begin(); + for(;it!=_fs.end();it++) + if((const MEDCouplingFieldDouble *)(*it)) + return (*it)->getDescription(); + return std::string(); +} + +std::string MEDCouplingMultiFields::getTimeUnit() const +{ + std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_fs.begin(); + for(;it!=_fs.end();it++) + if((const MEDCouplingFieldDouble *)(*it)) + return (*it)->getTimeUnit(); + return std::string(); +} + +double MEDCouplingMultiFields::getTimeResolution() const throw(INTERP_KERNEL::Exception) +{ + std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_fs.begin(); + for(;it!=_fs.end();it++) + if((const MEDCouplingFieldDouble *)(*it)) + return (*it)->getTimeTolerance(); + throw INTERP_KERNEL::Exception("MEDCouplingMultiFields::getTimeResolution : no not null field !"); +} + +std::string MEDCouplingMultiFields::simpleRepr() const +{ + std::ostringstream ret; + ret << "MEDCouplingMultiFields with name : \"" << getName() << "\"\n"; + ret << "Description of MEDCouplingMultiFields is : \"" << getDescription() << "\"\n"; + ret << "Number of discretization : " << _fs.size() << "\n"; + ret << "Number of different meshes : "; + std::vector ms; + std::vector refms; + try + { + ms=getDifferentMeshes(refms); + ret << ms.size() << "\n"; + } + catch(INTERP_KERNEL::Exception& e) + { ret << "Current instance is INVALID !\n"; } + return ret.str(); +} + +std::string MEDCouplingMultiFields::advancedRepr() const +{ + return simpleRepr(); +} + +bool MEDCouplingMultiFields::isEqualWithoutConsideringStr(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const +{ + std::size_t sz=_fs.size(); + if(sz!=other->_fs.size()) + return false; + for(std::size_t i=0;iisEqualWithoutConsideringStr(other->_fs[i],meshPrec,valsPrec)) + return false; + return true; +} + +const MEDCouplingFieldDouble *MEDCouplingMultiFields::getFieldWithId(int id) const throw(INTERP_KERNEL::Exception) +{ + if(id>=(int)_fs.size() || id < 0) + throw INTERP_KERNEL::Exception("MEDCouplingMultiFields::getFieldWithId : invalid id outside boundaries !"); + return _fs[id]; +} + +std::vector MEDCouplingMultiFields::getFields() const +{ + std::vector ret(_fs.size()); + std::copy(_fs.begin(),_fs.end(),ret.begin()); + return ret; +} + +int MEDCouplingMultiFields::getNumberOfFields() const +{ + return _fs.size(); +} + +const MEDCouplingFieldDouble *MEDCouplingMultiFields::getFieldAtPos(int id) const throw(INTERP_KERNEL::Exception) +{ + if(id<0 || id>=(int)_fs.size()) + { + std::ostringstream oss; oss << "MEDCouplingMultiFields::getFieldAtPos : Invalid given pos : should be >=0 and < " << _fs.size() << " !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } + return _fs[id]; +} + +void MEDCouplingMultiFields::updateTime() +{ + std::vector< MEDCouplingAutoRefCountObjectPtr >::iterator it=_fs.begin(); + for(;it!=_fs.end();it++) + if((MEDCouplingFieldDouble *)(*it)) + (*it)->updateTime(); + it=_fs.begin(); + for(;it!=_fs.end();it++) + if((MEDCouplingFieldDouble *)(*it)) + updateTimeWith(*(*it)); +} + +std::vector MEDCouplingMultiFields::getMeshes() const throw(INTERP_KERNEL::Exception) +{ + std::vector ms; + for(std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_fs.begin();it!=_fs.end();it++) + { + const MEDCouplingMesh *m=0; + if((const MEDCouplingFieldDouble *)(*it)) + m=(*it)->getMesh(); + ms.push_back(const_cast(m)); + } + return ms; +} + +std::vector MEDCouplingMultiFields::getDifferentMeshes(std::vector& refs) const throw(INTERP_KERNEL::Exception) +{ + refs.resize(_fs.size()); + std::vector ms; + int id=0; + for(std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_fs.begin();it!=_fs.end();it++,id++) + { + const MEDCouplingMesh *m=0; + if((const MEDCouplingFieldDouble *)(*it)) + m=(*it)->getMesh(); + if(m) + { + std::vector::iterator it=std::find(ms.begin(),ms.end(),m); + if(it==ms.end()) + { + ms.push_back(const_cast(m)); + refs[id]=ms.size()-1; + } + else + refs[id]=std::distance(ms.begin(),it); + } + else + refs[id]=-1; + } + return ms; +} + +std::vector MEDCouplingMultiFields::getArrays() const throw(INTERP_KERNEL::Exception) +{ + std::vector tmp; + for(std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_fs.begin();it!=_fs.end();it++) + { + std::vector tmp2=(*it)->getArrays(); + tmp.insert(tmp.end(),tmp2.begin(),tmp2.end()); + } + return tmp; +} + +std::vector MEDCouplingMultiFields::getDifferentArrays(std::vector< std::vector >& refs) const throw(INTERP_KERNEL::Exception) +{ + refs.resize(_fs.size()); + int id=0; + std::vector ret; + for(std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_fs.begin();it!=_fs.end();it++,id++) + { + std::vector tmp2; + if((const MEDCouplingFieldDouble *)(*it)) + { + tmp2=(*it)->getArrays(); + refs[id].resize(tmp2.size()); + } + else + refs[id].clear(); + int id2=0; + for(std::vector::const_iterator it2=tmp2.begin();it2!=tmp2.end();it2++,id2++) + { + if(*it2) + { + std::vector::iterator it3=std::find(ret.begin(),ret.end(),*it2); + if(it3==ret.end()) + { + ret.push_back(*it2); + refs[id][id2]=ret.size()-1; + } + else + refs[id][id2]=std::distance(ret.begin(),it3); + } + else + refs[id][id2]=-1; + } + } + return ret; +} + +void MEDCouplingMultiFields::checkCoherency() const throw(INTERP_KERNEL::Exception) +{ + std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_fs.begin(); + for(;it!=_fs.end();it++) + { + if((const MEDCouplingFieldDouble *)(*it)==0) + throw INTERP_KERNEL::Exception("MEDCouplingMultiFields::checkCoherency : There is an empty Field in array..."); + (*it)->checkCoherency(); + } +} + +MEDCouplingMultiFields::MEDCouplingMultiFields(const std::vector& fs) throw(INTERP_KERNEL::Exception):_fs(fs.size()) +{ + int id=0; + for(std::vector< MEDCouplingFieldDouble * >::const_iterator it=fs.begin();it!=fs.end();it++,id++) + { + if(*it) + (*it)->incrRef(); + else + throw INTERP_KERNEL::Exception("MEDCouplingMultiFields constructor : empty field found in vector !"); + (*it)->checkCoherency(); + _fs[id]=*it; + } +} + + +/*! + * Performs deepCpy. + */ +MEDCouplingMultiFields::MEDCouplingMultiFields(const MEDCouplingMultiFields& other) +{ + int sz=other._fs.size(); + _fs.resize(sz); + std::vector refs; + std::vector< std::vector > refs2; + std::vector ms=other.getDifferentMeshes(refs); + int msLgh=ms.size(); + std::vector< MEDCouplingAutoRefCountObjectPtr > ms2(msLgh); + for(int i=0;ideepCpy(); + std::vector das=other.getDifferentArrays(refs2); + int dasLgth=das.size(); + std::vector< MEDCouplingAutoRefCountObjectPtr > das2(dasLgth); + for(int i=0;ideepCpy(); + for(int i=0;igetTimeDiscretization()); + tmp->decrRef(); + if(refs[i]!=-1) + _fs[i]->setMesh(ms2[refs[i]]); + int nbOfArr=refs2[i].size(); + std::vector tmp2(nbOfArr); + for(int j=0;jsetArrays(tmp2); + std::vector tinyInfo; + std::vector tinyInfo2; + other._fs[i]->getTimeDiscretizationUnderGround()->getTinySerializationIntInformation2(tinyInfo); + other._fs[i]->getTimeDiscretizationUnderGround()->getTinySerializationDbleInformation2(tinyInfo2); + _fs[i]->getTimeDiscretizationUnderGround()->finishUnserialization2(tinyInfo,tinyInfo2); + } + } +} + +MEDCouplingMultiFields::MEDCouplingMultiFields() +{ +} + +void MEDCouplingMultiFields::getTinySerializationInformation(std::vector& tinyInfo, std::vector& tinyInfo2, int& nbOfDiffMeshes, int& nbOfDiffArr) const +{ + std::vector refs; + std::vector ms=getDifferentMeshes(refs); + nbOfDiffMeshes=ms.size(); + std::vector< std::vector > refs2; + std::vector fs=getDifferentArrays(refs2); + nbOfDiffArr=fs.size(); + // + int sz=refs.size();//==_fs.size() + int sz2=0; + for(int i=0;i doubleDaInd(sz); + std::vector timeDiscrInt; + tinyInfo.resize(sz2+5*sz+3); + tinyInfo[0]=sz; + tinyInfo[1]=sz2; + for(int i=0;i tmp; + std::vector tmp2; + _fs[i]->getTimeDiscretizationUnderGround()->getTinySerializationDbleInformation2(tmp); + _fs[i]->getTimeDiscretizationUnderGround()->getTinySerializationIntInformation2(tmp2); + tinyInfo[3*sz+3+i]=tmp.size(); + tinyInfo[4*sz+3+i]=tmp2.size(); + tinyInfo2.insert(tinyInfo2.end(),tmp.begin(),tmp.end()); + timeDiscrInt.insert(timeDiscrInt.end(),tmp2.begin(),tmp2.end()); + } + int sz3=timeDiscrInt.size(); + tinyInfo[2]=sz3; + // + for(int i=0;igetTimeDiscretization(); + int k=0; + for(int i=0;i::const_iterator it=refs2[i].begin();it!=refs2[i].end();it++,k++) + tinyInfo[5*sz+k+3]=*it; + tinyInfo.insert(tinyInfo.end(),timeDiscrInt.begin(),timeDiscrInt.end());//tinyInfo has lgth==sz3+sz2+5*sz+3 +} + +void MEDCouplingMultiFields::finishUnserialization(const std::vector& tinyInfoI, const std::vector& tinyInfoD, + const std::vector& ft, const std::vector& ms, + const std::vector& das) +{ + int sz=tinyInfoI[0]; + _fs.resize(sz); + int sz2=tinyInfoI[1]; + // dealing with ft with no mesh set. + for(int i=0;isetMesh(ms[meshId]); + } + // dealing with fieldtemplate->fielddouble + int k=0; + int offI=0; + int offD=0; + for(int i=0;i tmp(sz3); + for(int j=0;jsetArrays(tmp); + // time discr tiny info + int lgthI=tinyInfoI[4*sz+3+i]; + int lgthD=tinyInfoI[3*sz+3+i]; + // + std::vector tdInfoI(tinyInfoI.begin()+sz2+5*sz+3+offI,tinyInfoI.begin()+sz2+5*sz+3+offI+lgthI); + std::vector tdInfoD(tinyInfoD.begin()+offD,tinyInfoD.begin()+offD+lgthD); + _fs[i]->getTimeDiscretizationUnderGround()->finishUnserialization2(tdInfoI,tdInfoD); + // + offI+=lgthI; + offD+=lgthD; + } +} diff --git a/src/MEDCoupling/MEDCouplingMultiFields.hxx b/src/MEDCoupling/MEDCouplingMultiFields.hxx new file mode 100644 index 000000000..26a6a1a18 --- /dev/null +++ b/src/MEDCoupling/MEDCouplingMultiFields.hxx @@ -0,0 +1,76 @@ +// Copyright (C) 2007-2010 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#ifndef __PARAMEDMEM_MEDCOUPLINGMULTIFIELDS_HXX__ +#define __PARAMEDMEM_MEDCOUPLINGMULTIFIELDS_HXX__ + +#include "MEDCouplingRefCountObject.hxx" +#include "MEDCouplingTimeLabel.hxx" +#include "MEDCouplingAutoRefCountObjectPtr.hxx" + +#include "InterpKernelException.hxx" + +#include + +namespace ParaMEDMEM +{ + class MEDCouplingMesh; + class DataArrayDouble; + class MEDCouplingFieldDouble; + class MEDCouplingFieldTemplate; + + class MEDCouplingMultiFields : public RefCountObject, public TimeLabel + { + public: + static MEDCouplingMultiFields *New(const std::vector& fs) throw(INTERP_KERNEL::Exception); + static MEDCouplingMultiFields *New(); + MEDCouplingMultiFields *deepCpy() const; + std::string getName() const; + std::string getDescription() const; + std::string getTimeUnit() const; + double getTimeResolution() const throw(INTERP_KERNEL::Exception); + virtual std::string simpleRepr() const; + virtual std::string advancedRepr() const; + virtual bool isEqual(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const; + virtual bool isEqualWithoutConsideringStr(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const; + const MEDCouplingFieldDouble *getFieldWithId(int id) const throw(INTERP_KERNEL::Exception); + std::vector getFields() const; + int getNumberOfFields() const; + const MEDCouplingFieldDouble *getFieldAtPos(int id) const throw(INTERP_KERNEL::Exception); + virtual std::vector getMeshes() const throw(INTERP_KERNEL::Exception); + virtual std::vector getDifferentMeshes(std::vector& refs) const throw(INTERP_KERNEL::Exception); + virtual std::vector getArrays() const throw(INTERP_KERNEL::Exception); + virtual std::vector getDifferentArrays(std::vector< std::vector >& refs) const throw(INTERP_KERNEL::Exception); + void updateTime(); + void getTinySerializationInformation(std::vector& tinyInfo, std::vector& tinyInfo2, int& nbOfDiffMeshes, int& nbOfDiffArr) const; + void finishUnserialization(const std::vector& tinyInfoI, const std::vector& tinyInfoD, + const std::vector& ft, const std::vector& ms, + const std::vector& das); + virtual void checkCoherency() const throw(INTERP_KERNEL::Exception); + protected: + MEDCouplingMultiFields(const std::vector& fs) throw(INTERP_KERNEL::Exception); + MEDCouplingMultiFields(const MEDCouplingMultiFields& other); + MEDCouplingMultiFields(); + protected: + std::vector< MEDCouplingAutoRefCountObjectPtr > _fs; + }; +} + +#endif + diff --git a/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx b/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx index 057e350e4..5e761d8fb 100644 --- a/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx +++ b/src/MEDCoupling/MEDCouplingTimeDiscretization.cxx @@ -65,10 +65,12 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::New(TypeOfTimeDisc void MEDCouplingTimeDiscretization::copyTinyAttrFrom(const MEDCouplingTimeDiscretization& other) { _time_tolerance=other._time_tolerance; + _time_unit=other._time_unit; } void MEDCouplingTimeDiscretization::copyTinyStringsFrom(const MEDCouplingTimeDiscretization& other) { + _time_unit=other._time_unit; if(_array && other._array) _array->copyStringInfoFrom(*other._array); } @@ -102,6 +104,8 @@ bool MEDCouplingTimeDiscretization::areCompatible(const MEDCouplingTimeDiscretiz bool MEDCouplingTimeDiscretization::areStrictlyCompatible(const MEDCouplingTimeDiscretization *other) const { + if(_time_unit!=other->_time_unit) + return false; if(std::fabs(_time_tolerance-other->_time_tolerance)>1.e-16) return false; if(_array==0 && other->_array==0) @@ -177,10 +181,10 @@ bool MEDCouplingTimeDiscretization::isEqualWithoutConsideringStr(const MEDCoupli return _array->isEqualWithoutConsideringStr(*other->_array,prec); } -MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::buildNewTimeReprFromThis(const MEDCouplingTimeDiscretization *other, - TypeOfTimeDiscretization type, bool deepCpy) const +MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::buildNewTimeReprFromThis(TypeOfTimeDiscretization type, bool deepCpy) const { MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(type); + ret->setTimeUnit(getTimeUnit()); DataArrayDouble *arrSrc=getArray(); DataArrayDouble *arr=0; if(arrSrc) @@ -245,7 +249,7 @@ MEDCouplingTimeDiscretization::MEDCouplingTimeDiscretization():_time_tolerance(T { } -MEDCouplingTimeDiscretization::MEDCouplingTimeDiscretization(const MEDCouplingTimeDiscretization& other, bool deepCpy):_time_tolerance(other._time_tolerance) +MEDCouplingTimeDiscretization::MEDCouplingTimeDiscretization(const MEDCouplingTimeDiscretization& other, bool deepCpy):_time_unit(other._time_unit),_time_tolerance(other._time_tolerance) { if(other._array) _array=other._array->performCpy(deepCpy); @@ -315,6 +319,7 @@ bool MEDCouplingTimeDiscretization::isStrictlyBefore(const MEDCouplingTimeDiscre MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::doublyContractedProduct() const throw(INTERP_KERNEL::Exception) { MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum()); + ret->setTimeUnit(getTimeUnit()); std::vector arrays; getArrays(arrays); std::vector< MEDCouplingAutoRefCountObjectPtr > arrays2(arrays.size()); @@ -348,6 +353,7 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::determinant() cons for(int j=0;j<(int)arrays.size();j++) arrays3[j]=arrays2[j]; MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum()); + ret->setTimeUnit(getTimeUnit()); ret->setArrays(arrays3,0); return ret; } @@ -368,6 +374,7 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::eigenValues() cons for(int j=0;j<(int)arrays.size();j++) arrays3[j]=arrays2[j]; MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum()); + ret->setTimeUnit(getTimeUnit()); ret->setArrays(arrays3,0); return ret; } @@ -388,6 +395,7 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::eigenVectors() con for(int j=0;j<(int)arrays.size();j++) arrays3[j]=arrays2[j]; MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum()); + ret->setTimeUnit(getTimeUnit()); ret->setArrays(arrays3,0); return ret; } @@ -408,6 +416,7 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::inverse() const th for(int j=0;j<(int)arrays.size();j++) arrays3[j]=arrays2[j]; MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum()); + ret->setTimeUnit(getTimeUnit()); ret->setArrays(arrays3,0); return ret; } @@ -428,6 +437,7 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::trace() const thro for(int j=0;j<(int)arrays.size();j++) arrays3[j]=arrays2[j]; MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum()); + ret->setTimeUnit(getTimeUnit()); ret->setArrays(arrays3,0); return ret; } @@ -448,6 +458,7 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::deviator() const t for(int j=0;j<(int)arrays.size();j++) arrays3[j]=arrays2[j]; MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum()); + ret->setTimeUnit(getTimeUnit()); ret->setArrays(arrays3,0); return ret; } @@ -468,6 +479,7 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::magnitude() const for(int j=0;j<(int)arrays.size();j++) arrays3[j]=arrays2[j]; MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum()); + ret->setTimeUnit(getTimeUnit()); ret->setArrays(arrays3,0); return ret; } @@ -488,6 +500,7 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::maxPerTuple() cons for(int j=0;j<(int)arrays.size();j++) arrays3[j]=arrays2[j]; MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum()); + ret->setTimeUnit(getTimeUnit()); ret->setArrays(arrays3,0); return ret; } @@ -508,6 +521,7 @@ MEDCouplingTimeDiscretization *MEDCouplingTimeDiscretization::keepSelectedCompon for(int j=0;j<(int)arrays.size();j++) arrays3[j]=arrays2[j]; MEDCouplingTimeDiscretization *ret=MEDCouplingTimeDiscretization::New(getEnum()); + ret->setTimeUnit(getTimeUnit()); ret->setArrays(arrays3,0); return ret; } @@ -709,6 +723,7 @@ std::string MEDCouplingNoTimeLabel::getStringRepr() const { std::ostringstream stream; stream << REPR; + stream << "\nTime unit is : \"" << _time_unit << "\""; return stream.str(); } @@ -1029,6 +1044,31 @@ void MEDCouplingNoTimeLabel::getValueOnDiscTime(int eltId, int iteration, int or throw INTERP_KERNEL::Exception(EXCEPTION_MSG); } +/*! + * idem getTinySerializationIntInformation except that it is for multi field fetch + */ +void MEDCouplingNoTimeLabel::getTinySerializationIntInformation2(std::vector& tinyInfo) const +{ + tinyInfo.clear(); +} + +/*! + * idem getTinySerializationDbleInformation except that it is for multi field fetch + */ +void MEDCouplingNoTimeLabel::getTinySerializationDbleInformation2(std::vector& tinyInfo) const +{ + tinyInfo.resize(1); + tinyInfo[0]=_time_tolerance; +} + +/*! + * idem finishUnserialization except that it is for multi field fetch + */ +void MEDCouplingNoTimeLabel::finishUnserialization2(const std::vector& tinyInfoI, const std::vector& tinyInfoD) +{ + _time_tolerance=tinyInfoD[0]; +} + MEDCouplingWithTimeStep::MEDCouplingWithTimeStep(const MEDCouplingWithTimeStep& other, bool deepCpy):MEDCouplingTimeDiscretization(other,deepCpy), _time(other._time),_iteration(other._iteration),_order(other._order) { @@ -1042,6 +1082,7 @@ std::string MEDCouplingWithTimeStep::getStringRepr() const { std::ostringstream stream; stream << REPR << " Time is defined by iteration=" << _iteration << " order=" << _order << " and time=" << _time << "."; + stream << "\nTime unit is : \"" << _time_unit << "\""; return stream.str(); } @@ -1066,6 +1107,37 @@ void MEDCouplingWithTimeStep::finishUnserialization(const std::vector& tiny _order=tinyInfoI[3]; } +/*! + * idem getTinySerializationIntInformation except that it is for multi field fetch + */ +void MEDCouplingWithTimeStep::getTinySerializationIntInformation2(std::vector& tinyInfo) const +{ + tinyInfo.resize(2); + tinyInfo[0]=_iteration; + tinyInfo[1]=_order; +} + +/*! + * idem getTinySerializationDbleInformation except that it is for multi field fetch + */ +void MEDCouplingWithTimeStep::getTinySerializationDbleInformation2(std::vector& tinyInfo) const +{ + tinyInfo.resize(2); + tinyInfo[0]=_time_tolerance; + tinyInfo[1]=_time; +} + +/*! + * idem finishUnserialization except that it is for multi field fetch + */ +void MEDCouplingWithTimeStep::finishUnserialization2(const std::vector& tinyInfoI, const std::vector& tinyInfoD) +{ + _iteration=tinyInfoI[0]; + _order=tinyInfoI[1]; + _time_tolerance=tinyInfoD[0]; + _time=tinyInfoD[1]; +} + bool MEDCouplingWithTimeStep::areCompatible(const MEDCouplingTimeDiscretization *other) const { if(!MEDCouplingTimeDiscretization::areCompatible(other)) @@ -1427,6 +1499,43 @@ void MEDCouplingConstOnTimeInterval::finishUnserialization(const std::vector& tinyInfo) const +{ + tinyInfo.resize(4); + tinyInfo[0]=_start_iteration; + tinyInfo[1]=_start_order; + tinyInfo[2]=_end_iteration; + tinyInfo[3]=_end_order; +} + +/*! + * idem getTinySerializationDbleInformation except that it is for multi field fetch + */ +void MEDCouplingConstOnTimeInterval::getTinySerializationDbleInformation2(std::vector& tinyInfo) const +{ + tinyInfo.resize(3); + tinyInfo[0]=_time_tolerance; + tinyInfo[1]=_start_time; + tinyInfo[2]=_end_time; +} + +/*! + * idem finishUnserialization except that it is for multi field fetch + */ +void MEDCouplingConstOnTimeInterval::finishUnserialization2(const std::vector& tinyInfoI, const std::vector& tinyInfoD) +{ + _start_iteration=tinyInfoI[0]; + _start_order=tinyInfoI[1]; + _end_iteration=tinyInfoI[2]; + _end_order=tinyInfoI[3]; + _time_tolerance=tinyInfoD[0]; + _start_time=tinyInfoD[1]; + _end_time=tinyInfoD[2]; +} + MEDCouplingConstOnTimeInterval::MEDCouplingConstOnTimeInterval(const MEDCouplingConstOnTimeInterval& other, bool deepCpy): 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) @@ -1438,6 +1547,7 @@ std::string MEDCouplingConstOnTimeInterval::getStringRepr() const std::ostringstream stream; 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"; + stream << "\nTime unit is : \"" << _time_unit << "\""; return stream.str(); } @@ -1992,6 +2102,43 @@ void MEDCouplingTwoTimeSteps::finishUnserialization(const std::vector& tiny _end_order=tinyInfoI[5]; } +/*! + * idem getTinySerializationIntInformation except that it is for multi field fetch + */ +void MEDCouplingTwoTimeSteps::getTinySerializationIntInformation2(std::vector& tinyInfo) const +{ + tinyInfo.resize(4); + tinyInfo[0]=_start_iteration; + tinyInfo[1]=_start_order; + tinyInfo[2]=_end_iteration; + tinyInfo[3]=_end_order; +} + +/*! + * idem getTinySerializationDbleInformation except that it is for multi field fetch + */ +void MEDCouplingTwoTimeSteps::getTinySerializationDbleInformation2(std::vector& tinyInfo) const +{ + tinyInfo.resize(3); + tinyInfo[0]=_time_tolerance; + tinyInfo[1]=_start_time; + tinyInfo[2]=_end_time; +} + +/*! + * idem finishUnserialization except that it is for multi field fetch + */ +void MEDCouplingTwoTimeSteps::finishUnserialization2(const std::vector& tinyInfoI, const std::vector& tinyInfoD) +{ + _start_iteration=tinyInfoI[0]; + _start_order=tinyInfoI[1]; + _end_iteration=tinyInfoI[2]; + _end_order=tinyInfoI[3]; + _time_tolerance=tinyInfoD[0]; + _start_time=tinyInfoD[1]; + _end_time=tinyInfoD[2]; +} + std::vector< const DataArrayDouble *> MEDCouplingTwoTimeSteps::getArraysForTime(double time) const throw(INTERP_KERNEL::Exception) { if(time>_start_time-_time_tolerance && time<_end_time+_time_tolerance) @@ -2026,6 +2173,7 @@ std::string MEDCouplingLinearTime::getStringRepr() const std::ostringstream stream; 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"; + stream << "Time unit is : \"" << _time_unit << "\""; return stream.str(); } diff --git a/src/MEDCoupling/MEDCouplingTimeDiscretization.hxx b/src/MEDCoupling/MEDCouplingTimeDiscretization.hxx index de9fff53a..aa5e4ccd9 100644 --- a/src/MEDCoupling/MEDCouplingTimeDiscretization.hxx +++ b/src/MEDCoupling/MEDCouplingTimeDiscretization.hxx @@ -40,6 +40,8 @@ namespace ParaMEDMEM public: void updateTime(); static MEDCouplingTimeDiscretization *New(TypeOfTimeDiscretization type); + void setTimeUnit(const char *unit) { _time_unit=unit; } + const char *getTimeUnit() const { return _time_unit.c_str(); } virtual void copyTinyAttrFrom(const MEDCouplingTimeDiscretization& other); virtual void copyTinyStringsFrom(const MEDCouplingTimeDiscretization& other); virtual void checkCoherency() const throw(INTERP_KERNEL::Exception); @@ -50,8 +52,7 @@ namespace ParaMEDMEM virtual bool areCompatibleForMeld(const MEDCouplingTimeDiscretization *other) const; virtual bool isEqual(const MEDCouplingTimeDiscretization *other, double prec) const; virtual bool isEqualWithoutConsideringStr(const MEDCouplingTimeDiscretization *other, double prec) const; - virtual MEDCouplingTimeDiscretization *buildNewTimeReprFromThis(const MEDCouplingTimeDiscretization *other, - TypeOfTimeDiscretization type, bool deepCpy) const; + virtual MEDCouplingTimeDiscretization *buildNewTimeReprFromThis(TypeOfTimeDiscretization type, bool deepCpy) const; virtual std::string getStringRepr() const = 0; virtual TypeOfTimeDiscretization getEnum() const = 0; virtual MEDCouplingTimeDiscretization *aggregate(const MEDCouplingTimeDiscretization *other) const = 0; @@ -74,6 +75,9 @@ namespace ParaMEDMEM virtual void getTinySerializationStrInformation(std::vector& tinyInfo) const; virtual void resizeForUnserialization(const std::vector& tinyInfoI, std::vector& arrays); virtual void finishUnserialization(const std::vector& tinyInfoI, const std::vector& tinyInfoD, const std::vector& tinyInfoS); + virtual void getTinySerializationIntInformation2(std::vector& tinyInfo) const = 0; + virtual void getTinySerializationDbleInformation2(std::vector& tinyInfo) const = 0; + virtual void finishUnserialization2(const std::vector& tinyInfoI, const std::vector& tinyInfoD) = 0; virtual MEDCouplingTimeDiscretization *performCpy(bool deepCpy) const = 0; void setTimeTolerance(double val) { _time_tolerance=val; } double getTimeTolerance() const { return _time_tolerance; } @@ -132,6 +136,7 @@ namespace ParaMEDMEM // virtual ~MEDCouplingTimeDiscretization(); protected: + std::string _time_unit; double _time_tolerance; DataArrayDouble *_array; protected: @@ -186,6 +191,9 @@ namespace ParaMEDMEM 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 iteration, int order, double *value) const throw(INTERP_KERNEL::Exception); + void getTinySerializationIntInformation2(std::vector& tinyInfo) const; + void getTinySerializationDbleInformation2(std::vector& tinyInfo) const; + void finishUnserialization2(const std::vector& tinyInfoI, const std::vector& tinyInfoD); public: static const TypeOfTimeDiscretization DISCRETIZATION=NO_TIME; static const char REPR[]; @@ -227,6 +235,9 @@ namespace ParaMEDMEM void getTinySerializationIntInformation(std::vector& tinyInfo) const; void getTinySerializationDbleInformation(std::vector& tinyInfo) const; void finishUnserialization(const std::vector& tinyInfoI, const std::vector& tinyInfoD, const std::vector& tinyInfoS); + void getTinySerializationIntInformation2(std::vector& tinyInfo) const; + void getTinySerializationDbleInformation2(std::vector& tinyInfo) const; + void finishUnserialization2(const std::vector& tinyInfoI, const std::vector& tinyInfoD); MEDCouplingTimeDiscretization *performCpy(bool deepCpy) const; void checkNoTimePresence() const throw(INTERP_KERNEL::Exception); void checkTimePresence(double time) const throw(INTERP_KERNEL::Exception); @@ -265,6 +276,9 @@ namespace ParaMEDMEM void getTinySerializationIntInformation(std::vector& tinyInfo) const; void getTinySerializationDbleInformation(std::vector& tinyInfo) const; void finishUnserialization(const std::vector& tinyInfoI, const std::vector& tinyInfoD, const std::vector& tinyInfoS); + void getTinySerializationIntInformation2(std::vector& tinyInfo) const; + void getTinySerializationDbleInformation2(std::vector& tinyInfo) const; + void finishUnserialization2(const std::vector& tinyInfoI, const std::vector& tinyInfoD); MEDCouplingTimeDiscretization *performCpy(bool deepCpy) const; bool areCompatible(const MEDCouplingTimeDiscretization *other) const; bool areStrictlyCompatible(const MEDCouplingTimeDiscretization *other) const; @@ -353,6 +367,9 @@ namespace ParaMEDMEM void getTinySerializationStrInformation(std::vector& tinyInfo) const; void resizeForUnserialization(const std::vector& tinyInfoI, std::vector& arrays); void finishUnserialization(const std::vector& tinyInfoI, const std::vector& tinyInfoD, const std::vector& tinyInfoS); + void getTinySerializationIntInformation2(std::vector& tinyInfo) const; + void getTinySerializationDbleInformation2(std::vector& tinyInfo) const; + void finishUnserialization2(const std::vector& tinyInfoI, const std::vector& tinyInfoD); std::vector< const DataArrayDouble *> getArraysForTime(double time) const throw(INTERP_KERNEL::Exception); void setArrays(const std::vector& arrays, TimeLabel *owner) throw(INTERP_KERNEL::Exception); protected: diff --git a/src/MEDCoupling/MEDCouplingUMesh.cxx b/src/MEDCoupling/MEDCouplingUMesh.cxx index b4f3f52e8..32a0d4e50 100644 --- a/src/MEDCoupling/MEDCouplingUMesh.cxx +++ b/src/MEDCoupling/MEDCouplingUMesh.cxx @@ -1423,6 +1423,7 @@ std::string MEDCouplingUMesh::simpleRepr() const static const char msg0[]="No coordinates specified !"; std::ostringstream ret; ret << "Unstructured mesh with name : \"" << getName() << "\"\n"; + ret << "Description of mesh : \"" << getDescription() << "\"\n"; ret << "Mesh dimension : " << _mesh_dim << "\nSpace dimension : "; if(_coords!=0) { @@ -3392,6 +3393,7 @@ MEDCouplingUMesh *MEDCouplingUMesh::keepSpecifiedCells(INTERP_KERNEL::Normalized return 0; } ret2->setName(getName()); + ret2->setDescription(getDescription()); return ret2; } diff --git a/src/MEDCoupling/Makefile.am b/src/MEDCoupling/Makefile.am index 8cd254889..37058285b 100644 --- a/src/MEDCoupling/Makefile.am +++ b/src/MEDCoupling/Makefile.am @@ -37,7 +37,8 @@ MEDCouplingFieldDiscretization.hxx MEDCouplingPointSet.hxx MEDCouplingPointSet.t MEDCouplingUMeshDesc.hxx MEDCouplingNatureOfField.hxx MEDCouplingFieldTemplate.hxx \ MEDCouplingNormalizedCartesianMesh.hxx MEDCouplingNormalizedCartesianMesh.txx \ MEDCouplingRemapper.hxx MEDCouplingExtrudedMesh.hxx MEDCouplingGaussLocalization.hxx \ -MEDCouplingAutoRefCountObjectPtr.hxx +MEDCouplingAutoRefCountObjectPtr.hxx MEDCouplingMultiFields.hxx MEDCouplingDefinitionTime.hxx \ +MEDCouplingFieldOverTime.hxx # Libraries targets @@ -48,7 +49,8 @@ dist_libmedcoupling_la_SOURCES = \ MEDCouplingFieldDiscretization.cxx MEDCouplingRefCountObject.cxx \ MEDCouplingPointSet.cxx MEDCouplingUMeshDesc.cxx MEDCouplingFieldTemplate.cxx \ MEDCouplingExtrudedMesh.cxx MEDCouplingMesh.cxx MEDCouplingGaussLocalization.cxx \ - MEDCouplingNatureOfField.cxx + MEDCouplingNatureOfField.cxx MEDCouplingMultiFields.cxx \ + MEDCouplingDefinitionTime.cxx MEDCouplingFieldOverTime.cxx libmedcoupling_la_LDFLAGS= @@ -93,4 +95,8 @@ EXTRA_DIST += \ MEDCouplingNatureOfField.hxx \ MEDCouplingRemapper.hxx \ MEDCouplingExtrudedMesh.hxx \ - MEDCouplingGaussLocalization.hxx + MEDCouplingGaussLocalization.hxx \ + MEDCouplingMultiFields.hxx \ + MEDCouplingFieldTemplate.hxx \ + MEDCouplingDefinitionTime.hxx \ + MEDCouplingFieldOverTime.hxx diff --git a/src/MEDCoupling/Test/MEDCouplingBasicsTest.hxx b/src/MEDCoupling/Test/MEDCouplingBasicsTest.hxx index 86166d27b..24a2190ac 100644 --- a/src/MEDCoupling/Test/MEDCouplingBasicsTest.hxx +++ b/src/MEDCoupling/Test/MEDCouplingBasicsTest.hxx @@ -28,6 +28,8 @@ namespace ParaMEDMEM { class MEDCouplingUMesh; + class MEDCouplingFieldDouble; + class MEDCouplingMultiFields; class MEDCouplingBasicsTest : public CppUnit::TestFixture { @@ -128,6 +130,7 @@ namespace ParaMEDMEM CPPUNIT_TEST( testFillFromAnalytic3 ); CPPUNIT_TEST( testFieldDoubleOpEqual1 ); CPPUNIT_TEST( testAreaBary3D2 ); + //MEDCouplingBasicsTest3.cxx CPPUNIT_TEST( testGetMeasureFieldCMesh1 ); CPPUNIT_TEST( testFieldDoubleZipCoords1 ); CPPUNIT_TEST( testFieldDoubleZipConnectivity1 ); @@ -186,6 +189,10 @@ namespace ParaMEDMEM CPPUNIT_TEST( testDAIAggregateMulti1 ); CPPUNIT_TEST( testMergeUMeshes2 ); CPPUNIT_TEST( testBuild0DMeshFromCoords1 ); + //MEDCouplingBasicsTest4.cxx + CPPUNIT_TEST( testDescriptionInMeshTimeUnit1 ); + CPPUNIT_TEST( testMultiFields1 ); + CPPUNIT_TEST( testFieldOverTime1 ); //MEDCouplingBasicsTestInterp.cxx CPPUNIT_TEST( test2DInterpP0P0_1 ); CPPUNIT_TEST( test2DInterpP0P0PL_1 ); @@ -342,6 +349,7 @@ namespace ParaMEDMEM void testFillFromAnalytic3(); void testFieldDoubleOpEqual1(); void testAreaBary3D2(); + //MEDCouplingBasicsTest3.cxx void testGetMeasureFieldCMesh1(); void testFieldDoubleZipCoords1(); void testFieldDoubleZipConnectivity1(); @@ -400,6 +408,10 @@ namespace ParaMEDMEM void testDAIAggregateMulti1(); void testMergeUMeshes2(); void testBuild0DMeshFromCoords1(); + //MEDCouplingBasicsTest4.cxx + void testDescriptionInMeshTimeUnit1(); + void testMultiFields1(); + void testFieldOverTime1(); //MEDCouplingBasicsTestInterp.cxx void test2DInterpP0P0_1(); void test2DInterpP0P0PL_1(); @@ -493,6 +505,8 @@ namespace ParaMEDMEM static MEDCouplingUMesh *build2DTargetMesh_3(); static MEDCouplingUMesh *build3DTargetMesh_3(); static MEDCouplingUMesh *build2DTargetMesh_4(); + static MEDCouplingMultiFields *buildMultiFields_1(); + static std::vector buildMultiFields_2(); static double sumAll(const std::vector< std::map >& matrix); }; } diff --git a/src/MEDCoupling/Test/MEDCouplingBasicsTest0.cxx b/src/MEDCoupling/Test/MEDCouplingBasicsTest0.cxx index 3f7adf58a..9c94949d1 100644 --- a/src/MEDCoupling/Test/MEDCouplingBasicsTest0.cxx +++ b/src/MEDCoupling/Test/MEDCouplingBasicsTest0.cxx @@ -22,6 +22,7 @@ #include "MEDCouplingExtrudedMesh.hxx" #include "MEDCouplingFieldDouble.hxx" #include "MEDCouplingMemArray.hxx" +#include "MEDCouplingMultiFields.hxx" #include "MEDCouplingBasicsTestData1.hxx" @@ -842,6 +843,145 @@ MEDCouplingUMesh *MEDCouplingBasicsTest::build3DTargetMesh_3() return 0; } +MEDCouplingMultiFields *MEDCouplingBasicsTest::buildMultiFields_1() +{ + ParaMEDMEM::MEDCouplingUMesh *m1=build2DTargetMesh_1(); + m1->setName("m1"); + ParaMEDMEM::MEDCouplingUMesh *m2=build2DTargetMesh_1(); + m2->setName("m2"); + const double vals0[]={-0.7,-1.,-2.,-3.,-4.}; + const double vals1[]={0.,1.,2.,3.,4.,0.1,0.2,0.3,0.4}; + const double vals1_1[]={170.,171.,172.,173.,174.,170.1,170.2,170.3,170.4}; + const double vals2[]={5.,6.,7.,8.,9.}; + const double vals4[]={15.,16.,17.,18.,19.}; + // + ParaMEDMEM::DataArrayDouble *d0=ParaMEDMEM::DataArrayDouble::New(); d0->alloc(5,1); std::copy(vals0,vals0+5,d0->getPointer()); + ParaMEDMEM::DataArrayDouble *d1=ParaMEDMEM::DataArrayDouble::New(); d1->alloc(9,1); std::copy(vals1,vals1+9,d1->getPointer()); + ParaMEDMEM::DataArrayDouble *d1_1=ParaMEDMEM::DataArrayDouble::New(); d1_1->alloc(9,1); std::copy(vals1_1,vals1_1+9,d1_1->getPointer()); + ParaMEDMEM::DataArrayDouble *d2=ParaMEDMEM::DataArrayDouble::New(); d2->alloc(5,1); std::copy(vals2,vals2+5,d2->getPointer()); + ParaMEDMEM::DataArrayDouble *d4=ParaMEDMEM::DataArrayDouble::New(); d4->alloc(5,1); std::copy(vals4,vals4+5,d4->getPointer()); + // + d0->setName("d0"); d1->setName("d1"); d1_1->setName("d1_1"); d2->setName("d2"); d4->setName("d4"); + d0->setInfoOnComponent(0,"c1"); + d1->setInfoOnComponent(0,"c6"); + d1_1->setInfoOnComponent(0,"c9"); + d2->setInfoOnComponent(0,"c5"); + d4->setInfoOnComponent(0,"c7"); + // + ParaMEDMEM::MEDCouplingFieldDouble *f0=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::ONE_TIME); + f0->setMesh(m1); + f0->setArray(d0); + f0->setTime(0.2,5,6); + f0->setName("f0"); + ParaMEDMEM::MEDCouplingFieldDouble *f1=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_NODES,ParaMEDMEM::LINEAR_TIME); + f1->setMesh(m1); + std::vector d1s(2); d1s[0]=d1; d1s[1]=d1_1; + f1->setArrays(d1s); + f1->setStartTime(0.7,7,8); + f1->setEndTime(1.2,9,10); + f1->setName("f1"); + ParaMEDMEM::MEDCouplingFieldDouble *f2=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::CONST_ON_TIME_INTERVAL); + f2->setMesh(m2); + f2->setArray(d2); + f2->setTime(1.2,11,12); + f2->setEndTime(1.5,13,14); + f2->setName("f2"); + ParaMEDMEM::MEDCouplingFieldDouble *f3=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::ONE_TIME); + f3->setMesh(m1); + f3->setArray(d2); + f3->setTime(1.7,15,16); + f3->setName("f3"); + ParaMEDMEM::MEDCouplingFieldDouble *f4=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::NO_TIME); + f4->setMesh(m2); + f4->setArray(d4); + f4->setName("f4"); + // + std::vector fs(5); + fs[0]=f0; fs[1]=f1; fs[2]=f2; fs[3]=f3; fs[4]=f4; + ParaMEDMEM::MEDCouplingMultiFields *ret=ParaMEDMEM::MEDCouplingMultiFields::New(fs); + // + m1->decrRef(); + m2->decrRef(); + d0->decrRef(); + d1->decrRef(); + d1_1->decrRef(); + d2->decrRef(); + d4->decrRef(); + f0->decrRef(); + f1->decrRef(); + f2->decrRef(); + f3->decrRef(); + f4->decrRef(); + // + return ret; +} + +std::vector MEDCouplingBasicsTest::buildMultiFields_2() +{ + ParaMEDMEM::MEDCouplingUMesh *m1=build2DTargetMesh_1(); + m1->setName("m1"); + ParaMEDMEM::MEDCouplingUMesh *m2=build2DTargetMesh_1(); + m2->setName("m2"); + const double vals0[]={-0.7,-1.,-2.,-3.,-4.}; + const double vals1[]={0.,1.,2.,3.,4.}; + const double vals1_1[]={170.,171.,172.,173.,174.}; + const double vals2[]={5.,6.,7.,8.,9.}; + const double vals4[]={15.,16.,17.,18.,19.}; + // + ParaMEDMEM::DataArrayDouble *d0=ParaMEDMEM::DataArrayDouble::New(); d0->alloc(5,1); std::copy(vals0,vals0+5,d0->getPointer()); + ParaMEDMEM::DataArrayDouble *d1=ParaMEDMEM::DataArrayDouble::New(); d1->alloc(5,1); std::copy(vals1,vals1+5,d1->getPointer()); + ParaMEDMEM::DataArrayDouble *d1_1=ParaMEDMEM::DataArrayDouble::New(); d1_1->alloc(5,1); std::copy(vals1_1,vals1_1+5,d1_1->getPointer()); + ParaMEDMEM::DataArrayDouble *d2=ParaMEDMEM::DataArrayDouble::New(); d2->alloc(5,1); std::copy(vals2,vals2+5,d2->getPointer()); + ParaMEDMEM::DataArrayDouble *d4=ParaMEDMEM::DataArrayDouble::New(); d4->alloc(5,1); std::copy(vals4,vals4+5,d4->getPointer()); + // + d0->setName("d0"); d1->setName("d1"); d1_1->setName("d1_1"); d2->setName("d2"); d4->setName("d4"); + d0->setInfoOnComponent(0,"c1"); + d1->setInfoOnComponent(0,"c6"); + d1_1->setInfoOnComponent(0,"c9"); + d2->setInfoOnComponent(0,"c5"); + d4->setInfoOnComponent(0,"c7"); + // + ParaMEDMEM::MEDCouplingFieldDouble *f0=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::ONE_TIME); + f0->setMesh(m1); + f0->setArray(d0); + f0->setTime(0.2,5,6); + f0->setName("f0"); + ParaMEDMEM::MEDCouplingFieldDouble *f1=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::LINEAR_TIME); + f1->setMesh(m1); + std::vector d1s(2); d1s[0]=d1; d1s[1]=d1_1; + f1->setArrays(d1s); + f1->setStartTime(0.7,7,8); + f1->setEndTime(1.2,9,10); + f1->setName("f1"); + ParaMEDMEM::MEDCouplingFieldDouble *f2=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::CONST_ON_TIME_INTERVAL); + f2->setMesh(m2); + f2->setArray(d2); + f2->setTime(1.2,11,12); + f2->setEndTime(1.5,13,14); + f2->setName("f2"); + ParaMEDMEM::MEDCouplingFieldDouble *f3=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::ONE_TIME); + f3->setMesh(m1); + f3->setArray(d2); + f3->setTime(1.7,15,16); + f3->setName("f3"); + ParaMEDMEM::MEDCouplingFieldDouble *f4=ParaMEDMEM::MEDCouplingFieldDouble::New(ParaMEDMEM::ON_CELLS,ParaMEDMEM::NO_TIME); + f4->setMesh(m2); + f4->setArray(d4); + f4->setName("f4"); + // + std::vector fs(5); + fs[0]=f0; fs[1]=f1; fs[2]=f2; fs[3]=f3; fs[4]=f4; + m1->decrRef(); + m2->decrRef(); + d0->decrRef(); + d1->decrRef(); + d1_1->decrRef(); + d2->decrRef(); + d4->decrRef(); + // + return fs; +} + double MEDCouplingBasicsTest::sumAll(const std::vector< std::map >& matrix) { double ret=0.; diff --git a/src/MEDCoupling/Test/MEDCouplingBasicsTest2.cxx b/src/MEDCoupling/Test/MEDCouplingBasicsTest2.cxx index 86e66ba9c..2930e52fc 100644 --- a/src/MEDCoupling/Test/MEDCouplingBasicsTest2.cxx +++ b/src/MEDCoupling/Test/MEDCouplingBasicsTest2.cxx @@ -2217,2224 +2217,3 @@ void MEDCouplingBasicsTest::testAreaBary3D2() // mesh->decrRef(); } - -void MEDCouplingBasicsTest::testGetMeasureFieldCMesh1() -{ - MEDCouplingCMesh *m=MEDCouplingCMesh::New(); - DataArrayDouble *da=DataArrayDouble::New(); - const double discX[4]={2.3,3.4,5.8,10.2}; - const double discY[3]={12.3,23.4,45.8}; - const double discZ[5]={-0.7,1.2,1.25,2.13,2.67}; - da->alloc(4,1); - std::copy(discX,discX+4,da->getPointer()); - m->setCoordsAt(0,da); - da->decrRef(); - m->checkCoherency(); - CPPUNIT_ASSERT_EQUAL(4,m->getNumberOfNodes()); - CPPUNIT_ASSERT_EQUAL(3,m->getNumberOfCells()); - CPPUNIT_ASSERT_EQUAL(1,m->getSpaceDimension()); - MEDCouplingFieldDouble *f=m->getMeasureField(true); - CPPUNIT_ASSERT_EQUAL(3,f->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,f->getNumberOfComponents()); - const double expected1[3]={1.1,2.4,4.4}; - for(int i=0;i<3;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f->getIJ(i,0),1e-12); - f->decrRef(); - DataArrayDouble *coords=m->getCoordinatesAndOwner(); - CPPUNIT_ASSERT_EQUAL(4,coords->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,coords->getNumberOfComponents()); - for(int i=0;i<4;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(discX[i],coords->getIJ(i,0),1e-12); - coords->decrRef(); - coords=m->getBarycenterAndOwner(); - CPPUNIT_ASSERT_EQUAL(3,coords->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,coords->getNumberOfComponents()); - const double expected1_3[3]={2.85,4.6,8.}; - for(int i=0;i<3;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1_3[i],coords->getIJ(i,0),1e-12); - coords->decrRef(); - // - da=DataArrayDouble::New(); - da->alloc(3,1); - std::copy(discY,discY+3,da->getPointer()); - m->setCoordsAt(1,da); - da->decrRef(); - m->checkCoherency(); - CPPUNIT_ASSERT_EQUAL(12,m->getNumberOfNodes()); - CPPUNIT_ASSERT_EQUAL(6,m->getNumberOfCells()); - CPPUNIT_ASSERT_EQUAL(2,m->getSpaceDimension()); - f=m->getMeasureField(true); - CPPUNIT_ASSERT_EQUAL(6,f->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,f->getNumberOfComponents()); - const double expected2[6]={12.21,26.64,48.84,24.64,53.76,98.56}; - for(int i=0;i<6;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f->getIJ(i,0),1e-12); - f->decrRef(); - coords=m->getCoordinatesAndOwner(); - CPPUNIT_ASSERT_EQUAL(12,coords->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,coords->getNumberOfComponents()); - const double expected2_2[24]={2.3,12.3,3.4,12.3,5.8,12.3,10.2,12.3, 2.3,23.4,3.4,23.4,5.8,23.4,10.2,23.4, 2.3,45.8,3.4,45.8,5.8,45.8,10.2,45.8}; - for(int i=0;i<24;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2_2[i],coords->getIJ(0,i),1e-12); - coords->decrRef(); - coords=m->getBarycenterAndOwner(); - CPPUNIT_ASSERT_EQUAL(6,coords->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,coords->getNumberOfComponents()); - const double expected2_3[12]={2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6}; - for(int i=0;i<12;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2_3[i],coords->getIJ(0,i),1e-12); - coords->decrRef(); - // - da=DataArrayDouble::New(); - da->alloc(5,1); - std::copy(discZ,discZ+5,da->getPointer()); - m->setCoordsAt(2,da); - da->decrRef(); - m->checkCoherency(); - CPPUNIT_ASSERT_EQUAL(60,m->getNumberOfNodes()); - CPPUNIT_ASSERT_EQUAL(24,m->getNumberOfCells()); - CPPUNIT_ASSERT_EQUAL(3,m->getSpaceDimension()); - f=m->getMeasureField(true); - CPPUNIT_ASSERT_EQUAL(24,f->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,f->getNumberOfComponents()); - const double expected3[24]={23.199, 50.616, 92.796, 46.816, 102.144, 187.264, 0.6105, 1.332, 2.442, 1.232, 2.688, 4.928, 10.7448, 23.4432, 42.9792, 21.6832, 47.3088, 86.7328, 6.5934, 14.3856, 26.3736, 13.3056, 29.0304, 53.2224}; - for(int i=0;i<24;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[i],f->getIJ(i,0),1e-12); - f->decrRef(); - coords=m->getCoordinatesAndOwner(); - CPPUNIT_ASSERT_EQUAL(60,coords->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(3,coords->getNumberOfComponents()); - const double expected3_2[180]={ - 2.3,12.3,-0.7, 3.4,12.3,-0.7, 5.8,12.3,-0.7, 10.2,12.3,-0.7, 2.3,23.4,-0.7, 3.4,23.4,-0.7, 5.8,23.4,-0.7, 10.2,23.4,-0.7, 2.3,45.8,-0.7, 3.4,45.8,-0.7, 5.8,45.8,-0.7, 10.2,45.8,-0.7, - 2.3,12.3,1.2, 3.4,12.3,1.2, 5.8,12.3,1.2, 10.2,12.3,1.2, 2.3,23.4,1.2, 3.4,23.4,1.2, 5.8,23.4,1.2, 10.2,23.4,1.2, 2.3,45.8,1.2, 3.4,45.8,1.2, 5.8,45.8,1.2, 10.2,45.8,1.2, - 2.3,12.3,1.25, 3.4,12.3,1.25, 5.8,12.3,1.25, 10.2,12.3,1.25, 2.3,23.4,1.25, 3.4,23.4,1.25, 5.8,23.4,1.25, 10.2,23.4,1.25, 2.3,45.8,1.25, 3.4,45.8,1.25, 5.8,45.8,1.25, 10.2,45.8,1.25, - 2.3,12.3,2.13, 3.4,12.3,2.13, 5.8,12.3,2.13, 10.2,12.3,2.13, 2.3,23.4,2.13, 3.4,23.4,2.13, 5.8,23.4,2.13, 10.2,23.4,2.13, 2.3,45.8,2.13, 3.4,45.8,2.13, 5.8,45.8,2.13, 10.2,45.8,2.13, - 2.3,12.3,2.67, 3.4,12.3,2.67, 5.8,12.3,2.67, 10.2,12.3,2.67, 2.3,23.4,2.67, 3.4,23.4,2.67, 5.8,23.4,2.67, 10.2,23.4,2.67, 2.3,45.8,2.67, 3.4,45.8,2.67, 5.8,45.8,2.67, 10.2,45.8,2.67 - }; - for(int i=0;i<180;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3_2[i],coords->getIJ(0,i),1e-12); - coords->decrRef(); - coords=m->getBarycenterAndOwner(); - CPPUNIT_ASSERT_EQUAL(24,coords->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(3,coords->getNumberOfComponents()); - const double expected3_3[72]={ - 2.85,17.85,0.25,4.6,17.85,0.25,8.,17.85,0.25, 2.85,34.6,0.25,4.6,34.6,0.25,8.,34.6,0.25, - 2.85,17.85,1.225,4.6,17.85,1.225,8.,17.85,1.225, 2.85,34.6,1.225,4.6,34.6,1.225,8.,34.6,1.225, - 2.85,17.85,1.69,4.6,17.85,1.69,8.,17.85,1.69, 2.85,34.6,1.69,4.6,34.6,1.69,8.,34.6,1.69, - 2.85,17.85,2.4,4.6,17.85,2.4,8.,17.85,2.4, 2.85,34.6,2.4,4.6,34.6,2.4,8.,34.6,2.4 - }; - for(int i=0;i<72;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3_3[i],coords->getIJ(0,i),1e-12); - coords->decrRef(); - // - m->decrRef(); -} - -void MEDCouplingBasicsTest::testFieldDoubleZipCoords1() -{ - MEDCouplingUMesh *m=build2DTargetMeshMergeNode_1(); - MEDCouplingFieldDouble *f=m->fillFromAnalytic(ON_NODES,2,"x*2."); - f->getArray()->setInfoOnComponent(0,"titi"); - f->getArray()->setInfoOnComponent(1,"tutu"); - f->checkCoherency(); - CPPUNIT_ASSERT_EQUAL(18,f->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,f->getNumberOfComponents()); - const double expected1[36]={-0.6, -0.6, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 0.4, 0.4}; - for(int i=0;i<36;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f->getIJ(0,i),1e-12); - CPPUNIT_ASSERT(f->zipCoords()); - f->checkCoherency(); - const double expected2[30]={-0.6, -0.6, 1.4, 1.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 0.4, 0.4}; - for(int i=0;i<30;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f->getIJ(0,i),1e-12); - CPPUNIT_ASSERT(!f->zipCoords()); - f->checkCoherency(); - for(int i=0;i<30;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f->getIJ(0,i),1e-12); - CPPUNIT_ASSERT(std::string(f->getArray()->getInfoOnComponent(0))=="titi"); - CPPUNIT_ASSERT(std::string(f->getArray()->getInfoOnComponent(1))=="tutu"); - f->decrRef(); - m->decrRef(); -} - -void MEDCouplingBasicsTest::testFieldDoubleZipConnectivity1() -{ - MEDCouplingUMesh *m1=build2DTargetMesh_1(); - MEDCouplingUMesh *m2=build2DTargetMesh_1(); - const int cells1[3]={2,3,4}; - MEDCouplingPointSet *m3_1=m2->buildPartOfMySelf(cells1,cells1+3,true); - MEDCouplingUMesh *m3=dynamic_cast(m3_1); - CPPUNIT_ASSERT(m3); - m2->decrRef(); - MEDCouplingUMesh *m4=build2DSourceMesh_1(); - MEDCouplingUMesh *m5=MEDCouplingUMesh::MergeUMeshes(m1,m3); - m1->decrRef(); - m3->decrRef(); - MEDCouplingUMesh *m6=MEDCouplingUMesh::MergeUMeshes(m5,m4); - m4->decrRef(); - m5->decrRef(); - // - CPPUNIT_ASSERT_EQUAL(10,m6->getNumberOfCells()); - CPPUNIT_ASSERT_EQUAL(22,m6->getNumberOfNodes()); - bool areNodesMerged; - int newNbOfNodes; - DataArrayInt *arr=m6->mergeNodes(1e-13,areNodesMerged,newNbOfNodes); - CPPUNIT_ASSERT_EQUAL(9,m6->getNumberOfNodes()); - arr->decrRef(); - MEDCouplingFieldDouble *f=m6->fillFromAnalytic(ON_CELLS,2,"x"); - MEDCouplingFieldDouble *f2=m6->fillFromAnalytic(ON_NODES,2,"x"); - CPPUNIT_ASSERT_EQUAL(10,f->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,f->getNumberOfComponents()); - const double expected1[20]={-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321, - -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45, - 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326}; - for(int i=0;i<20;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f->getIJ(0,i),1e-12); - f->getArray()->setInfoOnComponent(0,"titi"); - f->getArray()->setInfoOnComponent(1,"tutu"); - f->checkCoherency(); - CPPUNIT_ASSERT(f->zipConnectivity(0)); - const double expected2[14]={-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321, - -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326}; - CPPUNIT_ASSERT_EQUAL(7,f->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,f->getNumberOfComponents()); - for(int i=0;i<14;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f->getIJ(0,i),1e-12); - CPPUNIT_ASSERT(std::string(f->getArray()->getInfoOnComponent(0))=="titi"); - CPPUNIT_ASSERT(std::string(f->getArray()->getInfoOnComponent(1))=="tutu"); - CPPUNIT_ASSERT(!f->zipConnectivity(0)); - f->decrRef(); - // - const double expected3[18]={-0.3, -0.3, 0.2, 0.2, 0.7, 0.7, -0.3, -0.3, 0.2, 0.2, 0.7, 0.7, - -0.3, -0.3, 0.2, 0.2, 0.7, 0.7}; - CPPUNIT_ASSERT_EQUAL(9,f2->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,f2->getNumberOfComponents()); - for(int i=0;i<18;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[i],f2->getIJ(0,i),1e-12); - CPPUNIT_ASSERT(f2->zipConnectivity(0)); - CPPUNIT_ASSERT_EQUAL(9,f2->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,f2->getNumberOfComponents()); - for(int i=0;i<18;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[i],f2->getIJ(0,i),1e-12); - f2->decrRef(); - // - m6->decrRef(); -} - -void MEDCouplingBasicsTest::testDaDoubleRenumber1() -{ - DataArrayDouble *a=DataArrayDouble::New(); - a->alloc(7,2); - a->setInfoOnComponent(0,"toto"); - a->setInfoOnComponent(1,"tata"); - const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; - std::copy(arr1,arr1+14,a->getPointer()); - // - const int arr2[7]={3,1,0,6,5,4,2}; - DataArrayDouble *b=a->renumber(arr2); - CPPUNIT_ASSERT_EQUAL(7,b->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); - CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(0))=="toto"); - CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(1))=="tata"); - const double expected1[14]={3.1, 13.1, 2.1, 12.1, 7.1, 17.1, 1.1, 11.1, 6.1, 16.1, 5.1, 15.1, 4.1, 14.1}; - for(int i=0;i<14;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); - b->decrRef(); - a->decrRef(); - // - DataArrayInt *c=DataArrayInt::New(); - c->alloc(7,2); - c->setInfoOnComponent(0,"toto"); - c->setInfoOnComponent(1,"tata"); - const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; - std::copy(arr3,arr3+14,c->getPointer()); - DataArrayInt *d=c->renumber(arr2); - CPPUNIT_ASSERT_EQUAL(7,d->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,d->getNumberOfComponents()); - CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(0))=="toto"); - CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(1))=="tata"); - const int expected2[14]={3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14}; - for(int i=0;i<14;i++) - CPPUNIT_ASSERT_EQUAL(expected2[i],d->getIJ(0,i)); - c->decrRef(); - d->decrRef(); -} - -void MEDCouplingBasicsTest::testDaDoubleRenumberAndReduce1() -{ - DataArrayDouble *a=DataArrayDouble::New(); - a->alloc(7,2); - a->setInfoOnComponent(0,"toto"); - a->setInfoOnComponent(1,"tata"); - const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; - std::copy(arr1,arr1+14,a->getPointer()); - // - const int arr2[7]={2,-1,1,-1,0,4,3}; - DataArrayDouble *b=a->renumberAndReduce(arr2,5); - CPPUNIT_ASSERT_EQUAL(5,b->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); - CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(0))=="toto"); - CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(1))=="tata"); - const double expected1[10]={5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1}; - for(int i=0;i<10;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); - b->decrRef(); - a->decrRef(); - // - DataArrayInt *c=DataArrayInt::New(); - c->alloc(7,2); - c->setInfoOnComponent(0,"toto"); - c->setInfoOnComponent(1,"tata"); - const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; - std::copy(arr3,arr3+14,c->getPointer()); - DataArrayInt *d=c->renumberAndReduce(arr2,5); - CPPUNIT_ASSERT_EQUAL(5,d->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,d->getNumberOfComponents()); - CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(0))=="toto"); - CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(1))=="tata"); - const int expected2[10]={5,15,3,13,1,11,7,17,6,16}; - for(int i=0;i<10;i++) - CPPUNIT_ASSERT_EQUAL(expected2[i],d->getIJ(0,i)); - c->decrRef(); - d->decrRef(); -} - -void MEDCouplingBasicsTest::testDaDoubleRenumberInPlace1() -{ - DataArrayDouble *a=DataArrayDouble::New(); - a->alloc(7,2); - const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; - std::copy(arr1,arr1+14,a->getPointer()); - // - const int arr2[7]={3,1,0,6,5,4,2}; - a->renumberInPlace(arr2); - CPPUNIT_ASSERT_EQUAL(7,a->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,a->getNumberOfComponents()); - const double expected1[14]={3.1, 13.1, 2.1, 12.1, 7.1, 17.1, 1.1, 11.1, 6.1, 16.1, 5.1, 15.1, 4.1, 14.1}; - for(int i=0;i<14;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],a->getIJ(0,i),1e-14); - a->decrRef(); - // - DataArrayInt *c=DataArrayInt::New(); - c->alloc(7,2); - const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; - std::copy(arr3,arr3+14,c->getPointer()); - c->renumberInPlace(arr2); - CPPUNIT_ASSERT_EQUAL(7,c->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,c->getNumberOfComponents()); - const int expected2[14]={3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14}; - for(int i=0;i<14;i++) - CPPUNIT_ASSERT_EQUAL(expected2[i],c->getIJ(0,i)); - c->decrRef(); -} - -void MEDCouplingBasicsTest::testDaDoubleRenumberR1() -{ - DataArrayDouble *a=DataArrayDouble::New(); - a->alloc(7,2); - a->setInfoOnComponent(0,"toto"); - a->setInfoOnComponent(1,"tata"); - const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; - std::copy(arr1,arr1+14,a->getPointer()); - // - const int arr2[7]={3,1,0,6,5,4,2}; - DataArrayDouble *b=a->renumberR(arr2); - CPPUNIT_ASSERT_EQUAL(7,b->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); - CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(0))=="toto"); - CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(1))=="tata"); - const double expected1[14]={4.1, 14.1, 2.1, 12.1, 1.1, 11.1, 7.1, 17.1, 6.1, 16.1, 5.1, 15.1, 3.1, 13.1}; - for(int i=0;i<14;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); - b->decrRef(); - a->decrRef(); - // - DataArrayInt *c=DataArrayInt::New(); - c->alloc(7,2); - c->setInfoOnComponent(0,"toto"); - c->setInfoOnComponent(1,"tata"); - const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; - std::copy(arr3,arr3+14,c->getPointer()); - DataArrayInt *d=c->renumberR(arr2); - CPPUNIT_ASSERT_EQUAL(7,d->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,d->getNumberOfComponents()); - CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(0))=="toto"); - CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(1))=="tata"); - const int expected2[14]={4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13}; - for(int i=0;i<14;i++) - CPPUNIT_ASSERT_EQUAL(expected2[i],d->getIJ(0,i)); - c->decrRef(); - d->decrRef(); -} - -void MEDCouplingBasicsTest::testDaDoubleRenumberInPlaceR1() -{ - DataArrayDouble *a=DataArrayDouble::New(); - a->alloc(7,2); - const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; - std::copy(arr1,arr1+14,a->getPointer()); - // - const int arr2[7]={3,1,0,6,5,4,2}; - a->renumberInPlaceR(arr2); - CPPUNIT_ASSERT_EQUAL(7,a->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,a->getNumberOfComponents()); - const double expected1[14]={4.1, 14.1, 2.1, 12.1, 1.1, 11.1, 7.1, 17.1, 6.1, 16.1, 5.1, 15.1, 3.1, 13.1}; - for(int i=0;i<14;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],a->getIJ(0,i),1e-14); - a->decrRef(); - // - DataArrayInt *c=DataArrayInt::New(); - c->alloc(7,2); - const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; - std::copy(arr3,arr3+14,c->getPointer()); - c->renumberInPlaceR(arr2); - CPPUNIT_ASSERT_EQUAL(7,c->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,c->getNumberOfComponents()); - const int expected2[14]={4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13}; - for(int i=0;i<14;i++) - CPPUNIT_ASSERT_EQUAL(expected2[i],c->getIJ(0,i)); - c->decrRef(); -} - -void MEDCouplingBasicsTest::testDaDoubleSelectByTupleId1() -{ - DataArrayDouble *a=DataArrayDouble::New(); - a->alloc(7,2); - a->setInfoOnComponent(0,"toto"); - a->setInfoOnComponent(1,"tata"); - const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; - std::copy(arr1,arr1+14,a->getPointer()); - // - const int arr2[7]={4,2,0,6,5}; - DataArrayDouble *b=a->selectByTupleId(arr2,arr2+5); - CPPUNIT_ASSERT_EQUAL(5,b->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); - CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(0))=="toto"); - CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(1))=="tata"); - const double expected1[10]={5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1}; - for(int i=0;i<10;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); - b->decrRef(); - a->decrRef(); - // - DataArrayInt *c=DataArrayInt::New(); - c->alloc(7,2); - c->setInfoOnComponent(0,"toto"); - c->setInfoOnComponent(1,"tata"); - const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; - std::copy(arr3,arr3+14,c->getPointer()); - DataArrayInt *d=c->selectByTupleId(arr2,arr2+5); - CPPUNIT_ASSERT_EQUAL(5,d->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,d->getNumberOfComponents()); - CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(0))=="toto"); - CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(1))=="tata"); - const int expected2[10]={5,15,3,13,1,11,7,17,6,16}; - for(int i=0;i<10;i++) - CPPUNIT_ASSERT_EQUAL(expected2[i],d->getIJ(0,i)); - c->decrRef(); - d->decrRef(); -} - -void MEDCouplingBasicsTest::testDaDoubleGetMinMaxValues1() -{ - DataArrayDouble *a=DataArrayDouble::New(); - a->alloc(9,1); - const double arr1[9]={2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56}; - std::copy(arr1,arr1+9,a->getPointer()); - int where; - double m=a->getMaxValue(where); - CPPUNIT_ASSERT_EQUAL(1,where); - CPPUNIT_ASSERT_DOUBLES_EQUAL(4.56,m,1e-12); - DataArrayInt *ws; - m=a->getMaxValue2(ws); - CPPUNIT_ASSERT_DOUBLES_EQUAL(4.56,m,1e-12); - CPPUNIT_ASSERT_EQUAL(3,ws->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,ws->getNumberOfComponents()); - const int expected1[3]={1,4,8}; - for(int i=0;i<3;i++) - CPPUNIT_ASSERT_EQUAL(expected1[i],ws->getIJ(i,0)); - ws->decrRef(); - a->decrRef(); - a=DataArrayDouble::New(); - const double arr2[9]={-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56}; - a->alloc(9,1); - std::copy(arr2,arr2+9,a->getPointer()); - where=-2; - m=a->getMinValue(where); - CPPUNIT_ASSERT_EQUAL(1,where); - CPPUNIT_ASSERT_DOUBLES_EQUAL(-4.56,m,1e-12); - m=a->getMinValue2(ws); - CPPUNIT_ASSERT_DOUBLES_EQUAL(-4.56,m,1e-12); - CPPUNIT_ASSERT_EQUAL(3,ws->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,ws->getNumberOfComponents()); - for(int i=0;i<3;i++) - CPPUNIT_ASSERT_EQUAL(expected1[i],ws->getIJ(i,0)); - ws->decrRef(); - a->decrRef(); -} - -void MEDCouplingBasicsTest::testFieldDoubleGetMinMaxValues2() -{ - MEDCouplingUMesh *m1=0; - MEDCouplingUMesh *m2=build3DExtrudedUMesh_1(m1); - m1->decrRef(); - CPPUNIT_ASSERT_EQUAL(18,m2->getNumberOfCells()); - const double arr1[18]={8.71,4.53,-12.41,8.71,-8.71,8.7099,4.55,8.71,5.55,6.77,-1e-200,4.55,8.7099,0.,1.23,0.,2.22,8.71}; - MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME); - DataArrayDouble *a=DataArrayDouble::New(); - a->alloc(18,1); - std::copy(arr1,arr1+18,a->getPointer()); - f->setArray(a); - a->decrRef(); - f->setMesh(m2); - // - f->checkCoherency(); - double m=f->getMaxValue(); - CPPUNIT_ASSERT_DOUBLES_EQUAL(8.71,m,1e-12); - DataArrayInt *ws; - m=f->getMaxValue2(ws); - CPPUNIT_ASSERT_DOUBLES_EQUAL(8.71,m,1e-12); - CPPUNIT_ASSERT_EQUAL(4,ws->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,ws->getNumberOfComponents()); - const int expected1[4]={0,3,7,17}; - for(int i=0;i<4;i++) - CPPUNIT_ASSERT_EQUAL(expected1[i],ws->getIJ(i,0)); - ws->decrRef(); - // - const double arr2[18]={-8.71,-4.53,12.41,-8.71,8.71,-8.7099,-4.55,-8.71,-5.55,-6.77,1e-200,-4.55,-8.7099,0.,-1.23,0.,-2.22,-8.71}; - std::copy(arr2,arr2+18,a->getPointer()); - f->checkCoherency(); - m=f->getMinValue(); - CPPUNIT_ASSERT_DOUBLES_EQUAL(-8.71,m,1e-12); - m=f->getMinValue2(ws); - CPPUNIT_ASSERT_DOUBLES_EQUAL(-8.71,m,1e-12); - CPPUNIT_ASSERT_EQUAL(4,ws->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,ws->getNumberOfComponents()); - for(int i=0;i<4;i++) - CPPUNIT_ASSERT_EQUAL(expected1[i],ws->getIJ(i,0)); - ws->decrRef(); - // - f->decrRef(); - m2->decrRef(); -} - -void MEDCouplingBasicsTest::testBuildUnstructuredCMesh1() -{ - MEDCouplingCMesh *m=MEDCouplingCMesh::New(); - DataArrayDouble *da=DataArrayDouble::New(); - const double discX[4]={2.3,3.4,5.8,10.2}; - const double discY[3]={12.3,23.4,45.8}; - const double discZ[5]={-0.7,1.2,1.25,2.13,2.67}; - da->alloc(4,1); - std::copy(discX,discX+4,da->getPointer()); - m->setCoordsAt(0,da); - da->decrRef(); - m->checkCoherency(); - double pos=2.4; - CPPUNIT_ASSERT_EQUAL(0,m->getCellContainingPoint(&pos,1e-12)); - pos=3.7; - CPPUNIT_ASSERT_EQUAL(1,m->getCellContainingPoint(&pos,1e-12)); - pos=5.9; - CPPUNIT_ASSERT_EQUAL(2,m->getCellContainingPoint(&pos,1e-12)); - pos=10.3; - CPPUNIT_ASSERT_EQUAL(-1,m->getCellContainingPoint(&pos,1e-12)); - pos=1.3; - CPPUNIT_ASSERT_EQUAL(-1,m->getCellContainingPoint(&pos,1e-12)); - // - MEDCouplingUMesh *m2=m->buildUnstructured(); - m2->checkCoherency(); - MEDCouplingFieldDouble *f1=m->getMeasureField(false); - MEDCouplingFieldDouble *f2=m2->getMeasureField(false); - CPPUNIT_ASSERT_EQUAL(f1->getNumberOfTuples(),3); - CPPUNIT_ASSERT_EQUAL(f2->getNumberOfTuples(),3); - CPPUNIT_ASSERT_EQUAL(1,m2->getMeshDimension()); - CPPUNIT_ASSERT_EQUAL(1,m2->getSpaceDimension()); - for(int i=0;i<3;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(f1->getIJ(i,0),f2->getIJ(i,0),1e-10); - da=DataArrayDouble::New(); - da->alloc(3,1); - std::copy(discY,discY+3,da->getPointer()); - m->setCoordsAt(1,da); - da->decrRef(); - m2->decrRef(); - f1->decrRef(); - f2->decrRef(); - // - m2=m->buildUnstructured(); - m2->checkCoherency(); - f1=m->getMeasureField(false); - f2=m2->getMeasureField(false); - CPPUNIT_ASSERT_EQUAL(f1->getNumberOfTuples(),6); - CPPUNIT_ASSERT_EQUAL(f2->getNumberOfTuples(),6); - CPPUNIT_ASSERT_EQUAL(2,m2->getMeshDimension()); - CPPUNIT_ASSERT_EQUAL(2,m2->getSpaceDimension()); - for(int i=0;i<6;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(f1->getIJ(i,0),f2->getIJ(i,0),1e-10); - f1->decrRef(); - f2->decrRef(); - m2->decrRef(); - // - da=DataArrayDouble::New(); - da->alloc(5,1); - std::copy(discZ,discZ+5,da->getPointer()); - m->setCoordsAt(2,da); - da->decrRef(); - m2=m->buildUnstructured(); - m2->checkCoherency(); - f1=m->getMeasureField(false); - f2=m2->getMeasureField(false); - CPPUNIT_ASSERT_EQUAL(f1->getNumberOfTuples(),24); - CPPUNIT_ASSERT_EQUAL(f2->getNumberOfTuples(),24); - CPPUNIT_ASSERT_EQUAL(3,m2->getMeshDimension()); - CPPUNIT_ASSERT_EQUAL(3,m2->getSpaceDimension()); - for(int i=0;i<24;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(f1->getIJ(i,0),f2->getIJ(i,0),1e-10); - f1->decrRef(); - f2->decrRef(); - // - double pos1[3]={5.,30.,2.}; - CPPUNIT_ASSERT_EQUAL(16,m->getCellContainingPoint(pos1,1e-12)); - // - const double pt[3]={2.4,12.7,-3.4}; - m->scale(pt,3.7); - MEDCouplingUMesh *m3=m->buildUnstructured(); - m2->scale(pt,3.7); - CPPUNIT_ASSERT(m3->isEqual(m2,1e-12)); - m2->decrRef(); - m3->decrRef(); - // - m->decrRef(); -} - -void MEDCouplingBasicsTest::testDataArrayIntInvertO2NNO21() -{ - const int arr1[6]={2,0,4,1,5,3}; - DataArrayInt *da=DataArrayInt::New(); - da->alloc(6,1); - std::copy(arr1,arr1+6,da->getPointer()); - DataArrayInt *da2=da->invertArrayO2N2N2O(6); - CPPUNIT_ASSERT_EQUAL(6,da2->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,da2->getNumberOfComponents()); - const int expected1[6]={1,3,0,5,2,4}; - for(int i=0;i<6;i++) - CPPUNIT_ASSERT_EQUAL(expected1[i],da2->getIJ(i,0)); - DataArrayInt *da3=da2->invertArrayN2O2O2N(6); - for(int i=0;i<6;i++) - CPPUNIT_ASSERT_EQUAL(arr1[i],da3->getIJ(i,0)); - da3->decrRef(); - da2->decrRef(); - da->decrRef(); - // - const int arr2[10]={3,-1,5,4,-1,0,-1,1,2,-1}; - da=DataArrayInt::New(); - da->alloc(10,1); - std::copy(arr2,arr2+10,da->getPointer()); - da2=da->invertArrayO2N2N2O(6); - CPPUNIT_ASSERT_EQUAL(6,da2->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,da2->getNumberOfComponents()); - const int expected2[10]={5,7,8,0,3,2}; - for(int i=0;i<6;i++) - CPPUNIT_ASSERT_EQUAL(expected2[i],da2->getIJ(i,0)); - da3=da2->invertArrayN2O2O2N(10); - for(int i=0;i<10;i++) - CPPUNIT_ASSERT_EQUAL(arr2[i],da3->getIJ(i,0)); - da3->decrRef(); - da2->decrRef(); - da->decrRef(); -} - -void MEDCouplingBasicsTest::testKeepSetSelectedComponent1() -{ - const double arr1[20]={1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.}; - DataArrayDouble *a1=DataArrayDouble::New(); - a1->alloc(5,4); - std::copy(arr1,arr1+20,a1->getPointer()); - a1->setInfoOnComponent(0,"aaaa"); - a1->setInfoOnComponent(1,"bbbb"); - a1->setInfoOnComponent(2,"cccc"); - a1->setInfoOnComponent(3,"dddd"); - const int arr2[6]={1,2,1,2,0,0}; - std::vector arr2V(arr2,arr2+6); - DataArrayDouble *a2=a1->keepSelectedComponents(arr2V); - CPPUNIT_ASSERT_EQUAL(6,a2->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(5,a2->getNumberOfTuples()); - CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(0))=="bbbb"); - CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(1))=="cccc"); - CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(2))=="bbbb"); - CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(3))=="cccc"); - CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(4))=="aaaa"); - CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(5))=="aaaa"); - const double expected1[30]={2.,3.,2.,3.,1.,1., 12.,13.,12.,13.,11.,11., 22.,23.,22.,23.,21.,21., 32.,33.,32.,33.,31.,31., 42.,43.,42.,43.,41.,41.}; - for(int i=0;i<30;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],a2->getIJ(0,i),1e-14); - DataArrayInt *a3=a1->convertToIntArr(); - DataArrayInt *a4=a3->keepSelectedComponents(arr2V); - CPPUNIT_ASSERT_EQUAL(6,a4->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(5,a4->getNumberOfTuples()); - CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(0))=="bbbb"); - CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(1))=="cccc"); - CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(2))=="bbbb"); - CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(3))=="cccc"); - CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(4))=="aaaa"); - CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(5))=="aaaa"); - for(int i=0;i<30;i++) - CPPUNIT_ASSERT_EQUAL(int(expected1[i]),a4->getIJ(0,i)); - // setSelectedComponents - const int arr3[2]={3,2}; - std::vector arr3V(arr3,arr3+2); - DataArrayDouble *a5=a1->keepSelectedComponents(arr3V); - a5->setInfoOnComponent(0,"eeee"); - a5->setInfoOnComponent(1,"ffff"); - const int arr4[2]={1,2}; - std::vector arr4V(arr4,arr4+2); - a2->setSelectedComponents(a5,arr4V); - CPPUNIT_ASSERT_EQUAL(6,a2->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(5,a2->getNumberOfTuples()); - CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(0))=="bbbb"); - CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(1))=="eeee"); - CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(2))=="ffff"); - CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(3))=="cccc"); - CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(4))=="aaaa"); - CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(5))=="aaaa"); - const double expected2[30]={2.,4.,3.,3.,1.,1., 12.,14.,13.,13.,11.,11., 22.,24.,23.,23.,21.,21., 32.,34.,33.,33.,31.,31., 42.,44.,43.,43.,41.,41.}; - for(int i=0;i<30;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],a2->getIJ(0,i),1e-14); - DataArrayInt *a6=a5->convertToIntArr(); - a6->setInfoOnComponent(0,"eeee"); - a6->setInfoOnComponent(1,"ffff"); - a4->setSelectedComponents(a6,arr4V); - CPPUNIT_ASSERT_EQUAL(6,a4->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(5,a4->getNumberOfTuples()); - CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(0))=="bbbb"); - CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(1))=="eeee"); - CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(2))=="ffff"); - CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(3))=="cccc"); - CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(4))=="aaaa"); - CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(5))=="aaaa"); - for(int i=0;i<30;i++) - CPPUNIT_ASSERT_EQUAL(int(expected2[i]),a4->getIJ(0,i)); - // test of throw - const int arr5[3]={2,3,6}; - const int arr6[3]={2,7,5}; - const int arr7[4]={2,1,4,6}; - std::vector arr5V(arr5,arr5+3); - std::vector arr6V(arr6,arr6+3); - std::vector arr7V(arr7,arr7+4); - CPPUNIT_ASSERT_THROW(a2->keepSelectedComponents(arr5V),INTERP_KERNEL::Exception); - CPPUNIT_ASSERT_THROW(a2->keepSelectedComponents(arr6V),INTERP_KERNEL::Exception); - CPPUNIT_ASSERT_THROW(a2->setSelectedComponents(a1,arr7V),INTERP_KERNEL::Exception); - arr7V.resize(3); - CPPUNIT_ASSERT_THROW(a2->setSelectedComponents(a1,arr7V),INTERP_KERNEL::Exception); - // - a6->decrRef(); - a5->decrRef(); - a4->decrRef(); - a3->decrRef(); - a2->decrRef(); - a1->decrRef(); -} - -void MEDCouplingBasicsTest::testKeepSetSelectedComponent2() -{ - MEDCouplingUMesh *m1=build2DTargetMesh_1(); - const double arr1[20]={1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.}; - DataArrayDouble *a1=DataArrayDouble::New(); - a1->alloc(5,4); - std::copy(arr1,arr1+20,a1->getPointer()); - a1->setInfoOnComponent(0,"aaaa"); - a1->setInfoOnComponent(1,"bbbb"); - a1->setInfoOnComponent(2,"cccc"); - a1->setInfoOnComponent(3,"dddd"); - MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); - f1->setTime(2.3,4,5); - f1->setMesh(m1); - f1->setName("f1"); - f1->setArray(a1); - f1->checkCoherency(); - // - const int arr2[6]={1,2,1,2,0,0}; - std::vector arr2V(arr2,arr2+6); - MEDCouplingFieldDouble *f2=f1->keepSelectedComponents(arr2V); - CPPUNIT_ASSERT(f2->getMesh()==f1->getMesh()); - CPPUNIT_ASSERT(f2->getTimeDiscretization()==ONE_TIME); - int dt,it; - CPPUNIT_ASSERT_DOUBLES_EQUAL(2.3,f2->getTime(dt,it),1e-13); - CPPUNIT_ASSERT_EQUAL(4,dt); - CPPUNIT_ASSERT_EQUAL(5,it); - f2->checkCoherency(); - CPPUNIT_ASSERT_EQUAL(6,f2->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples()); - CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(0))=="bbbb"); - CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(1))=="cccc"); - CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(2))=="bbbb"); - CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(3))=="cccc"); - CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(4))=="aaaa"); - CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(5))=="aaaa"); - const double expected1[30]={2.,3.,2.,3.,1.,1., 12.,13.,12.,13.,11.,11., 22.,23.,22.,23.,21.,21., 32.,33.,32.,33.,31.,31., 42.,43.,42.,43.,41.,41.}; - for(int i=0;i<30;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f2->getIJ(0,i),1e-14); - //setSelectedComponents - const int arr3[2]={3,2}; - std::vector arr3V(arr3,arr3+2); - MEDCouplingFieldDouble *f5=f1->keepSelectedComponents(arr3V); - f5->setTime(6.7,8,9); - f5->getArray()->setInfoOnComponent(0,"eeee"); - f5->getArray()->setInfoOnComponent(1,"ffff"); - f5->checkCoherency(); - const int arr4[2]={1,2}; - std::vector arr4V(arr4,arr4+2); - f2->setSelectedComponents(f5,arr4V); - CPPUNIT_ASSERT_EQUAL(6,f2->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples()); - f2->checkCoherency(); - CPPUNIT_ASSERT_DOUBLES_EQUAL(2.3,f2->getTime(dt,it),1e-13); - CPPUNIT_ASSERT_EQUAL(4,dt); - CPPUNIT_ASSERT_EQUAL(5,it); - CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(0))=="bbbb"); - CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(1))=="eeee"); - CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(2))=="ffff"); - CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(3))=="cccc"); - CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(4))=="aaaa"); - CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(5))=="aaaa"); - const double expected2[30]={2.,4.,3.,3.,1.,1., 12.,14.,13.,13.,11.,11., 22.,24.,23.,23.,21.,21., 32.,34.,33.,33.,31.,31., 42.,44.,43.,43.,41.,41.}; - for(int i=0;i<30;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f2->getIJ(0,i),1e-14); - f5->decrRef(); - f1->decrRef(); - f2->decrRef(); - a1->decrRef(); - m1->decrRef(); -} - -void MEDCouplingBasicsTest::testDAIGetIdsEqual1() -{ - const int tab1[7]={5,-2,-4,-2,3,2,-2}; - DataArrayInt *da=DataArrayInt::New(); - da->alloc(7,1); - std::copy(tab1,tab1+7,da->getPointer()); - DataArrayInt *da2=da->getIdsEqual(-2); - CPPUNIT_ASSERT_EQUAL(3,da2->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,da2->getNumberOfComponents()); - const int expected1[3]={1,3,6}; - CPPUNIT_ASSERT(std::equal(expected1,expected1+3,da2->getConstPointer())); - da2->decrRef(); - da->decrRef(); -} - -void MEDCouplingBasicsTest::testDAIGetIdsEqualList1() -{ - const int tab1[7]={5,-2,-4,-2,3,2,-2}; - DataArrayInt *da=DataArrayInt::New(); - da->alloc(7,1); - std::copy(tab1,tab1+7,da->getPointer()); - const int tab2[3]={3,-2,0}; - std::vector tab2V(tab2,tab2+3); - DataArrayInt *da2=da->getIdsEqualList(tab2V); - CPPUNIT_ASSERT_EQUAL(4,da2->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,da2->getNumberOfComponents()); - const int expected1[4]={1,3,4,6}; - CPPUNIT_ASSERT(std::equal(expected1,expected1+4,da2->getConstPointer())); - da2->decrRef(); - da->decrRef(); -} - -void MEDCouplingBasicsTest::testDAFromNoInterlace1() -{ - const int tab1[15]={1,11,21,31,41,2,12,22,32,42,3,13,23,33,43}; - DataArrayInt *da=DataArrayInt::New(); - da->alloc(5,3); - std::copy(tab1,tab1+15,da->getPointer()); - DataArrayInt *da2=da->fromNoInterlace(); - const int expected1[15]={1,2,3,11,12,13,21,22,23,31,32,33,41,42,43}; - CPPUNIT_ASSERT_EQUAL(5,da2->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(3,da2->getNumberOfComponents());// it's not a bug. Avoid to have 1 million components ! - CPPUNIT_ASSERT(std::equal(expected1,expected1+15,da2->getConstPointer())); - DataArrayDouble *da3=da->convertToDblArr(); - DataArrayDouble *da4=da3->fromNoInterlace(); - CPPUNIT_ASSERT_EQUAL(5,da4->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(3,da4->getNumberOfComponents());// it's not a bug. Avoid to have 1 million components ! - for(int i=0;i<15;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL((double)expected1[i],da4->getIJ(0,i),1e-14); - da4->decrRef(); - da3->decrRef(); - da2->decrRef(); - da->decrRef(); -} - -void MEDCouplingBasicsTest::testDAToNoInterlace1() -{ - const int tab1[15]={1,2,3,11,12,13,21,22,23,31,32,33,41,42,43}; - DataArrayInt *da=DataArrayInt::New(); - da->alloc(5,3); - std::copy(tab1,tab1+15,da->getPointer()); - DataArrayInt *da2=da->toNoInterlace(); - const int expected1[15]={1,11,21,31,41,2,12,22,32,42,3,13,23,33,43}; - CPPUNIT_ASSERT_EQUAL(5,da2->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(3,da2->getNumberOfComponents());// it's not a bug. Avoid to have 1 million components ! - CPPUNIT_ASSERT(std::equal(expected1,expected1+15,da2->getConstPointer())); - DataArrayDouble *da3=da->convertToDblArr(); - DataArrayDouble *da4=da3->toNoInterlace(); - CPPUNIT_ASSERT_EQUAL(5,da4->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(3,da4->getNumberOfComponents());// it's not a bug. Avoid to have 1 million components ! - for(int i=0;i<15;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL((double)expected1[i],da4->getIJ(0,i),1e-14); - da4->decrRef(); - da3->decrRef(); - da2->decrRef(); - da->decrRef(); -} - -void MEDCouplingBasicsTest::testDAIsUniform1() -{ - const int tab1[5]={1,1,1,1,1}; - DataArrayInt *da=DataArrayInt::New(); - da->alloc(5,1); - std::copy(tab1,tab1+5,da->getPointer()); - CPPUNIT_ASSERT(da->isUniform(1)); - da->setIJ(2,0,2); - CPPUNIT_ASSERT(!da->isUniform(1)); - da->setIJ(2,0,1); - CPPUNIT_ASSERT(da->isUniform(1)); - DataArrayDouble *da2=da->convertToDblArr(); - CPPUNIT_ASSERT(da2->isUniform(1.,1e-12)); - da2->setIJ(1,0,1.+1.e-13); - CPPUNIT_ASSERT(da2->isUniform(1.,1e-12)); - da2->setIJ(1,0,1.+1.e-11); - CPPUNIT_ASSERT(!da2->isUniform(1.,1e-12)); - da2->decrRef(); - da->decrRef(); -} - -void MEDCouplingBasicsTest::testDADFromPolarToCart1() -{ - const double tab1[4]={2.,0.2,2.5,0.7}; - DataArrayDouble *da=DataArrayDouble::New(); - da->alloc(2,2); - std::copy(tab1,tab1+4,da->getPointer()); - DataArrayDouble *da2=da->fromPolarToCart(); - const double expected1[4]={1.9601331556824833,0.39733866159012243, 1.9121054682112213,1.6105442180942275}; - for(int i=0;i<4;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],da2->getIJ(0,i),1e-13); - da2->decrRef(); - da->decrRef(); -} - -void MEDCouplingBasicsTest::testDADFromCylToCart1() -{ - const double tab1[6]={2.,0.2,4.,2.5,0.7,9.}; - DataArrayDouble *da=DataArrayDouble::New(); - da->alloc(2,3); - std::copy(tab1,tab1+6,da->getPointer()); - DataArrayDouble *da2=da->fromCylToCart(); - const double expected1[6]={1.9601331556824833,0.39733866159012243,4., 1.9121054682112213,1.6105442180942275,9.}; - for(int i=0;i<6;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],da2->getIJ(0,i),1e-13); - da2->decrRef(); - da->decrRef(); -} - -void MEDCouplingBasicsTest::testDADFromSpherToCart1() -{ - const double tab1[6]={2.,0.2,0.3,2.5,0.7,0.8}; - DataArrayDouble *da=DataArrayDouble::New(); - da->alloc(2,3); - std::copy(tab1,tab1+6,da->getPointer()); - DataArrayDouble *da2=da->fromSpherToCart(); - const double expected1[6]={0.37959212195737485,0.11742160338765303,1.9601331556824833, 1.1220769624465328,1.1553337045129035,1.9121054682112213}; - for(int i=0;i<6;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],da2->getIJ(0,i),1e-13); - da2->decrRef(); - da->decrRef(); -} - -void MEDCouplingBasicsTest::testUnPolyze1() -{ - const int elts[8]={0,1,2,3,4,5,6,7}; - std::vector eltsV(elts,elts+8); - MEDCouplingUMesh *mesh=build3DTargetMesh_1(); - mesh->convertToPolyTypes(eltsV); - mesh->unPolyze(); - MEDCouplingUMesh *mesh2=build3DTargetMesh_1(); - mesh->checkCoherency(); - CPPUNIT_ASSERT(mesh->isEqual(mesh2,1e-12)); - mesh->convertToPolyTypes(eltsV); - CPPUNIT_ASSERT(!mesh->isEqual(mesh2,1e-12)); - mesh->getNodalConnectivity()->setIJ(0,6,10); - mesh->getNodalConnectivity()->setIJ(0,7,9); - mesh->getNodalConnectivity()->setIJ(0,8,12); - mesh->getNodalConnectivity()->setIJ(0,9,13); - mesh->unPolyze(); - CPPUNIT_ASSERT(mesh->isEqual(mesh2,1e-12)); - mesh->convertToPolyTypes(eltsV); - mesh->getNodalConnectivity()->setIJ(0,6,12); - mesh->getNodalConnectivity()->setIJ(0,7,13); - mesh->getNodalConnectivity()->setIJ(0,8,10); - mesh->getNodalConnectivity()->setIJ(0,9,9); - mesh->unPolyze(); - CPPUNIT_ASSERT(mesh->isEqual(mesh2,1e-12)); - mesh->convertToPolyTypes(eltsV); - mesh->getNodalConnectivity()->setIJ(0,6,12); - mesh->getNodalConnectivity()->setIJ(0,7,10); - mesh->getNodalConnectivity()->setIJ(0,8,13); - mesh->getNodalConnectivity()->setIJ(0,9,9); - mesh->unPolyze(); - CPPUNIT_ASSERT(!mesh->isEqual(mesh2,1e-12)); - mesh->decrRef(); - mesh2->decrRef(); - // Test for 2D mesh - mesh=build2DTargetMesh_1(); - mesh2=build2DTargetMesh_1(); - eltsV.resize(5); - mesh->convertToPolyTypes(eltsV); - CPPUNIT_ASSERT(!mesh->isEqual(mesh2,1e-12)); - mesh->unPolyze(); - CPPUNIT_ASSERT(mesh->isEqual(mesh2,1e-12)); - mesh->decrRef(); - mesh2->decrRef(); -} - -void MEDCouplingBasicsTest::testConvertDegeneratedCells1() -{ - MEDCouplingUMesh *mesh=build3DTargetMesh_1(); - int conn[32]={0,1,3,3,9,10,12,12, 0,1,3,4,9,9,9,9, 1,1,1,1,10,12,9,10, 10,11,12,9,1,1,1,1}; - mesh->allocateCells(4); - mesh->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn); - mesh->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+8); - mesh->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+16); - mesh->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+24); - mesh->finishInsertingCells(); - mesh->checkCoherency(); - CPPUNIT_ASSERT_EQUAL(4,mesh->getNumberOfCells()); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_HEXA8,mesh->getTypeOfCell(0)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_HEXA8,mesh->getTypeOfCell(1)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_HEXA8,mesh->getTypeOfCell(2)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_HEXA8,mesh->getTypeOfCell(3)); - MEDCouplingFieldDouble *f1=mesh->getMeasureField(true); - mesh->convertDegeneratedCells(); - mesh->checkCoherency(); - MEDCouplingFieldDouble *f2=mesh->getMeasureField(true); - CPPUNIT_ASSERT_EQUAL(4,mesh->getNumberOfCells()); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_PENTA6,mesh->getTypeOfCell(0)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_PYRA5,mesh->getTypeOfCell(1)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TETRA4,mesh->getTypeOfCell(2)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_PYRA5,mesh->getTypeOfCell(3)); - for(int i=0;i<4;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(f1->getArray()->getIJ(0,i),f2->getArray()->getIJ(0,i),1e-5); - f1->decrRef(); - f2->decrRef(); - mesh->decrRef(); -} - -void MEDCouplingBasicsTest::testGetNodeIdsNearPoints1() -{ - MEDCouplingUMesh *mesh=build2DTargetMesh_1(); - DataArrayDouble *coords=mesh->getCoords(); - DataArrayDouble *tmp=DataArrayDouble::New(); - tmp->alloc(3,2); - const double vals[6]={0.2,0.2,0.1,0.2,0.2,0.2}; - std::copy(vals,vals+6,tmp->getPointer()); - DataArrayDouble *tmp2=DataArrayDouble::Aggregate(coords,tmp); - tmp->decrRef(); - mesh->setCoords(tmp2); - tmp2->decrRef(); - const double pts[6]={0.2,0.2,0.1,0.3,-0.3,0.7}; - std::vector c=mesh->getNodeIdsNearPoint(pts,1e-7); - CPPUNIT_ASSERT_EQUAL(3,(int)c.size()); - CPPUNIT_ASSERT_EQUAL(4,c[0]); - CPPUNIT_ASSERT_EQUAL(9,c[1]); - CPPUNIT_ASSERT_EQUAL(11,c[2]); - c.clear(); - std::vector cI; - mesh->getNodeIdsNearPoints(pts,3,1e-7,c,cI); - CPPUNIT_ASSERT_EQUAL(4,(int)cI.size()); - CPPUNIT_ASSERT_EQUAL(4,(int)c.size()); - CPPUNIT_ASSERT_EQUAL(4,c[0]); - CPPUNIT_ASSERT_EQUAL(9,c[1]); - CPPUNIT_ASSERT_EQUAL(11,c[2]); - CPPUNIT_ASSERT_EQUAL(6,c[3]); - CPPUNIT_ASSERT_EQUAL(0,cI[0]); - CPPUNIT_ASSERT_EQUAL(3,cI[1]); - CPPUNIT_ASSERT_EQUAL(3,cI[2]); - CPPUNIT_ASSERT_EQUAL(4,cI[3]); - mesh->decrRef(); -} - -void MEDCouplingBasicsTest::testFieldCopyTinyAttrFrom1() -{ - MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); - f1->setName("f1"); - f1->setTimeTolerance(1.e-5); - f1->setDescription("f1Desc"); - f1->setTime(1.23,4,5); - MEDCouplingFieldDouble *f2=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); - f2->setName("f2"); - f2->setDescription("f2Desc"); - f2->setTime(6.78,9,10); - f2->setTimeTolerance(4.556e-12); - // - int dt,it; - f1->copyTinyAttrFrom(f2); - CPPUNIT_ASSERT_DOUBLES_EQUAL(4.556e-12,f1->getTimeTolerance(),1e-24); - CPPUNIT_ASSERT_DOUBLES_EQUAL(6.78,f1->getTime(dt,it),1e-12); - CPPUNIT_ASSERT_EQUAL(9,dt); - CPPUNIT_ASSERT_EQUAL(10,it); - CPPUNIT_ASSERT(std::string(f1->getName())=="f1");//name unchanged - CPPUNIT_ASSERT(std::string(f1->getDescription())=="f1Desc");//description unchanged - f1->decrRef(); - f2->decrRef(); - // - f1=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME); - f1->setName("f1"); - f1->setTimeTolerance(1.e-5); - f1->setDescription("f1Desc"); - f2=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME); - f2->setName("f2"); - f2->setDescription("f2Desc"); - f2->setTimeTolerance(4.556e-12); - // - f1->copyTinyAttrFrom(f2); - CPPUNIT_ASSERT_DOUBLES_EQUAL(4.556e-12,f1->getTimeTolerance(),1e-24); - CPPUNIT_ASSERT(std::string(f1->getName())=="f1");//name unchanged - CPPUNIT_ASSERT(std::string(f1->getDescription())=="f1Desc");//description unchanged - f1->decrRef(); - f2->decrRef(); - // - f1=MEDCouplingFieldDouble::New(ON_CELLS,CONST_ON_TIME_INTERVAL); - f1->setName("f1"); - f1->setTimeTolerance(1.e-5); - f1->setDescription("f1Desc"); - f1->setTime(1.23,4,5); - f1->setEndTime(5.43,2,1); - f2=MEDCouplingFieldDouble::New(ON_CELLS,CONST_ON_TIME_INTERVAL); - f2->setName("f2"); - f2->setDescription("f2Desc"); - f2->setTimeTolerance(4.556e-12); - f2->setTime(6.78,9,10); - f2->setEndTime(10.98,7,6); - // - f1->copyTinyAttrFrom(f2); - CPPUNIT_ASSERT_DOUBLES_EQUAL(4.556e-12,f1->getTimeTolerance(),1e-24); - CPPUNIT_ASSERT(std::string(f1->getName())=="f1");//name unchanged - CPPUNIT_ASSERT(std::string(f1->getDescription())=="f1Desc");//description unchanged - CPPUNIT_ASSERT_DOUBLES_EQUAL(6.78,f1->getTime(dt,it),1e-12); - CPPUNIT_ASSERT_EQUAL(9,dt); - CPPUNIT_ASSERT_EQUAL(10,it); - CPPUNIT_ASSERT_DOUBLES_EQUAL(10.98,f1->getEndTime(dt,it),1e-12); - CPPUNIT_ASSERT_EQUAL(7,dt); - CPPUNIT_ASSERT_EQUAL(6,it); - f1->decrRef(); - f2->decrRef(); - // - f1=MEDCouplingFieldDouble::New(ON_CELLS,LINEAR_TIME); - f1->setName("f1"); - f1->setTimeTolerance(1.e-5); - f1->setDescription("f1Desc"); - f1->setTime(1.23,4,5); - f1->setEndTime(5.43,2,1); - f2=MEDCouplingFieldDouble::New(ON_CELLS,LINEAR_TIME); - f2->setName("f2"); - f2->setDescription("f2Desc"); - f2->setTimeTolerance(4.556e-12); - f2->setTime(6.78,9,10); - f2->setEndTime(10.98,7,6); - // - f1->copyTinyAttrFrom(f2); - CPPUNIT_ASSERT_DOUBLES_EQUAL(4.556e-12,f1->getTimeTolerance(),1e-24); - CPPUNIT_ASSERT(std::string(f1->getName())=="f1");//name unchanged - CPPUNIT_ASSERT(std::string(f1->getDescription())=="f1Desc");//description unchanged - CPPUNIT_ASSERT_DOUBLES_EQUAL(6.78,f1->getTime(dt,it),1e-12); - CPPUNIT_ASSERT_EQUAL(9,dt); - CPPUNIT_ASSERT_EQUAL(10,it); - CPPUNIT_ASSERT_DOUBLES_EQUAL(10.98,f1->getEndTime(dt,it),1e-12); - CPPUNIT_ASSERT_EQUAL(7,dt); - CPPUNIT_ASSERT_EQUAL(6,it); - f1->decrRef(); - f2->decrRef(); -} - -/*! - * 1D -> 2D extrusion with rotation - */ -void MEDCouplingBasicsTest::testExtrudedMesh5() -{ - const double coo1[4]={0.,1.,2.,3.5}; - DataArrayDouble *a=DataArrayDouble::New(); - a->alloc(4,1); - std::copy(coo1,coo1+4,a->getPointer()); - MEDCouplingCMesh *b=MEDCouplingCMesh::New(); - b->setCoordsAt(0,a); - MEDCouplingUMesh *c=b->buildUnstructured(); - CPPUNIT_ASSERT_EQUAL(1,c->getSpaceDimension()); - c->changeSpaceDimension(2); - // - DataArrayDouble *d=DataArrayDouble::New(); - d->alloc(13,1); - d->iota(); - MEDCouplingCMesh *e=MEDCouplingCMesh::New(); - e->setCoordsAt(0,d); - MEDCouplingUMesh *f=e->buildUnstructured(); - DataArrayDouble *g=f->getCoords()->applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec"); - DataArrayDouble *h=g->fromPolarToCart(); - f->setCoords(h); - MEDCouplingUMesh *i=c->buildExtrudedMesh(f,1); - CPPUNIT_ASSERT_EQUAL(52,i->getNumberOfNodes()); - bool tmp2; - int tmp3; - DataArrayInt *tmp=i->mergeNodes(1e-9,tmp2,tmp3); - CPPUNIT_ASSERT(tmp2); - CPPUNIT_ASSERT_EQUAL(37,tmp3); - tmp->decrRef(); - i->convertDegeneratedCells(); - i->checkCoherency(); - CPPUNIT_ASSERT_EQUAL(36,i->getNumberOfCells()); - CPPUNIT_ASSERT_EQUAL(37,i->getNumberOfNodes()); - CPPUNIT_ASSERT_EQUAL(12,i->getNumberOfCellsWithType(INTERP_KERNEL::NORM_TRI3)); - CPPUNIT_ASSERT_EQUAL(24,i->getNumberOfCellsWithType(INTERP_KERNEL::NORM_QUAD4)); - const double expected1[3]={0.25,0.75,2.0625}; - MEDCouplingFieldDouble *j=i->getMeasureField(true); - for(int i=0;i<12;i++) - for(int k=0;k<3;k++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[k],j->getIJ(0,i*3+k),1e-10); - const double expected2[72]={0.62200846792814113, 0.16666666666681595, 1.4513530918323276, 0.38888888888923495, 2.6293994326053212, 0.7045454545460802, 0.45534180126145435, 0.45534180126150181, 1.0624642029433926, 1.0624642029435025, 1.9248539780597826, 1.9248539780599816, 0.16666666666661334, 0.62200846792815856, 0.38888888888876294, 1.4513530918323678, 0.70454545454522521, 2.629399432605394, -0.16666666666674007, 0.62200846792812436, -0.38888888888906142, 1.4513530918322881, -0.70454545454576778, 2.6293994326052488, -0.45534180126154766, 0.45534180126140844, -1.0624642029436118, 1.0624642029432834, -1.9248539780601803, 1.9248539780595841, -0.62200846792817499, 0.1666666666665495, -1.451353091832408, 0.388888888888613, -2.6293994326054668, 0.70454545454495332, -0.62200846792810593, -0.16666666666680507, -1.451353091832247, -0.38888888888921297, -2.6293994326051746, -0.70454545454604123, -0.45534180126135926, -0.45534180126159562, -1.0624642029431723, -1.0624642029437235, -1.9248539780593836, -1.9248539780603811, -0.1666666666664828, -0.62200846792819242, -0.38888888888846079, -1.4513530918324489, -0.70454545454467987, -2.6293994326055397, 0.16666666666687083, -0.62200846792808862, 0.38888888888936374, -1.4513530918322073, 0.70454545454631357, -2.6293994326051022, 0.45534180126164348, -0.45534180126131207, 1.0624642029438327, -1.0624642029430627, 1.9248539780605791, -1.9248539780591853, 0.62200846792821063, -0.16666666666641802, 1.4513530918324888, -0.38888888888831086, 2.6293994326056125, -0.70454545454440853}; - DataArrayDouble *m=i->getBarycenterAndOwner(); - for(int i=0;i<72;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],m->getIJ(0,i),1e-10); - // - m->decrRef(); - j->decrRef(); - i->decrRef(); - h->decrRef(); - g->decrRef(); - f->decrRef(); - e->decrRef(); - d->decrRef(); - c->decrRef(); - b->decrRef(); - a->decrRef(); -} - -/*! - * 1D -> 2D extrusion without rotation - */ -void MEDCouplingBasicsTest::testExtrudedMesh6() -{ - const double coo1[4]={0.,1.,2.,3.5}; - DataArrayDouble *a=DataArrayDouble::New(); - a->alloc(4,1); - std::copy(coo1,coo1+4,a->getPointer()); - MEDCouplingCMesh *b=MEDCouplingCMesh::New(); - b->setCoordsAt(0,a); - MEDCouplingUMesh *c=b->buildUnstructured(); - CPPUNIT_ASSERT_EQUAL(1,c->getSpaceDimension()); - c->changeSpaceDimension(2); - // - DataArrayDouble *d=DataArrayDouble::New(); - d->alloc(5,1); - d->iota(); - MEDCouplingCMesh *e=MEDCouplingCMesh::New(); - e->setCoordsAt(0,d); - MEDCouplingUMesh *f=e->buildUnstructured(); - DataArrayDouble *d2=f->getCoords()->applyFunc("x*x/2"); - f->setCoords(d2); - f->changeSpaceDimension(2); - // - const double center[2]={0.,0.}; - f->rotate(center,0,M_PI/3); - MEDCouplingUMesh *g=c->buildExtrudedMesh(f,0); - g->checkCoherency(); - const double expected1[]={ 0.4330127018922193, 0.4330127018922193, 0.649519052838329, 1.2990381056766578, 1.299038105676658, 1.948557158514987, 2.1650635094610955, 2.1650635094610964, 3.2475952641916446, 3.031088913245533, 3.0310889132455352, 4.546633369868303 }; - MEDCouplingFieldDouble *f1=g->getMeasureField(true); - for(int i=0;i<12;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f1->getIJ(0,i),1e-12); - - const double expected2[]={0.625, 0.21650635094610962, 1.625, 0.21650635094610959, 2.8750000000000004, 0.21650635094610965, 1.1250000000000002, 1.0825317547305482, 2.125, 1.0825317547305482, 3.3750000000000004, 1.0825317547305484, 2.125, 2.8145825622994254, 3.125, 2.8145825622994254, 4.375, 2.8145825622994254, 3.6250000000000009, 5.4126587736527414, 4.625, 5.4126587736527414, 5.875, 5.4126587736527414}; - DataArrayDouble *f2=g->getBarycenterAndOwner(); - for(int i=0;i<24;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f2->getIJ(0,i),1e-12); - // - f1->decrRef(); - f2->decrRef(); - g->decrRef(); - f->decrRef(); - e->decrRef(); - d->decrRef(); - d2->decrRef(); - c->decrRef(); - b->decrRef(); - a->decrRef(); -} - -/*! - * 2D -> 3D extrusion with rotation - */ -void MEDCouplingBasicsTest::testExtrudedMesh7() -{ - const double coo1[4]={0.,1.,2.,3.5}; - DataArrayDouble *a=DataArrayDouble::New(); - a->alloc(4,1); - std::copy(coo1,coo1+4,a->getPointer()); - MEDCouplingCMesh *b=MEDCouplingCMesh::New(); - b->setCoordsAt(0,a); - MEDCouplingUMesh *c=b->buildUnstructured(); - CPPUNIT_ASSERT_EQUAL(1,c->getSpaceDimension()); - c->changeSpaceDimension(2); - // - DataArrayDouble *d=DataArrayDouble::New(); - d->alloc(13,1); - d->iota(); - MEDCouplingCMesh *e=MEDCouplingCMesh::New(); - e->setCoordsAt(0,d); - MEDCouplingUMesh *f=e->buildUnstructured(); - DataArrayDouble *g=f->getCoords()->applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec"); - DataArrayDouble *h=g->fromPolarToCart(); - f->setCoords(h); - MEDCouplingUMesh *i=c->buildExtrudedMesh(f,1); - CPPUNIT_ASSERT_EQUAL(52,i->getNumberOfNodes()); - bool tmp2; - int tmp3; - DataArrayInt *tmp=i->mergeNodes(1e-9,tmp2,tmp3); - CPPUNIT_ASSERT(tmp2); - CPPUNIT_ASSERT_EQUAL(37,tmp3); - tmp->decrRef(); - i->convertDegeneratedCells(); - const double vec1[3]={10.,0.,0.}; - i->translate(vec1); - DataArrayDouble *g2=h->applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec"); - f->setCoords(g2); - i->changeSpaceDimension(3); - MEDCouplingUMesh *i3=i->buildExtrudedMesh(f,1); - MEDCouplingFieldDouble *f2=i3->getMeasureField(true); - tmp=i->mergeNodes(1e-9,tmp2,tmp3); - CPPUNIT_ASSERT(tmp2); - CPPUNIT_ASSERT_EQUAL(444,tmp3); - tmp->decrRef(); - const double expected1[36]={1.327751058489274, 4.2942574094314701, 13.024068164857139, 1.3069177251569044, 4.1484240761012954, 12.297505664866796, 1.270833333332571, 3.8958333333309674, 11.039062499993179, 1.2291666666659207, 3.6041666666644425, 9.585937499993932, 1.1930822748415895, 3.3515759238941376, 8.3274943351204556, 1.1722489415082769, 3.2057425905609289, 7.6009318351210622, 1.1722489415082862, 3.2057425905609884, 7.6009318351213713, 1.1930822748416161, 3.3515759238943001, 8.3274943351212727, 1.2291666666659564, 3.6041666666646734, 9.5859374999950777, 1.2708333333326081, 3.8958333333311868, 11.039062499994293, 1.3069177251569224, 4.1484240761014384, 12.297505664867627, 1.3277510584902354, 4.2942574094346071, 13.024068164866796}; - int kk=0; - for(int ii=0;ii<12;ii++) - for(int jj=0;jj<36;jj++,kk++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[jj],f2->getIJ(0,kk),1e-9); - // - f2->decrRef(); - i3->decrRef(); - g2->decrRef(); - i->decrRef(); - h->decrRef(); - g->decrRef(); - f->decrRef(); - e->decrRef(); - d->decrRef(); - c->decrRef(); - b->decrRef(); - a->decrRef(); -} - -void MEDCouplingBasicsTest::testSimplexize1() -{ - MEDCouplingUMesh *m=build3DSurfTargetMesh_1(); - std::vector v(1); - v[0]=3; - m->convertToPolyTypes(v); - DataArrayInt *da=m->simplexize(0); - CPPUNIT_ASSERT_EQUAL(7,da->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,da->getNumberOfComponents()); - const int expected2[7]={0,0,1,2,3,4,4}; - for(int i=0;i<7;i++) - CPPUNIT_ASSERT_EQUAL(expected2[i],da->getIJ(i,0)); - m->checkCoherency(); - CPPUNIT_ASSERT_EQUAL(7,m->getNumberOfCells()); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(0)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(1)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(2)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(3)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_POLYGON,m->getTypeOfCell(4)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(5)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(6)); - const double expected1[7]={0.125,0.125,0.125,0.125,0.25,0.125,0.125}; - MEDCouplingFieldDouble *f=m->getMeasureField(false); - for(int i=0;i<7;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i]*sqrt(2.),f->getIJ(i,0),1e-10); - std::set types=m->getAllTypes(); - CPPUNIT_ASSERT_EQUAL(2,(int)types.size()); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,*(types.begin())); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_POLYGON,*(++(types.begin()))); - f->decrRef(); - da->decrRef(); - m->decrRef(); - // - m=build3DSurfTargetMesh_1(); - v[0]=3; - m->convertToPolyTypes(v); - da=m->simplexize(1); - CPPUNIT_ASSERT_EQUAL(7,da->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,da->getNumberOfComponents()); - for(int i=0;i<7;i++) - CPPUNIT_ASSERT_EQUAL(expected2[i],da->getIJ(i,0)); - m->checkCoherency(); - types=m->getAllTypes(); - CPPUNIT_ASSERT_EQUAL(2,(int)types.size()); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,*(types.begin())); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_POLYGON,*(++(types.begin()))); - CPPUNIT_ASSERT_EQUAL(7,m->getNumberOfCells()); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(0)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(1)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(2)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(3)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_POLYGON,m->getTypeOfCell(4)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(5)); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(6)); - f=m->getMeasureField(false); - for(int i=0;i<7;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i]*sqrt(2.),f->getIJ(i,0),1e-10); - f->decrRef(); - da->decrRef(); - m->decrRef(); -} - -void MEDCouplingBasicsTest::testSimplexize2() -{ - MEDCouplingUMesh *m=build3DSurfTargetMesh_1(); - std::vector v(1); - v[0]=3; - m->convertToPolyTypes(v); - MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); - f1->setMesh(m); - DataArrayDouble *arr=DataArrayDouble::New(); - const double arr1[10]={10.,110.,20.,120.,30.,130.,40.,140.,50.,150.}; - arr->alloc(5,2); - std::copy(arr1,arr1+10,arr->getPointer()); - f1->setArray(arr); - arr->decrRef(); - // - f1->checkCoherency(); - CPPUNIT_ASSERT(f1->simplexize(0)); - f1->checkCoherency(); - const double expected1[14]={10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.}; - for(int i=0;i<14;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f1->getIJ(0,i),1e-10); - CPPUNIT_ASSERT(!f1->simplexize(0)); - for(int i=0;i<14;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f1->getIJ(0,i),1e-10); - // - f1->decrRef(); - m->decrRef(); -} - -void MEDCouplingBasicsTest::testDAMeld1() -{ - DataArrayDouble *da1=DataArrayDouble::New(); - da1->alloc(7,2); - DataArrayDouble *da2=DataArrayDouble::New(); - da2->alloc(7,1); - // - da1->fillWithValue(7.); - da2->iota(0.); - DataArrayDouble *da3=da2->applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec"); - // - da1->setInfoOnComponent(0,"c0da1"); - da1->setInfoOnComponent(1,"c1da1"); - da3->setInfoOnComponent(0,"c0da3"); - da3->setInfoOnComponent(1,"c1da3"); - da3->setInfoOnComponent(2,"c2da3"); - // - DataArrayDouble *da1C=da1->deepCpy(); - da1->meldWith(da3); - CPPUNIT_ASSERT_EQUAL(5,da1->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(7,da1->getNumberOfTuples()); - CPPUNIT_ASSERT(da1->getInfoOnComponent(0)=="c0da1"); - CPPUNIT_ASSERT(da1->getInfoOnComponent(1)=="c1da1"); - CPPUNIT_ASSERT(da1->getInfoOnComponent(2)=="c0da3"); - CPPUNIT_ASSERT(da1->getInfoOnComponent(3)=="c1da3"); - CPPUNIT_ASSERT(da1->getInfoOnComponent(4)=="c2da3"); - // - const double expected1[35]={7.,7.,0.,0.,0., 7.,7.,10.,100.,1000., 7.,7.,20.,200.,2000., 7.,7.,30.,300.,3000., 7.,7.,40.,400.,4000.,7.,7.,50.,500.,5000.,7.,7.,60.,600.,6000.}; - for(int i=0;i<35;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],da1->getIJ(0,i),1e-10); - // - DataArrayInt *dai1=da1C->convertToIntArr(); - DataArrayInt *dai3=da3->convertToIntArr(); - dai1->meldWith(dai3); - CPPUNIT_ASSERT_EQUAL(5,dai1->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(7,dai1->getNumberOfTuples()); - CPPUNIT_ASSERT(dai1->getInfoOnComponent(0)=="c0da1"); - CPPUNIT_ASSERT(dai1->getInfoOnComponent(1)=="c1da1"); - CPPUNIT_ASSERT(dai1->getInfoOnComponent(2)=="c0da3"); - CPPUNIT_ASSERT(dai1->getInfoOnComponent(3)=="c1da3"); - CPPUNIT_ASSERT(dai1->getInfoOnComponent(4)=="c2da3"); - for(int i=0;i<35;i++) - CPPUNIT_ASSERT_EQUAL((int)expected1[i],dai1->getIJ(0,i)); - // test of static method DataArrayDouble::meld - DataArrayDouble *da4=DataArrayDouble::Meld(da1C,da3); - CPPUNIT_ASSERT_EQUAL(5,da4->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(7,da4->getNumberOfTuples()); - CPPUNIT_ASSERT(da4->getInfoOnComponent(0)=="c0da1"); - CPPUNIT_ASSERT(da4->getInfoOnComponent(1)=="c1da1"); - CPPUNIT_ASSERT(da4->getInfoOnComponent(2)=="c0da3"); - CPPUNIT_ASSERT(da4->getInfoOnComponent(3)=="c1da3"); - CPPUNIT_ASSERT(da4->getInfoOnComponent(4)=="c2da3"); - for(int i=0;i<35;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],da4->getIJ(0,i),1e-10); - // test of static method DataArrayInt::meld - dai1->decrRef(); - dai1=da1C->convertToIntArr(); - DataArrayInt *dai4=DataArrayInt::Meld(dai1,dai3); - CPPUNIT_ASSERT_EQUAL(5,dai4->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(7,dai4->getNumberOfTuples()); - CPPUNIT_ASSERT(dai4->getInfoOnComponent(0)=="c0da1"); - CPPUNIT_ASSERT(dai4->getInfoOnComponent(1)=="c1da1"); - CPPUNIT_ASSERT(dai4->getInfoOnComponent(2)=="c0da3"); - CPPUNIT_ASSERT(dai4->getInfoOnComponent(3)=="c1da3"); - CPPUNIT_ASSERT(dai4->getInfoOnComponent(4)=="c2da3"); - for(int i=0;i<35;i++) - CPPUNIT_ASSERT_EQUAL((int)expected1[i],dai4->getIJ(0,i)); - // - dai4->decrRef(); - da4->decrRef(); - dai3->decrRef(); - dai1->decrRef(); - da1C->decrRef(); - da1->decrRef(); - da2->decrRef(); - da3->decrRef(); -} - -void MEDCouplingBasicsTest::testFieldMeld1() -{ - MEDCouplingUMesh *m=build3DSurfTargetMesh_1(); - MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); - f1->setMesh(m); - DataArrayDouble *da1=DataArrayDouble::New(); - const double arr1[5]={12.,23.,34.,45.,56.}; - da1->alloc(5,1); - std::copy(arr1,arr1+5,da1->getPointer()); - da1->setInfoOnComponent(0,"aaa"); - f1->setArray(da1); - f1->setTime(3.4,2,1); - f1->checkCoherency(); - // - MEDCouplingFieldDouble *f2=f1->deepCpy(); - f2->setMesh(f1->getMesh()); - f2->checkCoherency(); - f2->changeNbOfComponents(2,5.); - (*f2)=5.; - f2->getArray()->setInfoOnComponent(0,"bbb"); - f2->getArray()->setInfoOnComponent(1,"ccc"); - f2->checkCoherency(); - // - MEDCouplingFieldDouble *f3=MEDCouplingFieldDouble::MeldFields(f2,f1); - f3->checkCoherency(); - CPPUNIT_ASSERT_EQUAL(5,f3->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(3,f3->getNumberOfComponents()); - CPPUNIT_ASSERT(f3->getArray()->getInfoOnComponent(0)=="bbb"); - CPPUNIT_ASSERT(f3->getArray()->getInfoOnComponent(1)=="ccc"); - CPPUNIT_ASSERT(f3->getArray()->getInfoOnComponent(2)=="aaa"); - const double expected1[15]={5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.}; - for(int i=0;i<15;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f3->getIJ(0,i),1e-12); - int dt,it; - double time=f3->getTime(dt,it); - CPPUNIT_ASSERT_DOUBLES_EQUAL(3.4,time,1e-14); - CPPUNIT_ASSERT_EQUAL(2,dt); - CPPUNIT_ASSERT_EQUAL(1,it); - // - MEDCouplingFieldDouble *f4=f2->buildNewTimeReprFromThis(NO_TIME,false); - MEDCouplingFieldDouble *f5=f1->buildNewTimeReprFromThis(NO_TIME,false); - MEDCouplingFieldDouble *f6=MEDCouplingFieldDouble::MeldFields(f4,f5); - f6->checkCoherency(); - CPPUNIT_ASSERT_EQUAL(5,f6->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(3,f6->getNumberOfComponents()); - CPPUNIT_ASSERT(f6->getArray()->getInfoOnComponent(0)=="bbb"); - CPPUNIT_ASSERT(f6->getArray()->getInfoOnComponent(1)=="ccc"); - CPPUNIT_ASSERT(f6->getArray()->getInfoOnComponent(2)=="aaa"); - for(int i=0;i<15;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f6->getIJ(0,i),1e-12); - // - f6->decrRef(); - f4->decrRef(); - f5->decrRef(); - f3->decrRef(); - da1->decrRef(); - f2->decrRef(); - f1->decrRef(); - m->decrRef(); -} - -void MEDCouplingBasicsTest::testMergeNodes2() -{ - MEDCouplingUMesh *m1=build2DTargetMesh_1(); - MEDCouplingUMesh *m2=build2DTargetMesh_1(); - const double vec[2]={0.002,0.}; - m2->translate(vec); - // - std::vector tmp(2); - tmp[0]=m1; - tmp[1]=m2; - MEDCouplingUMesh *m3=MEDCouplingUMesh::MergeUMeshes(tmp); - bool b; - int newNbOfNodes; - DataArrayInt *da=m3->mergeNodes2(0.01,b,newNbOfNodes); - CPPUNIT_ASSERT_EQUAL(9,m3->getNumberOfNodes()); - const double expected1[18]={-0.299,-0.3, 0.201,-0.3, 0.701,-0.3, -0.299,0.2, 0.201,0.2, 0.701,0.2, -0.299,0.7, 0.201,0.7, 0.701,0.7}; - for(int i=0;i<18;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],m3->getCoords()->getIJ(0,i),1e-13); - // - da->decrRef(); - m3->decrRef(); - m1->decrRef(); - m2->decrRef(); -} - -void MEDCouplingBasicsTest::testMergeField2() -{ - MEDCouplingUMesh *m=build2DTargetMesh_1(); - MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); - f1->setMesh(m); - DataArrayDouble *arr=DataArrayDouble::New(); - arr->alloc(5,2); - arr->fillWithValue(2.); - f1->setArray(arr); - arr->decrRef(); - MEDCouplingFieldDouble *f2=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); - f2->setMesh(m); - arr=DataArrayDouble::New(); - arr->alloc(5,2); - arr->fillWithValue(5.); - f2->setArray(arr); - arr->decrRef(); - MEDCouplingFieldDouble *f3=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); - f3->setMesh(m); - arr=DataArrayDouble::New(); - arr->alloc(5,2); - arr->fillWithValue(7.); - f3->setArray(arr); - arr->decrRef(); - // - std::vector tmp(3); - tmp[0]=f1; tmp[1]=f2; tmp[2]=f3; - MEDCouplingFieldDouble *f4=MEDCouplingFieldDouble::MergeFields(tmp); - CPPUNIT_ASSERT_EQUAL(15,f4->getMesh()->getNumberOfCells()); - const double expected1[30]={2.,2.,2.,2.,2.,2.,2.,2.,2.,2., 5.,5.,5.,5.,5.,5.,5.,5.,5.,5., 7.,7.,7.,7.,7.,7.,7.,7.,7.,7.}; - for(int i=0;i<30;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f4->getIJ(0,i),1.e-13); - // - f4->decrRef(); - f1->decrRef(); - f2->decrRef(); - f3->decrRef(); - m->decrRef(); -} - -void MEDCouplingBasicsTest::testDAIBuildComplement1() -{ - DataArrayInt *a=DataArrayInt::New(); - const int tab[4]={3,1,7,8}; - a->alloc(4,1); - std::copy(tab,tab+4,a->getPointer()); - DataArrayInt *b=a->buildComplement(12); - CPPUNIT_ASSERT_EQUAL(8,b->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,b->getNumberOfComponents()); - const int expected1[8]={0,2,4,5,6,9,10,11}; - for(int i=0;i<8;i++) - CPPUNIT_ASSERT_EQUAL(expected1[i],b->getIJ(0,i)); - b->decrRef(); - a->decrRef(); -} - -void MEDCouplingBasicsTest::testDAIBuildUnion1() -{ - DataArrayInt *a=DataArrayInt::New(); - const int tab1[4]={3,1,7,8}; - a->alloc(4,1); - std::copy(tab1,tab1+4,a->getPointer()); - DataArrayInt *c=DataArrayInt::New(); - const int tab2[5]={5,3,0,18,8}; - c->alloc(5,1); - std::copy(tab2,tab2+5,c->getPointer()); - DataArrayInt *b=a->buildUnion(c); - CPPUNIT_ASSERT_EQUAL(7,b->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,b->getNumberOfComponents()); - const int expected1[7]={0,1,3,5,7,8,18}; - for(int i=0;i<7;i++) - CPPUNIT_ASSERT_EQUAL(expected1[i],b->getIJ(0,i)); - c->decrRef(); - b->decrRef(); - a->decrRef(); -} - -void MEDCouplingBasicsTest::testDAIBuildIntersection1() -{ - DataArrayInt *a=DataArrayInt::New(); - const int tab1[4]={3,1,7,8}; - a->alloc(4,1); - std::copy(tab1,tab1+4,a->getPointer()); - DataArrayInt *c=DataArrayInt::New(); - const int tab2[5]={5,3,0,18,8}; - c->alloc(5,1); - std::copy(tab2,tab2+5,c->getPointer()); - DataArrayInt *b=a->buildIntersection(c); - CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,b->getNumberOfComponents()); - const int expected1[2]={3,8}; - for(int i=0;i<2;i++) - CPPUNIT_ASSERT_EQUAL(expected1[i],b->getIJ(0,i)); - c->decrRef(); - b->decrRef(); - a->decrRef(); -} - -void MEDCouplingBasicsTest::testDAIDeltaShiftIndex1() -{ - DataArrayInt *a=DataArrayInt::New(); - const int tab[7]={1,3,6,7,7,9,15}; - a->alloc(7,1); - std::copy(tab,tab+7,a->getPointer()); - DataArrayInt *b=a->deltaShiftIndex(); - CPPUNIT_ASSERT_EQUAL(6,b->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,b->getNumberOfComponents()); - const int expected1[6]={2,3,1,0,2,6}; - for(int i=0;i<6;i++) - CPPUNIT_ASSERT_EQUAL(expected1[i],b->getIJ(0,i)); - b->decrRef(); - a->decrRef(); -} - -void MEDCouplingBasicsTest::testDaDoubleSelectByTupleIdSafe1() -{ - DataArrayDouble *a=DataArrayDouble::New(); - a->alloc(7,2); - a->setInfoOnComponent(0,"toto"); - a->setInfoOnComponent(1,"tata"); - const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; - std::copy(arr1,arr1+14,a->getPointer()); - // - const int arr2[7]={4,2,0,6,5}; - DataArrayDouble *b=a->selectByTupleIdSafe(arr2,arr2+5); - CPPUNIT_ASSERT_EQUAL(5,b->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); - CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(0))=="toto"); - CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(1))=="tata"); - const double expected1[10]={5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1}; - for(int i=0;i<10;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); - const int arr4[5]={4,-1,0,6,5}; - CPPUNIT_ASSERT_THROW(a->selectByTupleIdSafe(arr4,arr4+5),INTERP_KERNEL::Exception); - const int arr5[5]={4,2,0,6,7}; - CPPUNIT_ASSERT_THROW(a->selectByTupleIdSafe(arr5,arr5+5),INTERP_KERNEL::Exception); - b->decrRef(); - a->decrRef(); - // - DataArrayInt *c=DataArrayInt::New(); - c->alloc(7,2); - c->setInfoOnComponent(0,"toto"); - c->setInfoOnComponent(1,"tata"); - const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; - std::copy(arr3,arr3+14,c->getPointer()); - DataArrayInt *d=c->selectByTupleIdSafe(arr2,arr2+5); - CPPUNIT_ASSERT_EQUAL(5,d->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,d->getNumberOfComponents()); - CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(0))=="toto"); - CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(1))=="tata"); - const int expected2[10]={5,15,3,13,1,11,7,17,6,16}; - for(int i=0;i<10;i++) - CPPUNIT_ASSERT_EQUAL(expected2[i],d->getIJ(0,i)); - CPPUNIT_ASSERT_THROW(c->selectByTupleIdSafe(arr4,arr4+5),INTERP_KERNEL::Exception); - CPPUNIT_ASSERT_THROW(c->selectByTupleIdSafe(arr5,arr5+5),INTERP_KERNEL::Exception); - c->decrRef(); - d->decrRef(); -} - -void MEDCouplingBasicsTest::testAreCellsIncludedIn1() -{ - MEDCouplingUMesh *m=build3DSurfTargetMesh_1(); - const int pt[2]={1,3}; - MEDCouplingUMesh *m2=(MEDCouplingUMesh *)m->buildPartOfMySelf(pt,pt+2,true); - DataArrayInt *tmp; - CPPUNIT_ASSERT(m->areCellsIncludedIn(m2,0,tmp)); - CPPUNIT_ASSERT_EQUAL(2,tmp->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,tmp->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(pt[0],tmp->getIJ(0,0)); - CPPUNIT_ASSERT_EQUAL(pt[1],tmp->getIJ(0,1)); - tmp->decrRef(); - CPPUNIT_ASSERT(!m2->areCellsIncludedIn(m,0,tmp)); - tmp->decrRef(); - m2->decrRef(); - m->decrRef(); -} - -void MEDCouplingBasicsTest::testDAIBuildSubstraction1() -{ - DataArrayInt *a=DataArrayInt::New(); - const int aa[]={2,3,6,8,9}; - a->alloc(5,1); - std::copy(aa,aa+5,a->getPointer()); - DataArrayInt *b=DataArrayInt::New(); - const int bb[]={1,3,5,9,11}; - b->alloc(5,1); - std::copy(bb,bb+5,b->getPointer()); - // - DataArrayInt *c=a->buildSubstraction(b); - CPPUNIT_ASSERT_EQUAL(3,c->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,c->getNumberOfComponents()); - const int expected1[3]={2,6,8}; - CPPUNIT_ASSERT(std::equal(expected1,expected1+3,c->getConstPointer())); - // - c->decrRef(); - b->decrRef(); - a->decrRef(); -} - -void MEDCouplingBasicsTest::testBuildOrthogonalField2() -{ - MEDCouplingUMesh *m=build2DTargetMesh_1(); - DataArrayInt *d1=DataArrayInt::New(); - DataArrayInt *d2=DataArrayInt::New(); - DataArrayInt *d3=DataArrayInt::New(); - DataArrayInt *d4=DataArrayInt::New(); - MEDCouplingUMesh *m1=m->buildDescendingConnectivity(d1,d2,d3,d4); - // - MEDCouplingFieldDouble *f1=m1->buildOrthogonalField(); - DataArrayDouble *da1=f1->getArray(); - CPPUNIT_ASSERT_EQUAL(2,da1->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(13,da1->getNumberOfTuples()); - // - const double expected1[26]={-1.,0.,0.,1.,1.,0.,0.,-1.,0.707106781186548,0.707106781186548,0.,-1.,0.,1.,1.,0.,0.,1.,1.,0.,-1.,0.,0.,1.,1.,0.}; - for(int i=0;i<26;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],da1->getIJ(0,i),1e-14); - // - f1->decrRef(); - m1->decrRef(); - d1->decrRef(); - d2->decrRef(); - d3->decrRef(); - d4->decrRef(); - m->decrRef(); -} - -void MEDCouplingBasicsTest::testUMInsertNextCell1() -{ - double targetCoords[18]={-0.3,-0.3, 0.2,-0.3, 0.7,-0.3, -0.3,0.2, 0.2,0.2, 0.7,0.2, -0.3,0.7, 0.2,0.7, 0.7,0.7 }; - int targetConn[18]={0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4}; - MEDCouplingUMesh *targetMesh=MEDCouplingUMesh::New(); - targetMesh->allocateCells(5); - CPPUNIT_ASSERT_THROW(targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn),INTERP_KERNEL::Exception); - targetMesh->setMeshDimension(2); - targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn); - CPPUNIT_ASSERT_THROW(targetMesh->insertNextCell(INTERP_KERNEL::NORM_TETRA4,4,targetConn),INTERP_KERNEL::Exception); - CPPUNIT_ASSERT_THROW(targetMesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,targetConn),INTERP_KERNEL::Exception); - CPPUNIT_ASSERT_THROW(targetMesh->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,targetConn),INTERP_KERNEL::Exception); - targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn+4); - targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn+7); - targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+10); - targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+14); - targetMesh->finishInsertingCells(); - DataArrayDouble *myCoords=DataArrayDouble::New(); - myCoords->alloc(9,2); - std::copy(targetCoords,targetCoords+18,myCoords->getPointer()); - targetMesh->setCoords(myCoords); - myCoords->decrRef(); - targetMesh->checkCoherency(); - targetMesh->decrRef(); -} - -void MEDCouplingBasicsTest::testFieldOperatorDivDiffComp1() -{ - MEDCouplingUMesh *m=build2DTargetMesh_1(); - DataArrayInt *d1=DataArrayInt::New(); - DataArrayInt *d2=DataArrayInt::New(); - DataArrayInt *d3=DataArrayInt::New(); - DataArrayInt *d4=DataArrayInt::New(); - MEDCouplingUMesh *m1=m->buildDescendingConnectivity(d1,d2,d3,d4); - // - MEDCouplingFieldDouble *f1=m1->buildOrthogonalField(); - const double arr1[13]={2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.}; - DataArrayDouble *arr=DataArrayDouble::New(); - arr->alloc(13,1); - std::copy(arr1,arr1+13,arr->getPointer()); - MEDCouplingFieldDouble *f2=MEDCouplingFieldDouble::New(ON_CELLS); - f2->setArray(arr); - f2->setMesh(m1); - f2->checkCoherency(); - // - MEDCouplingFieldDouble *f3=(*f1)/(*f2); - CPPUNIT_ASSERT_THROW((*f2)/(*f1),INTERP_KERNEL::Exception); - f3->checkCoherency(); - (*f1)/=(*f2); - CPPUNIT_ASSERT(f1->isEqual(f3,1e-10,1e-10)); - CPPUNIT_ASSERT_THROW((*f2)/=(*f1),INTERP_KERNEL::Exception); - const double expected1[26]={-0.5, 0.0, 0.0, 0.33333333333333331, 0.25, 0.0, 0.0, -0.20000000000000001, 0.117851130197758, 0.117851130197758, 0.0, -0.14285714285714285, 0.0, 0.125, 0.1111111111111111, 0.0, 0.0, 0.10000000000000001, 0.090909090909090912, 0.0, -0.083333333333333329, 0.0, 0.0, 0.076923076923076927, 0.071428571428571425, 0.0}; - for(int i=0;i<26;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f3->getIJ(0,i),1e-10); - // - f3->decrRef(); - f2->decrRef(); - arr->decrRef(); - f1->decrRef(); - m1->decrRef(); - d1->decrRef(); - d2->decrRef(); - d3->decrRef(); - d4->decrRef(); - m->decrRef(); -} - -void MEDCouplingBasicsTest::testDARearrange1() -{ - DataArrayInt *da1=DataArrayInt::New(); - da1->alloc(12,1); - da1->iota(0); - const int *ptr=da1->getConstPointer(); - // - CPPUNIT_ASSERT_EQUAL(12,da1->getNbOfElems()); - CPPUNIT_ASSERT_EQUAL(1,da1->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(12,da1->getNumberOfTuples()); - da1->rearrange(4); - CPPUNIT_ASSERT(ptr==da1->getConstPointer()); - CPPUNIT_ASSERT_EQUAL(12,da1->getNbOfElems()); - CPPUNIT_ASSERT_EQUAL(4,da1->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(3,da1->getNumberOfTuples()); - for(int i=0;i<12;i++) - CPPUNIT_ASSERT_EQUAL(i,da1->getIJ(0,i)); - // - da1->rearrange(6); - CPPUNIT_ASSERT(ptr==da1->getConstPointer()); - CPPUNIT_ASSERT_EQUAL(12,da1->getNbOfElems()); - CPPUNIT_ASSERT_EQUAL(6,da1->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(2,da1->getNumberOfTuples()); - for(int i=0;i<12;i++) - CPPUNIT_ASSERT_EQUAL(i,da1->getIJ(0,i)); - // - CPPUNIT_ASSERT_THROW(da1->rearrange(7),INTERP_KERNEL::Exception); - // - da1->rearrange(12); - CPPUNIT_ASSERT(ptr==da1->getConstPointer()); - CPPUNIT_ASSERT_EQUAL(12,da1->getNbOfElems()); - CPPUNIT_ASSERT_EQUAL(12,da1->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(1,da1->getNumberOfTuples()); - for(int i=0;i<12;i++) - CPPUNIT_ASSERT_EQUAL(i,da1->getIJ(0,i)); - // - da1->rearrange(3); - CPPUNIT_ASSERT(ptr==da1->getConstPointer()); - CPPUNIT_ASSERT_EQUAL(12,da1->getNbOfElems()); - CPPUNIT_ASSERT_EQUAL(3,da1->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(4,da1->getNumberOfTuples()); - for(int i=0;i<12;i++) - CPPUNIT_ASSERT_EQUAL(i,da1->getIJ(0,i)); - //double - DataArrayDouble *da2=da1->convertToDblArr(); - da1->decrRef(); - const double *ptr2=da2->getConstPointer(); - // - CPPUNIT_ASSERT_EQUAL(12,da2->getNbOfElems()); - CPPUNIT_ASSERT_EQUAL(3,da2->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(4,da2->getNumberOfTuples()); - da2->rearrange(4); - CPPUNIT_ASSERT(ptr2==da2->getConstPointer()); - CPPUNIT_ASSERT_EQUAL(12,da2->getNbOfElems()); - CPPUNIT_ASSERT_EQUAL(4,da2->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(3,da2->getNumberOfTuples()); - for(int i=0;i<12;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL((double)i,da2->getIJ(0,i),1e-14); - // - da2->rearrange(6); - CPPUNIT_ASSERT(ptr2==da2->getConstPointer()); - CPPUNIT_ASSERT_EQUAL(12,da2->getNbOfElems()); - CPPUNIT_ASSERT_EQUAL(6,da2->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(2,da2->getNumberOfTuples()); - for(int i=0;i<12;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL((double)i,da2->getIJ(0,i),1e-14); - // - CPPUNIT_ASSERT_THROW(da2->rearrange(7),INTERP_KERNEL::Exception); - // - da2->rearrange(1); - CPPUNIT_ASSERT(ptr2==da2->getConstPointer()); - CPPUNIT_ASSERT_EQUAL(12,da2->getNbOfElems()); - CPPUNIT_ASSERT_EQUAL(1,da2->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(12,da2->getNumberOfTuples()); - for(int i=0;i<12;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL((double)i,da2->getIJ(0,i),1e-14); - // - da2->rearrange(3); - CPPUNIT_ASSERT(ptr2==da2->getConstPointer()); - CPPUNIT_ASSERT_EQUAL(12,da2->getNbOfElems()); - CPPUNIT_ASSERT_EQUAL(3,da2->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(4,da2->getNumberOfTuples()); - for(int i=0;i<12;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL((double)i,da2->getIJ(0,i),1e-14); - da2->decrRef(); -} - -void MEDCouplingBasicsTest::testGetDifferentValues1() -{ - DataArrayInt *da1=DataArrayInt::New(); - const int arr[12]={1,2,3,2,2,3,5,1,5,5,2,2}; - da1->alloc(4,3); - std::copy(arr,arr+12,da1->getPointer()); - std::set s=da1->getDifferentValues(); - const int expected1[4]={1,2,3,5}; - CPPUNIT_ASSERT_EQUAL(4,(int)s.size()); - CPPUNIT_ASSERT(std::equal(expected1,expected1+4,s.begin())); - da1->decrRef(); -} - -void MEDCouplingBasicsTest::testDAIBuildPermutationArr1() -{ - DataArrayInt *a=DataArrayInt::New(); - const int vala[5]={4,5,6,7,8}; - a->alloc(5,1); - std::copy(vala,vala+5,a->getPointer()); - DataArrayInt *b=DataArrayInt::New(); - const int valb[5]={5,4,8,6,7}; - b->alloc(5,1); - std::copy(valb,valb+5,b->getPointer()); - DataArrayInt *c=a->buildPermutationArr(*b); - const int expect1[5]={1,0,4,2,3}; - CPPUNIT_ASSERT_EQUAL(5,c->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,c->getNumberOfComponents()); - CPPUNIT_ASSERT(std::equal(expect1,expect1+5,c->getConstPointer())); - CPPUNIT_ASSERT(a->isEqualWithoutConsideringStrAndOrder(*b)); - b->setIJ(0,0,9); - CPPUNIT_ASSERT(!a->isEqualWithoutConsideringStrAndOrder(*b)); - CPPUNIT_ASSERT_THROW(a->buildPermutationArr(*b),INTERP_KERNEL::Exception); - a->setIJ(3,0,4); - b->setIJ(0,0,5); - b->setIJ(4,0,4);//;a==[4,5,6,4,8] and b==[5,4,8,6,4] - CPPUNIT_ASSERT(a->isEqualWithoutConsideringStrAndOrder(*b)); - c->decrRef(); - c=a->buildPermutationArr(*b); - const int expect2[5]={1,3,4,2,3}; - CPPUNIT_ASSERT(std::equal(expect2,expect2+5,c->getConstPointer())); - DataArrayDouble *d=b->convertToDblArr(); - b->sort(); - const int expect3[5]={4,4,5,6,8}; - CPPUNIT_ASSERT(std::equal(expect3,expect3+5,b->getConstPointer())); - d->sort(); - CPPUNIT_ASSERT_EQUAL(5,d->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,d->getNumberOfComponents()); - for(int i=0;i<5;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(double(expect3[i]),d->getIJ(i,0),1e-14); - // - d->decrRef(); - c->decrRef(); - a->decrRef(); - b->decrRef(); -} - -void MEDCouplingBasicsTest::testAreCellsIncludedIn2() -{ - const char myName[]="Vitoo"; - MEDCouplingUMesh *m=build3DSurfTargetMesh_1(); - MEDCouplingUMesh *m2=(MEDCouplingUMesh *)m->buildPartOfMySelf(0,0,true); - CPPUNIT_ASSERT_EQUAL(0,m2->getNumberOfCells()); - CPPUNIT_ASSERT_EQUAL(3,m2->getSpaceDimension()); - CPPUNIT_ASSERT_EQUAL(2,m2->getMeshDimension()); - m2->setName(myName); - DataArrayInt *tmp; - CPPUNIT_ASSERT(m->areCellsIncludedIn(m2,0,tmp)); - CPPUNIT_ASSERT(std::string(myName)==tmp->getName()); - CPPUNIT_ASSERT_EQUAL(0,tmp->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(1,tmp->getNumberOfComponents()); - m->decrRef(); - m2->decrRef(); - tmp->decrRef(); -} - -void MEDCouplingBasicsTest::testUMeshGetPartBarycenterAndOwner1() -{ - MEDCouplingUMesh *m1=build2DTargetMesh_1(); - const int part[3]={1,0,4}; - DataArrayDouble *b=m1->getPartBarycenterAndOwner(part,part+3); - CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(3,b->getNumberOfTuples()); - const double expected1[6]={0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45}; - for(int i=0;i<6;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); - b->decrRef(); - m1->decrRef(); -} - -void MEDCouplingBasicsTest::testUMeshGetPartMeasureField1() -{ - MEDCouplingUMesh *m1=build2DTargetMesh_1(); - const int part[3]={1,0,4}; - DataArrayDouble *b=m1->getPartMeasureField(true,part,part+3); - CPPUNIT_ASSERT_EQUAL(1,b->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(3,b->getNumberOfTuples()); - const double expected1[3]={0.125,0.25,0.25}; - for(int i=0;i<3;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); - b->decrRef(); - m1->decrRef(); -} - -void MEDCouplingBasicsTest::testUMeshBuildPartOrthogonalField1() -{ - MEDCouplingUMesh *m1=build2DTargetMesh_1(); - m1->changeSpaceDimension(3); - const int part[3]={1,0,4}; - MEDCouplingFieldDouble *b=m1->buildPartOrthogonalField(part,part+3); - CPPUNIT_ASSERT_EQUAL(3,b->getArray()->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(3,b->getArray()->getNumberOfTuples()); - const double expected1[9]={0.,0.,-1.,0.,0.,-1.,0.,0.,-1.}; - for(int i=0;i<9;i++) - CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getArray()->getIJ(0,i),1e-14); - b->decrRef(); - m1->decrRef(); -} - -void MEDCouplingBasicsTest::testUMeshGetTypesOfPart1() -{ - MEDCouplingUMesh *m1=build2DTargetMesh_1(); - const int part1[]={0,3,4}; - std::set s; - s=m1->getTypesOfPart(part1,part1+3); - CPPUNIT_ASSERT(s.size()==1); - CPPUNIT_ASSERT(*s.begin()==INTERP_KERNEL::NORM_QUAD4); - const int part2[]={2,2,2,1}; - s=m1->getTypesOfPart(part2,part2+4); - CPPUNIT_ASSERT(s.size()==1); - CPPUNIT_ASSERT(*s.begin()==INTERP_KERNEL::NORM_TRI3); - const int part3[]={3,2,1}; - s=m1->getTypesOfPart(part3,part3+3); - CPPUNIT_ASSERT(s.size()==2); - CPPUNIT_ASSERT(*s.begin()==INTERP_KERNEL::NORM_TRI3); - CPPUNIT_ASSERT(*(++s.begin())==INTERP_KERNEL::NORM_QUAD4); - m1->decrRef(); -} - -void MEDCouplingBasicsTest::testUMeshKeepCellIdsByType1() -{ - MEDCouplingUMesh *m1=build2DTargetMesh_1(); - const int part1[3]={0,3,4}; - DataArrayInt *a=m1->keepCellIdsByType(INTERP_KERNEL::NORM_TRI3,part1,part1+3); - CPPUNIT_ASSERT_EQUAL(1,a->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(0,a->getNumberOfTuples()); - a->decrRef(); - // - const int part2[5]={3,2,0,2,4}; - a=m1->keepCellIdsByType(INTERP_KERNEL::NORM_TRI3,part2,part2+5); - CPPUNIT_ASSERT_EQUAL(1,a->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(2,a->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,a->getIJ(0,0)); - CPPUNIT_ASSERT_EQUAL(2,a->getIJ(1,0)); - a->decrRef(); - // - a=m1->keepCellIdsByType(INTERP_KERNEL::NORM_QUAD4,part2,part2+5); - CPPUNIT_ASSERT_EQUAL(1,a->getNumberOfComponents()); - CPPUNIT_ASSERT_EQUAL(3,a->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(3,a->getIJ(0,0)); - CPPUNIT_ASSERT_EQUAL(0,a->getIJ(1,0)); - CPPUNIT_ASSERT_EQUAL(4,a->getIJ(2,0)); - // - a->decrRef(); - m1->decrRef(); -} - -void MEDCouplingBasicsTest::testDAIAggregateMulti1() -{ - DataArrayInt *a=DataArrayInt::New(); - a->setName("aa"); - a->alloc(4,1); - a->iota(0); - a->rearrange(2); - DataArrayInt *b=DataArrayInt::New(); - b->setName("bb"); - b->alloc(6,1); - b->iota(0); - b->rearrange(2); - // - std::vector v(2); - v[0]=a; v[1]=b; - DataArrayInt *c=DataArrayInt::Aggregate(v); - CPPUNIT_ASSERT_EQUAL(5,c->getNumberOfTuples()); - CPPUNIT_ASSERT_EQUAL(2,c->getNumberOfComponents()); - CPPUNIT_ASSERT(c->getName()=="aa"); - const int expect1[10]={0,1,2,3,0,1,2,3,4,5}; - for(int i=0;i<10;i++) - CPPUNIT_ASSERT_EQUAL(expect1[i],c->getIJ(0,i)); - // - c->decrRef(); - a->decrRef(); - b->decrRef(); -} - -void MEDCouplingBasicsTest::testMergeUMeshes2() -{ - MEDCouplingUMesh *m1=build3DSurfTargetMesh_1(); - MEDCouplingUMesh *m2=build3DSurfTargetMesh_1(); - MEDCouplingUMesh *m3=build3DSurfTargetMesh_1(); - // - const int vec1[3]={0,2,3}; - MEDCouplingUMesh *m2_2=(MEDCouplingUMesh *)m2->buildPartOfMySelf(vec1,vec1+3,false); - const int vec2[2]={1,1}; - MEDCouplingUMesh *m3_2=(MEDCouplingUMesh *)m3->buildPartOfMySelf(vec2,vec2+2,false); - // - std::vector ms(3); - ms[0]=m1; ms[1]=m2_2; ms[2]=m3_2; - // - MEDCouplingUMesh *m4=MEDCouplingUMesh::MergeUMeshes(ms); - m4->checkCoherency(); - CPPUNIT_ASSERT_EQUAL(10,m4->getNumberOfCells()); - CPPUNIT_ASSERT_EQUAL(20,m4->getNumberOfNodes()); - CPPUNIT_ASSERT_EQUAL(45,m4->getMeshLength()); - // - const int vec3[5]={0,1,2,3,4}; - MEDCouplingUMesh *m4_1=(MEDCouplingUMesh *)m4->buildPartOfMySelf(vec3,vec3+5,false); - m4_1->setName(m1->getName()); - CPPUNIT_ASSERT(m4_1->isEqual(m1,1e-12)); - m4_1->decrRef(); - // - const int vec4[3]={5,6,7}; - MEDCouplingUMesh *m4_2=(MEDCouplingUMesh *)m4->buildPartOfMySelf(vec4,vec4+3,false); - DataArrayInt *cellCor=0; - DataArrayInt *nodeCor=0; - m4_2->checkGeoEquivalWith(m2_2,10,1e-12,cellCor,nodeCor); - CPPUNIT_ASSERT(cellCor==0); - CPPUNIT_ASSERT(nodeCor==0); - m4_2->decrRef(); - // - const int vec5[2]={8,9}; - MEDCouplingUMesh *m4_3=(MEDCouplingUMesh *)m4->buildPartOfMySelf(vec5,vec5+2,false); - CPPUNIT_ASSERT_EQUAL(2,m4_3->getNumberOfCells()); - CPPUNIT_ASSERT_EQUAL(3,m4_3->getNumberOfNodes()); - m3_2->zipCoords(); - m4_3->setName(m3_2->getName()); - CPPUNIT_ASSERT(m4_3->isEqual(m3_2,1e-12)); - m4_3->decrRef(); - // - m4->decrRef(); - m1->decrRef(); - m2->decrRef(); - m2_2->decrRef(); - m3->decrRef(); - m3_2->decrRef(); -} - -void MEDCouplingBasicsTest::testBuild0DMeshFromCoords1() -{ - const double sourceCoords[12]={-0.3,-0.3,0., 0.7,-0.3,0., -0.3,0.7,0., 0.7,0.7,0.}; - DataArrayDouble *coo=DataArrayDouble::New(); - coo->alloc(4,3); - coo->setName("My0D"); - std::copy(sourceCoords,sourceCoords+12,coo->getPointer()); - MEDCouplingUMesh *m=MEDCouplingUMesh::Build0DMeshFromCoords(coo); - m->checkCoherency(); - CPPUNIT_ASSERT_EQUAL(4,m->getNumberOfNodes()); - CPPUNIT_ASSERT_EQUAL(4,m->getNumberOfCells()); - CPPUNIT_ASSERT_EQUAL(3,m->getSpaceDimension()); - CPPUNIT_ASSERT_EQUAL(0,m->getMeshDimension()); - const std::set& types=m->getAllTypes(); - CPPUNIT_ASSERT_EQUAL(1,(int)types.size()); - CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_POINT1,*types.begin()); - for(int i=0;i<4;i++) - { - std::vector conn; - m->getNodeIdsOfCell(i,conn); - CPPUNIT_ASSERT_EQUAL(1,(int)conn.size()); - CPPUNIT_ASSERT_EQUAL(i,conn[0]); - CPPUNIT_ASSERT(INTERP_KERNEL::NORM_POINT1==m->getTypeOfCell(i)); - } - CPPUNIT_ASSERT(std::string(m->getName())=="My0D"); - m->decrRef(); - coo->decrRef(); -} - diff --git a/src/MEDCoupling/Test/MEDCouplingBasicsTest3.cxx b/src/MEDCoupling/Test/MEDCouplingBasicsTest3.cxx new file mode 100644 index 000000000..5e85498b2 --- /dev/null +++ b/src/MEDCoupling/Test/MEDCouplingBasicsTest3.cxx @@ -0,0 +1,2253 @@ +// Copyright (C) 2007-2010 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#include "MEDCouplingBasicsTest.hxx" +#include "MEDCouplingUMesh.hxx" +#include "MEDCouplingCMesh.hxx" +#include "MEDCouplingExtrudedMesh.hxx" +#include "MEDCouplingFieldDouble.hxx" +#include "MEDCouplingMemArray.hxx" +#include "MEDCouplingGaussLocalization.hxx" + +#include +#include +#include + +using namespace ParaMEDMEM; + +void MEDCouplingBasicsTest::testGetMeasureFieldCMesh1() +{ + MEDCouplingCMesh *m=MEDCouplingCMesh::New(); + DataArrayDouble *da=DataArrayDouble::New(); + const double discX[4]={2.3,3.4,5.8,10.2}; + const double discY[3]={12.3,23.4,45.8}; + const double discZ[5]={-0.7,1.2,1.25,2.13,2.67}; + da->alloc(4,1); + std::copy(discX,discX+4,da->getPointer()); + m->setCoordsAt(0,da); + da->decrRef(); + m->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(4,m->getNumberOfNodes()); + CPPUNIT_ASSERT_EQUAL(3,m->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(1,m->getSpaceDimension()); + MEDCouplingFieldDouble *f=m->getMeasureField(true); + CPPUNIT_ASSERT_EQUAL(3,f->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,f->getNumberOfComponents()); + const double expected1[3]={1.1,2.4,4.4}; + for(int i=0;i<3;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f->getIJ(i,0),1e-12); + f->decrRef(); + DataArrayDouble *coords=m->getCoordinatesAndOwner(); + CPPUNIT_ASSERT_EQUAL(4,coords->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,coords->getNumberOfComponents()); + for(int i=0;i<4;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(discX[i],coords->getIJ(i,0),1e-12); + coords->decrRef(); + coords=m->getBarycenterAndOwner(); + CPPUNIT_ASSERT_EQUAL(3,coords->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,coords->getNumberOfComponents()); + const double expected1_3[3]={2.85,4.6,8.}; + for(int i=0;i<3;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1_3[i],coords->getIJ(i,0),1e-12); + coords->decrRef(); + // + da=DataArrayDouble::New(); + da->alloc(3,1); + std::copy(discY,discY+3,da->getPointer()); + m->setCoordsAt(1,da); + da->decrRef(); + m->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(12,m->getNumberOfNodes()); + CPPUNIT_ASSERT_EQUAL(6,m->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(2,m->getSpaceDimension()); + f=m->getMeasureField(true); + CPPUNIT_ASSERT_EQUAL(6,f->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,f->getNumberOfComponents()); + const double expected2[6]={12.21,26.64,48.84,24.64,53.76,98.56}; + for(int i=0;i<6;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f->getIJ(i,0),1e-12); + f->decrRef(); + coords=m->getCoordinatesAndOwner(); + CPPUNIT_ASSERT_EQUAL(12,coords->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,coords->getNumberOfComponents()); + const double expected2_2[24]={2.3,12.3,3.4,12.3,5.8,12.3,10.2,12.3, 2.3,23.4,3.4,23.4,5.8,23.4,10.2,23.4, 2.3,45.8,3.4,45.8,5.8,45.8,10.2,45.8}; + for(int i=0;i<24;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2_2[i],coords->getIJ(0,i),1e-12); + coords->decrRef(); + coords=m->getBarycenterAndOwner(); + CPPUNIT_ASSERT_EQUAL(6,coords->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,coords->getNumberOfComponents()); + const double expected2_3[12]={2.85,17.85,4.6,17.85,8.,17.85, 2.85,34.6,4.6,34.6,8.,34.6}; + for(int i=0;i<12;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2_3[i],coords->getIJ(0,i),1e-12); + coords->decrRef(); + // + da=DataArrayDouble::New(); + da->alloc(5,1); + std::copy(discZ,discZ+5,da->getPointer()); + m->setCoordsAt(2,da); + da->decrRef(); + m->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(60,m->getNumberOfNodes()); + CPPUNIT_ASSERT_EQUAL(24,m->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(3,m->getSpaceDimension()); + f=m->getMeasureField(true); + CPPUNIT_ASSERT_EQUAL(24,f->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,f->getNumberOfComponents()); + const double expected3[24]={23.199, 50.616, 92.796, 46.816, 102.144, 187.264, 0.6105, 1.332, 2.442, 1.232, 2.688, 4.928, 10.7448, 23.4432, 42.9792, 21.6832, 47.3088, 86.7328, 6.5934, 14.3856, 26.3736, 13.3056, 29.0304, 53.2224}; + for(int i=0;i<24;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[i],f->getIJ(i,0),1e-12); + f->decrRef(); + coords=m->getCoordinatesAndOwner(); + CPPUNIT_ASSERT_EQUAL(60,coords->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(3,coords->getNumberOfComponents()); + const double expected3_2[180]={ + 2.3,12.3,-0.7, 3.4,12.3,-0.7, 5.8,12.3,-0.7, 10.2,12.3,-0.7, 2.3,23.4,-0.7, 3.4,23.4,-0.7, 5.8,23.4,-0.7, 10.2,23.4,-0.7, 2.3,45.8,-0.7, 3.4,45.8,-0.7, 5.8,45.8,-0.7, 10.2,45.8,-0.7, + 2.3,12.3,1.2, 3.4,12.3,1.2, 5.8,12.3,1.2, 10.2,12.3,1.2, 2.3,23.4,1.2, 3.4,23.4,1.2, 5.8,23.4,1.2, 10.2,23.4,1.2, 2.3,45.8,1.2, 3.4,45.8,1.2, 5.8,45.8,1.2, 10.2,45.8,1.2, + 2.3,12.3,1.25, 3.4,12.3,1.25, 5.8,12.3,1.25, 10.2,12.3,1.25, 2.3,23.4,1.25, 3.4,23.4,1.25, 5.8,23.4,1.25, 10.2,23.4,1.25, 2.3,45.8,1.25, 3.4,45.8,1.25, 5.8,45.8,1.25, 10.2,45.8,1.25, + 2.3,12.3,2.13, 3.4,12.3,2.13, 5.8,12.3,2.13, 10.2,12.3,2.13, 2.3,23.4,2.13, 3.4,23.4,2.13, 5.8,23.4,2.13, 10.2,23.4,2.13, 2.3,45.8,2.13, 3.4,45.8,2.13, 5.8,45.8,2.13, 10.2,45.8,2.13, + 2.3,12.3,2.67, 3.4,12.3,2.67, 5.8,12.3,2.67, 10.2,12.3,2.67, 2.3,23.4,2.67, 3.4,23.4,2.67, 5.8,23.4,2.67, 10.2,23.4,2.67, 2.3,45.8,2.67, 3.4,45.8,2.67, 5.8,45.8,2.67, 10.2,45.8,2.67 + }; + for(int i=0;i<180;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3_2[i],coords->getIJ(0,i),1e-12); + coords->decrRef(); + coords=m->getBarycenterAndOwner(); + CPPUNIT_ASSERT_EQUAL(24,coords->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(3,coords->getNumberOfComponents()); + const double expected3_3[72]={ + 2.85,17.85,0.25,4.6,17.85,0.25,8.,17.85,0.25, 2.85,34.6,0.25,4.6,34.6,0.25,8.,34.6,0.25, + 2.85,17.85,1.225,4.6,17.85,1.225,8.,17.85,1.225, 2.85,34.6,1.225,4.6,34.6,1.225,8.,34.6,1.225, + 2.85,17.85,1.69,4.6,17.85,1.69,8.,17.85,1.69, 2.85,34.6,1.69,4.6,34.6,1.69,8.,34.6,1.69, + 2.85,17.85,2.4,4.6,17.85,2.4,8.,17.85,2.4, 2.85,34.6,2.4,4.6,34.6,2.4,8.,34.6,2.4 + }; + for(int i=0;i<72;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3_3[i],coords->getIJ(0,i),1e-12); + coords->decrRef(); + // + m->decrRef(); +} + +void MEDCouplingBasicsTest::testFieldDoubleZipCoords1() +{ + MEDCouplingUMesh *m=build2DTargetMeshMergeNode_1(); + MEDCouplingFieldDouble *f=m->fillFromAnalytic(ON_NODES,2,"x*2."); + f->getArray()->setInfoOnComponent(0,"titi"); + f->getArray()->setInfoOnComponent(1,"tutu"); + f->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(18,f->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,f->getNumberOfComponents()); + const double expected1[36]={-0.6, -0.6, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 0.4, 0.4}; + for(int i=0;i<36;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f->getIJ(0,i),1e-12); + CPPUNIT_ASSERT(f->zipCoords()); + f->checkCoherency(); + const double expected2[30]={-0.6, -0.6, 1.4, 1.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 1.4, 1.4, -0.6, -0.6, 0.4, 0.4, 1.4, 1.4, 0.4, 0.4}; + for(int i=0;i<30;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f->getIJ(0,i),1e-12); + CPPUNIT_ASSERT(!f->zipCoords()); + f->checkCoherency(); + for(int i=0;i<30;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f->getIJ(0,i),1e-12); + CPPUNIT_ASSERT(std::string(f->getArray()->getInfoOnComponent(0))=="titi"); + CPPUNIT_ASSERT(std::string(f->getArray()->getInfoOnComponent(1))=="tutu"); + f->decrRef(); + m->decrRef(); +} + +void MEDCouplingBasicsTest::testFieldDoubleZipConnectivity1() +{ + MEDCouplingUMesh *m1=build2DTargetMesh_1(); + MEDCouplingUMesh *m2=build2DTargetMesh_1(); + const int cells1[3]={2,3,4}; + MEDCouplingPointSet *m3_1=m2->buildPartOfMySelf(cells1,cells1+3,true); + MEDCouplingUMesh *m3=dynamic_cast(m3_1); + CPPUNIT_ASSERT(m3); + m2->decrRef(); + MEDCouplingUMesh *m4=build2DSourceMesh_1(); + MEDCouplingUMesh *m5=MEDCouplingUMesh::MergeUMeshes(m1,m3); + m1->decrRef(); + m3->decrRef(); + MEDCouplingUMesh *m6=MEDCouplingUMesh::MergeUMeshes(m5,m4); + m4->decrRef(); + m5->decrRef(); + // + CPPUNIT_ASSERT_EQUAL(10,m6->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(22,m6->getNumberOfNodes()); + bool areNodesMerged; + int newNbOfNodes; + DataArrayInt *arr=m6->mergeNodes(1e-13,areNodesMerged,newNbOfNodes); + CPPUNIT_ASSERT_EQUAL(9,m6->getNumberOfNodes()); + arr->decrRef(); + MEDCouplingFieldDouble *f=m6->fillFromAnalytic(ON_CELLS,2,"x"); + MEDCouplingFieldDouble *f2=m6->fillFromAnalytic(ON_NODES,2,"x"); + CPPUNIT_ASSERT_EQUAL(10,f->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,f->getNumberOfComponents()); + const double expected1[20]={-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321, + -0.05, -0.05, 0.45, 0.45, 0.53333333333333321, 0.53333333333333321, -0.05, -0.05, 0.45, 0.45, + 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326}; + for(int i=0;i<20;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f->getIJ(0,i),1e-12); + f->getArray()->setInfoOnComponent(0,"titi"); + f->getArray()->setInfoOnComponent(1,"tutu"); + f->checkCoherency(); + CPPUNIT_ASSERT(f->zipConnectivity(0)); + const double expected2[14]={-0.05, -0.05, 0.3666666666666667, 0.3666666666666667, 0.53333333333333321, 0.53333333333333321, + -0.05, -0.05, 0.45, 0.45, 0.36666666666666659, 0.36666666666666659, 0.033333333333333326, 0.033333333333333326}; + CPPUNIT_ASSERT_EQUAL(7,f->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,f->getNumberOfComponents()); + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f->getIJ(0,i),1e-12); + CPPUNIT_ASSERT(std::string(f->getArray()->getInfoOnComponent(0))=="titi"); + CPPUNIT_ASSERT(std::string(f->getArray()->getInfoOnComponent(1))=="tutu"); + CPPUNIT_ASSERT(!f->zipConnectivity(0)); + f->decrRef(); + // + const double expected3[18]={-0.3, -0.3, 0.2, 0.2, 0.7, 0.7, -0.3, -0.3, 0.2, 0.2, 0.7, 0.7, + -0.3, -0.3, 0.2, 0.2, 0.7, 0.7}; + CPPUNIT_ASSERT_EQUAL(9,f2->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,f2->getNumberOfComponents()); + for(int i=0;i<18;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[i],f2->getIJ(0,i),1e-12); + CPPUNIT_ASSERT(f2->zipConnectivity(0)); + CPPUNIT_ASSERT_EQUAL(9,f2->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,f2->getNumberOfComponents()); + for(int i=0;i<18;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected3[i],f2->getIJ(0,i),1e-12); + f2->decrRef(); + // + m6->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleRenumber1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(7,2); + a->setInfoOnComponent(0,"toto"); + a->setInfoOnComponent(1,"tata"); + const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; + std::copy(arr1,arr1+14,a->getPointer()); + // + const int arr2[7]={3,1,0,6,5,4,2}; + DataArrayDouble *b=a->renumber(arr2); + CPPUNIT_ASSERT_EQUAL(7,b->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(1))=="tata"); + const double expected1[14]={3.1, 13.1, 2.1, 12.1, 7.1, 17.1, 1.1, 11.1, 6.1, 16.1, 5.1, 15.1, 4.1, 14.1}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); + b->decrRef(); + a->decrRef(); + // + DataArrayInt *c=DataArrayInt::New(); + c->alloc(7,2); + c->setInfoOnComponent(0,"toto"); + c->setInfoOnComponent(1,"tata"); + const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; + std::copy(arr3,arr3+14,c->getPointer()); + DataArrayInt *d=c->renumber(arr2); + CPPUNIT_ASSERT_EQUAL(7,d->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,d->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(1))=="tata"); + const int expected2[14]={3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],d->getIJ(0,i)); + c->decrRef(); + d->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleRenumberAndReduce1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(7,2); + a->setInfoOnComponent(0,"toto"); + a->setInfoOnComponent(1,"tata"); + const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; + std::copy(arr1,arr1+14,a->getPointer()); + // + const int arr2[7]={2,-1,1,-1,0,4,3}; + DataArrayDouble *b=a->renumberAndReduce(arr2,5); + CPPUNIT_ASSERT_EQUAL(5,b->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(1))=="tata"); + const double expected1[10]={5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1}; + for(int i=0;i<10;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); + b->decrRef(); + a->decrRef(); + // + DataArrayInt *c=DataArrayInt::New(); + c->alloc(7,2); + c->setInfoOnComponent(0,"toto"); + c->setInfoOnComponent(1,"tata"); + const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; + std::copy(arr3,arr3+14,c->getPointer()); + DataArrayInt *d=c->renumberAndReduce(arr2,5); + CPPUNIT_ASSERT_EQUAL(5,d->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,d->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(1))=="tata"); + const int expected2[10]={5,15,3,13,1,11,7,17,6,16}; + for(int i=0;i<10;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],d->getIJ(0,i)); + c->decrRef(); + d->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleRenumberInPlace1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(7,2); + const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; + std::copy(arr1,arr1+14,a->getPointer()); + // + const int arr2[7]={3,1,0,6,5,4,2}; + a->renumberInPlace(arr2); + CPPUNIT_ASSERT_EQUAL(7,a->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,a->getNumberOfComponents()); + const double expected1[14]={3.1, 13.1, 2.1, 12.1, 7.1, 17.1, 1.1, 11.1, 6.1, 16.1, 5.1, 15.1, 4.1, 14.1}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],a->getIJ(0,i),1e-14); + a->decrRef(); + // + DataArrayInt *c=DataArrayInt::New(); + c->alloc(7,2); + const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; + std::copy(arr3,arr3+14,c->getPointer()); + c->renumberInPlace(arr2); + CPPUNIT_ASSERT_EQUAL(7,c->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,c->getNumberOfComponents()); + const int expected2[14]={3, 13, 2, 12, 7, 17, 1, 11, 6, 16, 5, 15, 4, 14}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],c->getIJ(0,i)); + c->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleRenumberR1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(7,2); + a->setInfoOnComponent(0,"toto"); + a->setInfoOnComponent(1,"tata"); + const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; + std::copy(arr1,arr1+14,a->getPointer()); + // + const int arr2[7]={3,1,0,6,5,4,2}; + DataArrayDouble *b=a->renumberR(arr2); + CPPUNIT_ASSERT_EQUAL(7,b->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(1))=="tata"); + const double expected1[14]={4.1, 14.1, 2.1, 12.1, 1.1, 11.1, 7.1, 17.1, 6.1, 16.1, 5.1, 15.1, 3.1, 13.1}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); + b->decrRef(); + a->decrRef(); + // + DataArrayInt *c=DataArrayInt::New(); + c->alloc(7,2); + c->setInfoOnComponent(0,"toto"); + c->setInfoOnComponent(1,"tata"); + const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; + std::copy(arr3,arr3+14,c->getPointer()); + DataArrayInt *d=c->renumberR(arr2); + CPPUNIT_ASSERT_EQUAL(7,d->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,d->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(1))=="tata"); + const int expected2[14]={4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],d->getIJ(0,i)); + c->decrRef(); + d->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleRenumberInPlaceR1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(7,2); + const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; + std::copy(arr1,arr1+14,a->getPointer()); + // + const int arr2[7]={3,1,0,6,5,4,2}; + a->renumberInPlaceR(arr2); + CPPUNIT_ASSERT_EQUAL(7,a->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,a->getNumberOfComponents()); + const double expected1[14]={4.1, 14.1, 2.1, 12.1, 1.1, 11.1, 7.1, 17.1, 6.1, 16.1, 5.1, 15.1, 3.1, 13.1}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],a->getIJ(0,i),1e-14); + a->decrRef(); + // + DataArrayInt *c=DataArrayInt::New(); + c->alloc(7,2); + const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; + std::copy(arr3,arr3+14,c->getPointer()); + c->renumberInPlaceR(arr2); + CPPUNIT_ASSERT_EQUAL(7,c->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,c->getNumberOfComponents()); + const int expected2[14]={4, 14, 2, 12, 1, 11, 7, 17, 6, 16, 5, 15, 3, 13}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],c->getIJ(0,i)); + c->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleSelectByTupleId1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(7,2); + a->setInfoOnComponent(0,"toto"); + a->setInfoOnComponent(1,"tata"); + const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; + std::copy(arr1,arr1+14,a->getPointer()); + // + const int arr2[7]={4,2,0,6,5}; + DataArrayDouble *b=a->selectByTupleId(arr2,arr2+5); + CPPUNIT_ASSERT_EQUAL(5,b->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(1))=="tata"); + const double expected1[10]={5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1}; + for(int i=0;i<10;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); + b->decrRef(); + a->decrRef(); + // + DataArrayInt *c=DataArrayInt::New(); + c->alloc(7,2); + c->setInfoOnComponent(0,"toto"); + c->setInfoOnComponent(1,"tata"); + const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; + std::copy(arr3,arr3+14,c->getPointer()); + DataArrayInt *d=c->selectByTupleId(arr2,arr2+5); + CPPUNIT_ASSERT_EQUAL(5,d->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,d->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(1))=="tata"); + const int expected2[10]={5,15,3,13,1,11,7,17,6,16}; + for(int i=0;i<10;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],d->getIJ(0,i)); + c->decrRef(); + d->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleGetMinMaxValues1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(9,1); + const double arr1[9]={2.34,4.56,-6.77,4.55,4.56,2.24,2.34,1.02,4.56}; + std::copy(arr1,arr1+9,a->getPointer()); + int where; + double m=a->getMaxValue(where); + CPPUNIT_ASSERT_EQUAL(1,where); + CPPUNIT_ASSERT_DOUBLES_EQUAL(4.56,m,1e-12); + DataArrayInt *ws; + m=a->getMaxValue2(ws); + CPPUNIT_ASSERT_DOUBLES_EQUAL(4.56,m,1e-12); + CPPUNIT_ASSERT_EQUAL(3,ws->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,ws->getNumberOfComponents()); + const int expected1[3]={1,4,8}; + for(int i=0;i<3;i++) + CPPUNIT_ASSERT_EQUAL(expected1[i],ws->getIJ(i,0)); + ws->decrRef(); + a->decrRef(); + a=DataArrayDouble::New(); + const double arr2[9]={-2.34,-4.56,6.77,-4.55,-4.56,-2.24,-2.34,-1.02,-4.56}; + a->alloc(9,1); + std::copy(arr2,arr2+9,a->getPointer()); + where=-2; + m=a->getMinValue(where); + CPPUNIT_ASSERT_EQUAL(1,where); + CPPUNIT_ASSERT_DOUBLES_EQUAL(-4.56,m,1e-12); + m=a->getMinValue2(ws); + CPPUNIT_ASSERT_DOUBLES_EQUAL(-4.56,m,1e-12); + CPPUNIT_ASSERT_EQUAL(3,ws->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,ws->getNumberOfComponents()); + for(int i=0;i<3;i++) + CPPUNIT_ASSERT_EQUAL(expected1[i],ws->getIJ(i,0)); + ws->decrRef(); + a->decrRef(); +} + +void MEDCouplingBasicsTest::testFieldDoubleGetMinMaxValues2() +{ + MEDCouplingUMesh *m1=0; + MEDCouplingUMesh *m2=build3DExtrudedUMesh_1(m1); + m1->decrRef(); + CPPUNIT_ASSERT_EQUAL(18,m2->getNumberOfCells()); + const double arr1[18]={8.71,4.53,-12.41,8.71,-8.71,8.7099,4.55,8.71,5.55,6.77,-1e-200,4.55,8.7099,0.,1.23,0.,2.22,8.71}; + MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME); + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(18,1); + std::copy(arr1,arr1+18,a->getPointer()); + f->setArray(a); + a->decrRef(); + f->setMesh(m2); + // + f->checkCoherency(); + double m=f->getMaxValue(); + CPPUNIT_ASSERT_DOUBLES_EQUAL(8.71,m,1e-12); + DataArrayInt *ws; + m=f->getMaxValue2(ws); + CPPUNIT_ASSERT_DOUBLES_EQUAL(8.71,m,1e-12); + CPPUNIT_ASSERT_EQUAL(4,ws->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,ws->getNumberOfComponents()); + const int expected1[4]={0,3,7,17}; + for(int i=0;i<4;i++) + CPPUNIT_ASSERT_EQUAL(expected1[i],ws->getIJ(i,0)); + ws->decrRef(); + // + const double arr2[18]={-8.71,-4.53,12.41,-8.71,8.71,-8.7099,-4.55,-8.71,-5.55,-6.77,1e-200,-4.55,-8.7099,0.,-1.23,0.,-2.22,-8.71}; + std::copy(arr2,arr2+18,a->getPointer()); + f->checkCoherency(); + m=f->getMinValue(); + CPPUNIT_ASSERT_DOUBLES_EQUAL(-8.71,m,1e-12); + m=f->getMinValue2(ws); + CPPUNIT_ASSERT_DOUBLES_EQUAL(-8.71,m,1e-12); + CPPUNIT_ASSERT_EQUAL(4,ws->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,ws->getNumberOfComponents()); + for(int i=0;i<4;i++) + CPPUNIT_ASSERT_EQUAL(expected1[i],ws->getIJ(i,0)); + ws->decrRef(); + // + f->decrRef(); + m2->decrRef(); +} + +void MEDCouplingBasicsTest::testBuildUnstructuredCMesh1() +{ + MEDCouplingCMesh *m=MEDCouplingCMesh::New(); + DataArrayDouble *da=DataArrayDouble::New(); + const double discX[4]={2.3,3.4,5.8,10.2}; + const double discY[3]={12.3,23.4,45.8}; + const double discZ[5]={-0.7,1.2,1.25,2.13,2.67}; + da->alloc(4,1); + std::copy(discX,discX+4,da->getPointer()); + m->setCoordsAt(0,da); + da->decrRef(); + m->checkCoherency(); + double pos=2.4; + CPPUNIT_ASSERT_EQUAL(0,m->getCellContainingPoint(&pos,1e-12)); + pos=3.7; + CPPUNIT_ASSERT_EQUAL(1,m->getCellContainingPoint(&pos,1e-12)); + pos=5.9; + CPPUNIT_ASSERT_EQUAL(2,m->getCellContainingPoint(&pos,1e-12)); + pos=10.3; + CPPUNIT_ASSERT_EQUAL(-1,m->getCellContainingPoint(&pos,1e-12)); + pos=1.3; + CPPUNIT_ASSERT_EQUAL(-1,m->getCellContainingPoint(&pos,1e-12)); + // + MEDCouplingUMesh *m2=m->buildUnstructured(); + m2->checkCoherency(); + MEDCouplingFieldDouble *f1=m->getMeasureField(false); + MEDCouplingFieldDouble *f2=m2->getMeasureField(false); + CPPUNIT_ASSERT_EQUAL(f1->getNumberOfTuples(),3); + CPPUNIT_ASSERT_EQUAL(f2->getNumberOfTuples(),3); + CPPUNIT_ASSERT_EQUAL(1,m2->getMeshDimension()); + CPPUNIT_ASSERT_EQUAL(1,m2->getSpaceDimension()); + for(int i=0;i<3;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(f1->getIJ(i,0),f2->getIJ(i,0),1e-10); + da=DataArrayDouble::New(); + da->alloc(3,1); + std::copy(discY,discY+3,da->getPointer()); + m->setCoordsAt(1,da); + da->decrRef(); + m2->decrRef(); + f1->decrRef(); + f2->decrRef(); + // + m2=m->buildUnstructured(); + m2->checkCoherency(); + f1=m->getMeasureField(false); + f2=m2->getMeasureField(false); + CPPUNIT_ASSERT_EQUAL(f1->getNumberOfTuples(),6); + CPPUNIT_ASSERT_EQUAL(f2->getNumberOfTuples(),6); + CPPUNIT_ASSERT_EQUAL(2,m2->getMeshDimension()); + CPPUNIT_ASSERT_EQUAL(2,m2->getSpaceDimension()); + for(int i=0;i<6;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(f1->getIJ(i,0),f2->getIJ(i,0),1e-10); + f1->decrRef(); + f2->decrRef(); + m2->decrRef(); + // + da=DataArrayDouble::New(); + da->alloc(5,1); + std::copy(discZ,discZ+5,da->getPointer()); + m->setCoordsAt(2,da); + da->decrRef(); + m2=m->buildUnstructured(); + m2->checkCoherency(); + f1=m->getMeasureField(false); + f2=m2->getMeasureField(false); + CPPUNIT_ASSERT_EQUAL(f1->getNumberOfTuples(),24); + CPPUNIT_ASSERT_EQUAL(f2->getNumberOfTuples(),24); + CPPUNIT_ASSERT_EQUAL(3,m2->getMeshDimension()); + CPPUNIT_ASSERT_EQUAL(3,m2->getSpaceDimension()); + for(int i=0;i<24;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(f1->getIJ(i,0),f2->getIJ(i,0),1e-10); + f1->decrRef(); + f2->decrRef(); + // + double pos1[3]={5.,30.,2.}; + CPPUNIT_ASSERT_EQUAL(16,m->getCellContainingPoint(pos1,1e-12)); + // + const double pt[3]={2.4,12.7,-3.4}; + m->scale(pt,3.7); + MEDCouplingUMesh *m3=m->buildUnstructured(); + m2->scale(pt,3.7); + CPPUNIT_ASSERT(m3->isEqual(m2,1e-12)); + m2->decrRef(); + m3->decrRef(); + // + m->decrRef(); +} + +void MEDCouplingBasicsTest::testDataArrayIntInvertO2NNO21() +{ + const int arr1[6]={2,0,4,1,5,3}; + DataArrayInt *da=DataArrayInt::New(); + da->alloc(6,1); + std::copy(arr1,arr1+6,da->getPointer()); + DataArrayInt *da2=da->invertArrayO2N2N2O(6); + CPPUNIT_ASSERT_EQUAL(6,da2->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,da2->getNumberOfComponents()); + const int expected1[6]={1,3,0,5,2,4}; + for(int i=0;i<6;i++) + CPPUNIT_ASSERT_EQUAL(expected1[i],da2->getIJ(i,0)); + DataArrayInt *da3=da2->invertArrayN2O2O2N(6); + for(int i=0;i<6;i++) + CPPUNIT_ASSERT_EQUAL(arr1[i],da3->getIJ(i,0)); + da3->decrRef(); + da2->decrRef(); + da->decrRef(); + // + const int arr2[10]={3,-1,5,4,-1,0,-1,1,2,-1}; + da=DataArrayInt::New(); + da->alloc(10,1); + std::copy(arr2,arr2+10,da->getPointer()); + da2=da->invertArrayO2N2N2O(6); + CPPUNIT_ASSERT_EQUAL(6,da2->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,da2->getNumberOfComponents()); + const int expected2[10]={5,7,8,0,3,2}; + for(int i=0;i<6;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],da2->getIJ(i,0)); + da3=da2->invertArrayN2O2O2N(10); + for(int i=0;i<10;i++) + CPPUNIT_ASSERT_EQUAL(arr2[i],da3->getIJ(i,0)); + da3->decrRef(); + da2->decrRef(); + da->decrRef(); +} + +void MEDCouplingBasicsTest::testKeepSetSelectedComponent1() +{ + const double arr1[20]={1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.}; + DataArrayDouble *a1=DataArrayDouble::New(); + a1->alloc(5,4); + std::copy(arr1,arr1+20,a1->getPointer()); + a1->setInfoOnComponent(0,"aaaa"); + a1->setInfoOnComponent(1,"bbbb"); + a1->setInfoOnComponent(2,"cccc"); + a1->setInfoOnComponent(3,"dddd"); + const int arr2[6]={1,2,1,2,0,0}; + std::vector arr2V(arr2,arr2+6); + DataArrayDouble *a2=a1->keepSelectedComponents(arr2V); + CPPUNIT_ASSERT_EQUAL(6,a2->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(5,a2->getNumberOfTuples()); + CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(0))=="bbbb"); + CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(1))=="cccc"); + CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(2))=="bbbb"); + CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(3))=="cccc"); + CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(4))=="aaaa"); + CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(5))=="aaaa"); + const double expected1[30]={2.,3.,2.,3.,1.,1., 12.,13.,12.,13.,11.,11., 22.,23.,22.,23.,21.,21., 32.,33.,32.,33.,31.,31., 42.,43.,42.,43.,41.,41.}; + for(int i=0;i<30;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],a2->getIJ(0,i),1e-14); + DataArrayInt *a3=a1->convertToIntArr(); + DataArrayInt *a4=a3->keepSelectedComponents(arr2V); + CPPUNIT_ASSERT_EQUAL(6,a4->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(5,a4->getNumberOfTuples()); + CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(0))=="bbbb"); + CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(1))=="cccc"); + CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(2))=="bbbb"); + CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(3))=="cccc"); + CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(4))=="aaaa"); + CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(5))=="aaaa"); + for(int i=0;i<30;i++) + CPPUNIT_ASSERT_EQUAL(int(expected1[i]),a4->getIJ(0,i)); + // setSelectedComponents + const int arr3[2]={3,2}; + std::vector arr3V(arr3,arr3+2); + DataArrayDouble *a5=a1->keepSelectedComponents(arr3V); + a5->setInfoOnComponent(0,"eeee"); + a5->setInfoOnComponent(1,"ffff"); + const int arr4[2]={1,2}; + std::vector arr4V(arr4,arr4+2); + a2->setSelectedComponents(a5,arr4V); + CPPUNIT_ASSERT_EQUAL(6,a2->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(5,a2->getNumberOfTuples()); + CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(0))=="bbbb"); + CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(1))=="eeee"); + CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(2))=="ffff"); + CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(3))=="cccc"); + CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(4))=="aaaa"); + CPPUNIT_ASSERT(std::string(a2->getInfoOnComponent(5))=="aaaa"); + const double expected2[30]={2.,4.,3.,3.,1.,1., 12.,14.,13.,13.,11.,11., 22.,24.,23.,23.,21.,21., 32.,34.,33.,33.,31.,31., 42.,44.,43.,43.,41.,41.}; + for(int i=0;i<30;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],a2->getIJ(0,i),1e-14); + DataArrayInt *a6=a5->convertToIntArr(); + a6->setInfoOnComponent(0,"eeee"); + a6->setInfoOnComponent(1,"ffff"); + a4->setSelectedComponents(a6,arr4V); + CPPUNIT_ASSERT_EQUAL(6,a4->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(5,a4->getNumberOfTuples()); + CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(0))=="bbbb"); + CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(1))=="eeee"); + CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(2))=="ffff"); + CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(3))=="cccc"); + CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(4))=="aaaa"); + CPPUNIT_ASSERT(std::string(a4->getInfoOnComponent(5))=="aaaa"); + for(int i=0;i<30;i++) + CPPUNIT_ASSERT_EQUAL(int(expected2[i]),a4->getIJ(0,i)); + // test of throw + const int arr5[3]={2,3,6}; + const int arr6[3]={2,7,5}; + const int arr7[4]={2,1,4,6}; + std::vector arr5V(arr5,arr5+3); + std::vector arr6V(arr6,arr6+3); + std::vector arr7V(arr7,arr7+4); + CPPUNIT_ASSERT_THROW(a2->keepSelectedComponents(arr5V),INTERP_KERNEL::Exception); + CPPUNIT_ASSERT_THROW(a2->keepSelectedComponents(arr6V),INTERP_KERNEL::Exception); + CPPUNIT_ASSERT_THROW(a2->setSelectedComponents(a1,arr7V),INTERP_KERNEL::Exception); + arr7V.resize(3); + CPPUNIT_ASSERT_THROW(a2->setSelectedComponents(a1,arr7V),INTERP_KERNEL::Exception); + // + a6->decrRef(); + a5->decrRef(); + a4->decrRef(); + a3->decrRef(); + a2->decrRef(); + a1->decrRef(); +} + +void MEDCouplingBasicsTest::testKeepSetSelectedComponent2() +{ + MEDCouplingUMesh *m1=build2DTargetMesh_1(); + const double arr1[20]={1.,2.,3.,4., 11.,12.,13.,14., 21.,22.,23.,24., 31.,32.,33.,34., 41.,42.,43.,44.}; + DataArrayDouble *a1=DataArrayDouble::New(); + a1->alloc(5,4); + std::copy(arr1,arr1+20,a1->getPointer()); + a1->setInfoOnComponent(0,"aaaa"); + a1->setInfoOnComponent(1,"bbbb"); + a1->setInfoOnComponent(2,"cccc"); + a1->setInfoOnComponent(3,"dddd"); + MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); + f1->setTime(2.3,4,5); + f1->setMesh(m1); + f1->setName("f1"); + f1->setArray(a1); + f1->checkCoherency(); + // + const int arr2[6]={1,2,1,2,0,0}; + std::vector arr2V(arr2,arr2+6); + MEDCouplingFieldDouble *f2=f1->keepSelectedComponents(arr2V); + CPPUNIT_ASSERT(f2->getMesh()==f1->getMesh()); + CPPUNIT_ASSERT(f2->getTimeDiscretization()==ONE_TIME); + int dt,it; + CPPUNIT_ASSERT_DOUBLES_EQUAL(2.3,f2->getTime(dt,it),1e-13); + CPPUNIT_ASSERT_EQUAL(4,dt); + CPPUNIT_ASSERT_EQUAL(5,it); + f2->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(6,f2->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples()); + CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(0))=="bbbb"); + CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(1))=="cccc"); + CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(2))=="bbbb"); + CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(3))=="cccc"); + CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(4))=="aaaa"); + CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(5))=="aaaa"); + const double expected1[30]={2.,3.,2.,3.,1.,1., 12.,13.,12.,13.,11.,11., 22.,23.,22.,23.,21.,21., 32.,33.,32.,33.,31.,31., 42.,43.,42.,43.,41.,41.}; + for(int i=0;i<30;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f2->getIJ(0,i),1e-14); + //setSelectedComponents + const int arr3[2]={3,2}; + std::vector arr3V(arr3,arr3+2); + MEDCouplingFieldDouble *f5=f1->keepSelectedComponents(arr3V); + f5->setTime(6.7,8,9); + f5->getArray()->setInfoOnComponent(0,"eeee"); + f5->getArray()->setInfoOnComponent(1,"ffff"); + f5->checkCoherency(); + const int arr4[2]={1,2}; + std::vector arr4V(arr4,arr4+2); + f2->setSelectedComponents(f5,arr4V); + CPPUNIT_ASSERT_EQUAL(6,f2->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(5,f2->getNumberOfTuples()); + f2->checkCoherency(); + CPPUNIT_ASSERT_DOUBLES_EQUAL(2.3,f2->getTime(dt,it),1e-13); + CPPUNIT_ASSERT_EQUAL(4,dt); + CPPUNIT_ASSERT_EQUAL(5,it); + CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(0))=="bbbb"); + CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(1))=="eeee"); + CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(2))=="ffff"); + CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(3))=="cccc"); + CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(4))=="aaaa"); + CPPUNIT_ASSERT(std::string(f2->getArray()->getInfoOnComponent(5))=="aaaa"); + const double expected2[30]={2.,4.,3.,3.,1.,1., 12.,14.,13.,13.,11.,11., 22.,24.,23.,23.,21.,21., 32.,34.,33.,33.,31.,31., 42.,44.,43.,43.,41.,41.}; + for(int i=0;i<30;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f2->getIJ(0,i),1e-14); + f5->decrRef(); + f1->decrRef(); + f2->decrRef(); + a1->decrRef(); + m1->decrRef(); +} + +void MEDCouplingBasicsTest::testDAIGetIdsEqual1() +{ + const int tab1[7]={5,-2,-4,-2,3,2,-2}; + DataArrayInt *da=DataArrayInt::New(); + da->alloc(7,1); + std::copy(tab1,tab1+7,da->getPointer()); + DataArrayInt *da2=da->getIdsEqual(-2); + CPPUNIT_ASSERT_EQUAL(3,da2->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,da2->getNumberOfComponents()); + const int expected1[3]={1,3,6}; + CPPUNIT_ASSERT(std::equal(expected1,expected1+3,da2->getConstPointer())); + da2->decrRef(); + da->decrRef(); +} + +void MEDCouplingBasicsTest::testDAIGetIdsEqualList1() +{ + const int tab1[7]={5,-2,-4,-2,3,2,-2}; + DataArrayInt *da=DataArrayInt::New(); + da->alloc(7,1); + std::copy(tab1,tab1+7,da->getPointer()); + const int tab2[3]={3,-2,0}; + std::vector tab2V(tab2,tab2+3); + DataArrayInt *da2=da->getIdsEqualList(tab2V); + CPPUNIT_ASSERT_EQUAL(4,da2->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,da2->getNumberOfComponents()); + const int expected1[4]={1,3,4,6}; + CPPUNIT_ASSERT(std::equal(expected1,expected1+4,da2->getConstPointer())); + da2->decrRef(); + da->decrRef(); +} + +void MEDCouplingBasicsTest::testDAFromNoInterlace1() +{ + const int tab1[15]={1,11,21,31,41,2,12,22,32,42,3,13,23,33,43}; + DataArrayInt *da=DataArrayInt::New(); + da->alloc(5,3); + std::copy(tab1,tab1+15,da->getPointer()); + DataArrayInt *da2=da->fromNoInterlace(); + const int expected1[15]={1,2,3,11,12,13,21,22,23,31,32,33,41,42,43}; + CPPUNIT_ASSERT_EQUAL(5,da2->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(3,da2->getNumberOfComponents());// it's not a bug. Avoid to have 1 million components ! + CPPUNIT_ASSERT(std::equal(expected1,expected1+15,da2->getConstPointer())); + DataArrayDouble *da3=da->convertToDblArr(); + DataArrayDouble *da4=da3->fromNoInterlace(); + CPPUNIT_ASSERT_EQUAL(5,da4->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(3,da4->getNumberOfComponents());// it's not a bug. Avoid to have 1 million components ! + for(int i=0;i<15;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL((double)expected1[i],da4->getIJ(0,i),1e-14); + da4->decrRef(); + da3->decrRef(); + da2->decrRef(); + da->decrRef(); +} + +void MEDCouplingBasicsTest::testDAToNoInterlace1() +{ + const int tab1[15]={1,2,3,11,12,13,21,22,23,31,32,33,41,42,43}; + DataArrayInt *da=DataArrayInt::New(); + da->alloc(5,3); + std::copy(tab1,tab1+15,da->getPointer()); + DataArrayInt *da2=da->toNoInterlace(); + const int expected1[15]={1,11,21,31,41,2,12,22,32,42,3,13,23,33,43}; + CPPUNIT_ASSERT_EQUAL(5,da2->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(3,da2->getNumberOfComponents());// it's not a bug. Avoid to have 1 million components ! + CPPUNIT_ASSERT(std::equal(expected1,expected1+15,da2->getConstPointer())); + DataArrayDouble *da3=da->convertToDblArr(); + DataArrayDouble *da4=da3->toNoInterlace(); + CPPUNIT_ASSERT_EQUAL(5,da4->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(3,da4->getNumberOfComponents());// it's not a bug. Avoid to have 1 million components ! + for(int i=0;i<15;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL((double)expected1[i],da4->getIJ(0,i),1e-14); + da4->decrRef(); + da3->decrRef(); + da2->decrRef(); + da->decrRef(); +} + +void MEDCouplingBasicsTest::testDAIsUniform1() +{ + const int tab1[5]={1,1,1,1,1}; + DataArrayInt *da=DataArrayInt::New(); + da->alloc(5,1); + std::copy(tab1,tab1+5,da->getPointer()); + CPPUNIT_ASSERT(da->isUniform(1)); + da->setIJ(2,0,2); + CPPUNIT_ASSERT(!da->isUniform(1)); + da->setIJ(2,0,1); + CPPUNIT_ASSERT(da->isUniform(1)); + DataArrayDouble *da2=da->convertToDblArr(); + CPPUNIT_ASSERT(da2->isUniform(1.,1e-12)); + da2->setIJ(1,0,1.+1.e-13); + CPPUNIT_ASSERT(da2->isUniform(1.,1e-12)); + da2->setIJ(1,0,1.+1.e-11); + CPPUNIT_ASSERT(!da2->isUniform(1.,1e-12)); + da2->decrRef(); + da->decrRef(); +} + +void MEDCouplingBasicsTest::testDADFromPolarToCart1() +{ + const double tab1[4]={2.,0.2,2.5,0.7}; + DataArrayDouble *da=DataArrayDouble::New(); + da->alloc(2,2); + std::copy(tab1,tab1+4,da->getPointer()); + DataArrayDouble *da2=da->fromPolarToCart(); + const double expected1[4]={1.9601331556824833,0.39733866159012243, 1.9121054682112213,1.6105442180942275}; + for(int i=0;i<4;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],da2->getIJ(0,i),1e-13); + da2->decrRef(); + da->decrRef(); +} + +void MEDCouplingBasicsTest::testDADFromCylToCart1() +{ + const double tab1[6]={2.,0.2,4.,2.5,0.7,9.}; + DataArrayDouble *da=DataArrayDouble::New(); + da->alloc(2,3); + std::copy(tab1,tab1+6,da->getPointer()); + DataArrayDouble *da2=da->fromCylToCart(); + const double expected1[6]={1.9601331556824833,0.39733866159012243,4., 1.9121054682112213,1.6105442180942275,9.}; + for(int i=0;i<6;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],da2->getIJ(0,i),1e-13); + da2->decrRef(); + da->decrRef(); +} + +void MEDCouplingBasicsTest::testDADFromSpherToCart1() +{ + const double tab1[6]={2.,0.2,0.3,2.5,0.7,0.8}; + DataArrayDouble *da=DataArrayDouble::New(); + da->alloc(2,3); + std::copy(tab1,tab1+6,da->getPointer()); + DataArrayDouble *da2=da->fromSpherToCart(); + const double expected1[6]={0.37959212195737485,0.11742160338765303,1.9601331556824833, 1.1220769624465328,1.1553337045129035,1.9121054682112213}; + for(int i=0;i<6;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],da2->getIJ(0,i),1e-13); + da2->decrRef(); + da->decrRef(); +} + +void MEDCouplingBasicsTest::testUnPolyze1() +{ + const int elts[8]={0,1,2,3,4,5,6,7}; + std::vector eltsV(elts,elts+8); + MEDCouplingUMesh *mesh=build3DTargetMesh_1(); + mesh->convertToPolyTypes(eltsV); + mesh->unPolyze(); + MEDCouplingUMesh *mesh2=build3DTargetMesh_1(); + mesh->checkCoherency(); + CPPUNIT_ASSERT(mesh->isEqual(mesh2,1e-12)); + mesh->convertToPolyTypes(eltsV); + CPPUNIT_ASSERT(!mesh->isEqual(mesh2,1e-12)); + mesh->getNodalConnectivity()->setIJ(0,6,10); + mesh->getNodalConnectivity()->setIJ(0,7,9); + mesh->getNodalConnectivity()->setIJ(0,8,12); + mesh->getNodalConnectivity()->setIJ(0,9,13); + mesh->unPolyze(); + CPPUNIT_ASSERT(mesh->isEqual(mesh2,1e-12)); + mesh->convertToPolyTypes(eltsV); + mesh->getNodalConnectivity()->setIJ(0,6,12); + mesh->getNodalConnectivity()->setIJ(0,7,13); + mesh->getNodalConnectivity()->setIJ(0,8,10); + mesh->getNodalConnectivity()->setIJ(0,9,9); + mesh->unPolyze(); + CPPUNIT_ASSERT(mesh->isEqual(mesh2,1e-12)); + mesh->convertToPolyTypes(eltsV); + mesh->getNodalConnectivity()->setIJ(0,6,12); + mesh->getNodalConnectivity()->setIJ(0,7,10); + mesh->getNodalConnectivity()->setIJ(0,8,13); + mesh->getNodalConnectivity()->setIJ(0,9,9); + mesh->unPolyze(); + CPPUNIT_ASSERT(!mesh->isEqual(mesh2,1e-12)); + mesh->decrRef(); + mesh2->decrRef(); + // Test for 2D mesh + mesh=build2DTargetMesh_1(); + mesh2=build2DTargetMesh_1(); + eltsV.resize(5); + mesh->convertToPolyTypes(eltsV); + CPPUNIT_ASSERT(!mesh->isEqual(mesh2,1e-12)); + mesh->unPolyze(); + CPPUNIT_ASSERT(mesh->isEqual(mesh2,1e-12)); + mesh->decrRef(); + mesh2->decrRef(); +} + +void MEDCouplingBasicsTest::testConvertDegeneratedCells1() +{ + MEDCouplingUMesh *mesh=build3DTargetMesh_1(); + int conn[32]={0,1,3,3,9,10,12,12, 0,1,3,4,9,9,9,9, 1,1,1,1,10,12,9,10, 10,11,12,9,1,1,1,1}; + mesh->allocateCells(4); + mesh->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn); + mesh->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+8); + mesh->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+16); + mesh->insertNextCell(INTERP_KERNEL::NORM_HEXA8,8,conn+24); + mesh->finishInsertingCells(); + mesh->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(4,mesh->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_HEXA8,mesh->getTypeOfCell(0)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_HEXA8,mesh->getTypeOfCell(1)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_HEXA8,mesh->getTypeOfCell(2)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_HEXA8,mesh->getTypeOfCell(3)); + MEDCouplingFieldDouble *f1=mesh->getMeasureField(true); + mesh->convertDegeneratedCells(); + mesh->checkCoherency(); + MEDCouplingFieldDouble *f2=mesh->getMeasureField(true); + CPPUNIT_ASSERT_EQUAL(4,mesh->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_PENTA6,mesh->getTypeOfCell(0)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_PYRA5,mesh->getTypeOfCell(1)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TETRA4,mesh->getTypeOfCell(2)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_PYRA5,mesh->getTypeOfCell(3)); + for(int i=0;i<4;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(f1->getArray()->getIJ(0,i),f2->getArray()->getIJ(0,i),1e-5); + f1->decrRef(); + f2->decrRef(); + mesh->decrRef(); +} + +void MEDCouplingBasicsTest::testGetNodeIdsNearPoints1() +{ + MEDCouplingUMesh *mesh=build2DTargetMesh_1(); + DataArrayDouble *coords=mesh->getCoords(); + DataArrayDouble *tmp=DataArrayDouble::New(); + tmp->alloc(3,2); + const double vals[6]={0.2,0.2,0.1,0.2,0.2,0.2}; + std::copy(vals,vals+6,tmp->getPointer()); + DataArrayDouble *tmp2=DataArrayDouble::Aggregate(coords,tmp); + tmp->decrRef(); + mesh->setCoords(tmp2); + tmp2->decrRef(); + const double pts[6]={0.2,0.2,0.1,0.3,-0.3,0.7}; + std::vector c=mesh->getNodeIdsNearPoint(pts,1e-7); + CPPUNIT_ASSERT_EQUAL(3,(int)c.size()); + CPPUNIT_ASSERT_EQUAL(4,c[0]); + CPPUNIT_ASSERT_EQUAL(9,c[1]); + CPPUNIT_ASSERT_EQUAL(11,c[2]); + c.clear(); + std::vector cI; + mesh->getNodeIdsNearPoints(pts,3,1e-7,c,cI); + CPPUNIT_ASSERT_EQUAL(4,(int)cI.size()); + CPPUNIT_ASSERT_EQUAL(4,(int)c.size()); + CPPUNIT_ASSERT_EQUAL(4,c[0]); + CPPUNIT_ASSERT_EQUAL(9,c[1]); + CPPUNIT_ASSERT_EQUAL(11,c[2]); + CPPUNIT_ASSERT_EQUAL(6,c[3]); + CPPUNIT_ASSERT_EQUAL(0,cI[0]); + CPPUNIT_ASSERT_EQUAL(3,cI[1]); + CPPUNIT_ASSERT_EQUAL(3,cI[2]); + CPPUNIT_ASSERT_EQUAL(4,cI[3]); + mesh->decrRef(); +} + +void MEDCouplingBasicsTest::testFieldCopyTinyAttrFrom1() +{ + MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); + f1->setName("f1"); + f1->setTimeTolerance(1.e-5); + f1->setDescription("f1Desc"); + f1->setTime(1.23,4,5); + MEDCouplingFieldDouble *f2=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); + f2->setName("f2"); + f2->setDescription("f2Desc"); + f2->setTime(6.78,9,10); + f2->setTimeTolerance(4.556e-12); + // + int dt,it; + f1->copyTinyAttrFrom(f2); + CPPUNIT_ASSERT_DOUBLES_EQUAL(4.556e-12,f1->getTimeTolerance(),1e-24); + CPPUNIT_ASSERT_DOUBLES_EQUAL(6.78,f1->getTime(dt,it),1e-12); + CPPUNIT_ASSERT_EQUAL(9,dt); + CPPUNIT_ASSERT_EQUAL(10,it); + CPPUNIT_ASSERT(std::string(f1->getName())=="f1");//name unchanged + CPPUNIT_ASSERT(std::string(f1->getDescription())=="f1Desc");//description unchanged + f1->decrRef(); + f2->decrRef(); + // + f1=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME); + f1->setName("f1"); + f1->setTimeTolerance(1.e-5); + f1->setDescription("f1Desc"); + f2=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME); + f2->setName("f2"); + f2->setDescription("f2Desc"); + f2->setTimeTolerance(4.556e-12); + // + f1->copyTinyAttrFrom(f2); + CPPUNIT_ASSERT_DOUBLES_EQUAL(4.556e-12,f1->getTimeTolerance(),1e-24); + CPPUNIT_ASSERT(std::string(f1->getName())=="f1");//name unchanged + CPPUNIT_ASSERT(std::string(f1->getDescription())=="f1Desc");//description unchanged + f1->decrRef(); + f2->decrRef(); + // + f1=MEDCouplingFieldDouble::New(ON_CELLS,CONST_ON_TIME_INTERVAL); + f1->setName("f1"); + f1->setTimeTolerance(1.e-5); + f1->setDescription("f1Desc"); + f1->setTime(1.23,4,5); + f1->setEndTime(5.43,2,1); + f2=MEDCouplingFieldDouble::New(ON_CELLS,CONST_ON_TIME_INTERVAL); + f2->setName("f2"); + f2->setDescription("f2Desc"); + f2->setTimeTolerance(4.556e-12); + f2->setTime(6.78,9,10); + f2->setEndTime(10.98,7,6); + // + f1->copyTinyAttrFrom(f2); + CPPUNIT_ASSERT_DOUBLES_EQUAL(4.556e-12,f1->getTimeTolerance(),1e-24); + CPPUNIT_ASSERT(std::string(f1->getName())=="f1");//name unchanged + CPPUNIT_ASSERT(std::string(f1->getDescription())=="f1Desc");//description unchanged + CPPUNIT_ASSERT_DOUBLES_EQUAL(6.78,f1->getTime(dt,it),1e-12); + CPPUNIT_ASSERT_EQUAL(9,dt); + CPPUNIT_ASSERT_EQUAL(10,it); + CPPUNIT_ASSERT_DOUBLES_EQUAL(10.98,f1->getEndTime(dt,it),1e-12); + CPPUNIT_ASSERT_EQUAL(7,dt); + CPPUNIT_ASSERT_EQUAL(6,it); + f1->decrRef(); + f2->decrRef(); + // + f1=MEDCouplingFieldDouble::New(ON_CELLS,LINEAR_TIME); + f1->setName("f1"); + f1->setTimeTolerance(1.e-5); + f1->setDescription("f1Desc"); + f1->setTime(1.23,4,5); + f1->setEndTime(5.43,2,1); + f2=MEDCouplingFieldDouble::New(ON_CELLS,LINEAR_TIME); + f2->setName("f2"); + f2->setDescription("f2Desc"); + f2->setTimeTolerance(4.556e-12); + f2->setTime(6.78,9,10); + f2->setEndTime(10.98,7,6); + // + f1->copyTinyAttrFrom(f2); + CPPUNIT_ASSERT_DOUBLES_EQUAL(4.556e-12,f1->getTimeTolerance(),1e-24); + CPPUNIT_ASSERT(std::string(f1->getName())=="f1");//name unchanged + CPPUNIT_ASSERT(std::string(f1->getDescription())=="f1Desc");//description unchanged + CPPUNIT_ASSERT_DOUBLES_EQUAL(6.78,f1->getTime(dt,it),1e-12); + CPPUNIT_ASSERT_EQUAL(9,dt); + CPPUNIT_ASSERT_EQUAL(10,it); + CPPUNIT_ASSERT_DOUBLES_EQUAL(10.98,f1->getEndTime(dt,it),1e-12); + CPPUNIT_ASSERT_EQUAL(7,dt); + CPPUNIT_ASSERT_EQUAL(6,it); + f1->decrRef(); + f2->decrRef(); +} + +/*! + * 1D -> 2D extrusion with rotation + */ +void MEDCouplingBasicsTest::testExtrudedMesh5() +{ + const double coo1[4]={0.,1.,2.,3.5}; + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(4,1); + std::copy(coo1,coo1+4,a->getPointer()); + MEDCouplingCMesh *b=MEDCouplingCMesh::New(); + b->setCoordsAt(0,a); + MEDCouplingUMesh *c=b->buildUnstructured(); + CPPUNIT_ASSERT_EQUAL(1,c->getSpaceDimension()); + c->changeSpaceDimension(2); + // + DataArrayDouble *d=DataArrayDouble::New(); + d->alloc(13,1); + d->iota(); + MEDCouplingCMesh *e=MEDCouplingCMesh::New(); + e->setCoordsAt(0,d); + MEDCouplingUMesh *f=e->buildUnstructured(); + DataArrayDouble *g=f->getCoords()->applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec"); + DataArrayDouble *h=g->fromPolarToCart(); + f->setCoords(h); + MEDCouplingUMesh *i=c->buildExtrudedMesh(f,1); + CPPUNIT_ASSERT_EQUAL(52,i->getNumberOfNodes()); + bool tmp2; + int tmp3; + DataArrayInt *tmp=i->mergeNodes(1e-9,tmp2,tmp3); + CPPUNIT_ASSERT(tmp2); + CPPUNIT_ASSERT_EQUAL(37,tmp3); + tmp->decrRef(); + i->convertDegeneratedCells(); + i->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(36,i->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(37,i->getNumberOfNodes()); + CPPUNIT_ASSERT_EQUAL(12,i->getNumberOfCellsWithType(INTERP_KERNEL::NORM_TRI3)); + CPPUNIT_ASSERT_EQUAL(24,i->getNumberOfCellsWithType(INTERP_KERNEL::NORM_QUAD4)); + const double expected1[3]={0.25,0.75,2.0625}; + MEDCouplingFieldDouble *j=i->getMeasureField(true); + for(int i=0;i<12;i++) + for(int k=0;k<3;k++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[k],j->getIJ(0,i*3+k),1e-10); + const double expected2[72]={0.62200846792814113, 0.16666666666681595, 1.4513530918323276, 0.38888888888923495, 2.6293994326053212, 0.7045454545460802, 0.45534180126145435, 0.45534180126150181, 1.0624642029433926, 1.0624642029435025, 1.9248539780597826, 1.9248539780599816, 0.16666666666661334, 0.62200846792815856, 0.38888888888876294, 1.4513530918323678, 0.70454545454522521, 2.629399432605394, -0.16666666666674007, 0.62200846792812436, -0.38888888888906142, 1.4513530918322881, -0.70454545454576778, 2.6293994326052488, -0.45534180126154766, 0.45534180126140844, -1.0624642029436118, 1.0624642029432834, -1.9248539780601803, 1.9248539780595841, -0.62200846792817499, 0.1666666666665495, -1.451353091832408, 0.388888888888613, -2.6293994326054668, 0.70454545454495332, -0.62200846792810593, -0.16666666666680507, -1.451353091832247, -0.38888888888921297, -2.6293994326051746, -0.70454545454604123, -0.45534180126135926, -0.45534180126159562, -1.0624642029431723, -1.0624642029437235, -1.9248539780593836, -1.9248539780603811, -0.1666666666664828, -0.62200846792819242, -0.38888888888846079, -1.4513530918324489, -0.70454545454467987, -2.6293994326055397, 0.16666666666687083, -0.62200846792808862, 0.38888888888936374, -1.4513530918322073, 0.70454545454631357, -2.6293994326051022, 0.45534180126164348, -0.45534180126131207, 1.0624642029438327, -1.0624642029430627, 1.9248539780605791, -1.9248539780591853, 0.62200846792821063, -0.16666666666641802, 1.4513530918324888, -0.38888888888831086, 2.6293994326056125, -0.70454545454440853}; + DataArrayDouble *m=i->getBarycenterAndOwner(); + for(int i=0;i<72;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],m->getIJ(0,i),1e-10); + // + m->decrRef(); + j->decrRef(); + i->decrRef(); + h->decrRef(); + g->decrRef(); + f->decrRef(); + e->decrRef(); + d->decrRef(); + c->decrRef(); + b->decrRef(); + a->decrRef(); +} + +/*! + * 1D -> 2D extrusion without rotation + */ +void MEDCouplingBasicsTest::testExtrudedMesh6() +{ + const double coo1[4]={0.,1.,2.,3.5}; + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(4,1); + std::copy(coo1,coo1+4,a->getPointer()); + MEDCouplingCMesh *b=MEDCouplingCMesh::New(); + b->setCoordsAt(0,a); + MEDCouplingUMesh *c=b->buildUnstructured(); + CPPUNIT_ASSERT_EQUAL(1,c->getSpaceDimension()); + c->changeSpaceDimension(2); + // + DataArrayDouble *d=DataArrayDouble::New(); + d->alloc(5,1); + d->iota(); + MEDCouplingCMesh *e=MEDCouplingCMesh::New(); + e->setCoordsAt(0,d); + MEDCouplingUMesh *f=e->buildUnstructured(); + DataArrayDouble *d2=f->getCoords()->applyFunc("x*x/2"); + f->setCoords(d2); + f->changeSpaceDimension(2); + // + const double center[2]={0.,0.}; + f->rotate(center,0,M_PI/3); + MEDCouplingUMesh *g=c->buildExtrudedMesh(f,0); + g->checkCoherency(); + const double expected1[]={ 0.4330127018922193, 0.4330127018922193, 0.649519052838329, 1.2990381056766578, 1.299038105676658, 1.948557158514987, 2.1650635094610955, 2.1650635094610964, 3.2475952641916446, 3.031088913245533, 3.0310889132455352, 4.546633369868303 }; + MEDCouplingFieldDouble *f1=g->getMeasureField(true); + for(int i=0;i<12;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f1->getIJ(0,i),1e-12); + + const double expected2[]={0.625, 0.21650635094610962, 1.625, 0.21650635094610959, 2.8750000000000004, 0.21650635094610965, 1.1250000000000002, 1.0825317547305482, 2.125, 1.0825317547305482, 3.3750000000000004, 1.0825317547305484, 2.125, 2.8145825622994254, 3.125, 2.8145825622994254, 4.375, 2.8145825622994254, 3.6250000000000009, 5.4126587736527414, 4.625, 5.4126587736527414, 5.875, 5.4126587736527414}; + DataArrayDouble *f2=g->getBarycenterAndOwner(); + for(int i=0;i<24;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected2[i],f2->getIJ(0,i),1e-12); + // + f1->decrRef(); + f2->decrRef(); + g->decrRef(); + f->decrRef(); + e->decrRef(); + d->decrRef(); + d2->decrRef(); + c->decrRef(); + b->decrRef(); + a->decrRef(); +} + +/*! + * 2D -> 3D extrusion with rotation + */ +void MEDCouplingBasicsTest::testExtrudedMesh7() +{ + const double coo1[4]={0.,1.,2.,3.5}; + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(4,1); + std::copy(coo1,coo1+4,a->getPointer()); + MEDCouplingCMesh *b=MEDCouplingCMesh::New(); + b->setCoordsAt(0,a); + MEDCouplingUMesh *c=b->buildUnstructured(); + CPPUNIT_ASSERT_EQUAL(1,c->getSpaceDimension()); + c->changeSpaceDimension(2); + // + DataArrayDouble *d=DataArrayDouble::New(); + d->alloc(13,1); + d->iota(); + MEDCouplingCMesh *e=MEDCouplingCMesh::New(); + e->setCoordsAt(0,d); + MEDCouplingUMesh *f=e->buildUnstructured(); + DataArrayDouble *g=f->getCoords()->applyFunc(2,"3.5*IVec+x/6*3.14159265359*JVec"); + DataArrayDouble *h=g->fromPolarToCart(); + f->setCoords(h); + MEDCouplingUMesh *i=c->buildExtrudedMesh(f,1); + CPPUNIT_ASSERT_EQUAL(52,i->getNumberOfNodes()); + bool tmp2; + int tmp3; + DataArrayInt *tmp=i->mergeNodes(1e-9,tmp2,tmp3); + CPPUNIT_ASSERT(tmp2); + CPPUNIT_ASSERT_EQUAL(37,tmp3); + tmp->decrRef(); + i->convertDegeneratedCells(); + const double vec1[3]={10.,0.,0.}; + i->translate(vec1); + DataArrayDouble *g2=h->applyFunc(3,"13.5/3.5*x*IVec+0*JVec+13.5/3.5*y*KVec"); + f->setCoords(g2); + i->changeSpaceDimension(3); + MEDCouplingUMesh *i3=i->buildExtrudedMesh(f,1); + MEDCouplingFieldDouble *f2=i3->getMeasureField(true); + tmp=i->mergeNodes(1e-9,tmp2,tmp3); + CPPUNIT_ASSERT(tmp2); + CPPUNIT_ASSERT_EQUAL(444,tmp3); + tmp->decrRef(); + const double expected1[36]={1.327751058489274, 4.2942574094314701, 13.024068164857139, 1.3069177251569044, 4.1484240761012954, 12.297505664866796, 1.270833333332571, 3.8958333333309674, 11.039062499993179, 1.2291666666659207, 3.6041666666644425, 9.585937499993932, 1.1930822748415895, 3.3515759238941376, 8.3274943351204556, 1.1722489415082769, 3.2057425905609289, 7.6009318351210622, 1.1722489415082862, 3.2057425905609884, 7.6009318351213713, 1.1930822748416161, 3.3515759238943001, 8.3274943351212727, 1.2291666666659564, 3.6041666666646734, 9.5859374999950777, 1.2708333333326081, 3.8958333333311868, 11.039062499994293, 1.3069177251569224, 4.1484240761014384, 12.297505664867627, 1.3277510584902354, 4.2942574094346071, 13.024068164866796}; + int kk=0; + for(int ii=0;ii<12;ii++) + for(int jj=0;jj<36;jj++,kk++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[jj],f2->getIJ(0,kk),1e-9); + // + f2->decrRef(); + i3->decrRef(); + g2->decrRef(); + i->decrRef(); + h->decrRef(); + g->decrRef(); + f->decrRef(); + e->decrRef(); + d->decrRef(); + c->decrRef(); + b->decrRef(); + a->decrRef(); +} + +void MEDCouplingBasicsTest::testSimplexize1() +{ + MEDCouplingUMesh *m=build3DSurfTargetMesh_1(); + std::vector v(1); + v[0]=3; + m->convertToPolyTypes(v); + DataArrayInt *da=m->simplexize(0); + CPPUNIT_ASSERT_EQUAL(7,da->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,da->getNumberOfComponents()); + const int expected2[7]={0,0,1,2,3,4,4}; + for(int i=0;i<7;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],da->getIJ(i,0)); + m->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(7,m->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(0)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(1)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(2)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(3)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_POLYGON,m->getTypeOfCell(4)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(5)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(6)); + const double expected1[7]={0.125,0.125,0.125,0.125,0.25,0.125,0.125}; + MEDCouplingFieldDouble *f=m->getMeasureField(false); + for(int i=0;i<7;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i]*sqrt(2.),f->getIJ(i,0),1e-10); + std::set types=m->getAllTypes(); + CPPUNIT_ASSERT_EQUAL(2,(int)types.size()); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,*(types.begin())); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_POLYGON,*(++(types.begin()))); + f->decrRef(); + da->decrRef(); + m->decrRef(); + // + m=build3DSurfTargetMesh_1(); + v[0]=3; + m->convertToPolyTypes(v); + da=m->simplexize(1); + CPPUNIT_ASSERT_EQUAL(7,da->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,da->getNumberOfComponents()); + for(int i=0;i<7;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],da->getIJ(i,0)); + m->checkCoherency(); + types=m->getAllTypes(); + CPPUNIT_ASSERT_EQUAL(2,(int)types.size()); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,*(types.begin())); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_POLYGON,*(++(types.begin()))); + CPPUNIT_ASSERT_EQUAL(7,m->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(0)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(1)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(2)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(3)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_POLYGON,m->getTypeOfCell(4)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(5)); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_TRI3,m->getTypeOfCell(6)); + f=m->getMeasureField(false); + for(int i=0;i<7;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i]*sqrt(2.),f->getIJ(i,0),1e-10); + f->decrRef(); + da->decrRef(); + m->decrRef(); +} + +void MEDCouplingBasicsTest::testSimplexize2() +{ + MEDCouplingUMesh *m=build3DSurfTargetMesh_1(); + std::vector v(1); + v[0]=3; + m->convertToPolyTypes(v); + MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); + f1->setMesh(m); + DataArrayDouble *arr=DataArrayDouble::New(); + const double arr1[10]={10.,110.,20.,120.,30.,130.,40.,140.,50.,150.}; + arr->alloc(5,2); + std::copy(arr1,arr1+10,arr->getPointer()); + f1->setArray(arr); + arr->decrRef(); + // + f1->checkCoherency(); + CPPUNIT_ASSERT(f1->simplexize(0)); + f1->checkCoherency(); + const double expected1[14]={10.,110.,10.,110.,20.,120.,30.,130.,40.,140.,50.,150.,50.,150.}; + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f1->getIJ(0,i),1e-10); + CPPUNIT_ASSERT(!f1->simplexize(0)); + for(int i=0;i<14;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f1->getIJ(0,i),1e-10); + // + f1->decrRef(); + m->decrRef(); +} + +void MEDCouplingBasicsTest::testDAMeld1() +{ + DataArrayDouble *da1=DataArrayDouble::New(); + da1->alloc(7,2); + DataArrayDouble *da2=DataArrayDouble::New(); + da2->alloc(7,1); + // + da1->fillWithValue(7.); + da2->iota(0.); + DataArrayDouble *da3=da2->applyFunc(3,"10*x*IVec+100*x*JVec+1000*x*KVec"); + // + da1->setInfoOnComponent(0,"c0da1"); + da1->setInfoOnComponent(1,"c1da1"); + da3->setInfoOnComponent(0,"c0da3"); + da3->setInfoOnComponent(1,"c1da3"); + da3->setInfoOnComponent(2,"c2da3"); + // + DataArrayDouble *da1C=da1->deepCpy(); + da1->meldWith(da3); + CPPUNIT_ASSERT_EQUAL(5,da1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(7,da1->getNumberOfTuples()); + CPPUNIT_ASSERT(da1->getInfoOnComponent(0)=="c0da1"); + CPPUNIT_ASSERT(da1->getInfoOnComponent(1)=="c1da1"); + CPPUNIT_ASSERT(da1->getInfoOnComponent(2)=="c0da3"); + CPPUNIT_ASSERT(da1->getInfoOnComponent(3)=="c1da3"); + CPPUNIT_ASSERT(da1->getInfoOnComponent(4)=="c2da3"); + // + const double expected1[35]={7.,7.,0.,0.,0., 7.,7.,10.,100.,1000., 7.,7.,20.,200.,2000., 7.,7.,30.,300.,3000., 7.,7.,40.,400.,4000.,7.,7.,50.,500.,5000.,7.,7.,60.,600.,6000.}; + for(int i=0;i<35;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],da1->getIJ(0,i),1e-10); + // + DataArrayInt *dai1=da1C->convertToIntArr(); + DataArrayInt *dai3=da3->convertToIntArr(); + dai1->meldWith(dai3); + CPPUNIT_ASSERT_EQUAL(5,dai1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(7,dai1->getNumberOfTuples()); + CPPUNIT_ASSERT(dai1->getInfoOnComponent(0)=="c0da1"); + CPPUNIT_ASSERT(dai1->getInfoOnComponent(1)=="c1da1"); + CPPUNIT_ASSERT(dai1->getInfoOnComponent(2)=="c0da3"); + CPPUNIT_ASSERT(dai1->getInfoOnComponent(3)=="c1da3"); + CPPUNIT_ASSERT(dai1->getInfoOnComponent(4)=="c2da3"); + for(int i=0;i<35;i++) + CPPUNIT_ASSERT_EQUAL((int)expected1[i],dai1->getIJ(0,i)); + // test of static method DataArrayDouble::meld + DataArrayDouble *da4=DataArrayDouble::Meld(da1C,da3); + CPPUNIT_ASSERT_EQUAL(5,da4->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(7,da4->getNumberOfTuples()); + CPPUNIT_ASSERT(da4->getInfoOnComponent(0)=="c0da1"); + CPPUNIT_ASSERT(da4->getInfoOnComponent(1)=="c1da1"); + CPPUNIT_ASSERT(da4->getInfoOnComponent(2)=="c0da3"); + CPPUNIT_ASSERT(da4->getInfoOnComponent(3)=="c1da3"); + CPPUNIT_ASSERT(da4->getInfoOnComponent(4)=="c2da3"); + for(int i=0;i<35;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],da4->getIJ(0,i),1e-10); + // test of static method DataArrayInt::meld + dai1->decrRef(); + dai1=da1C->convertToIntArr(); + DataArrayInt *dai4=DataArrayInt::Meld(dai1,dai3); + CPPUNIT_ASSERT_EQUAL(5,dai4->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(7,dai4->getNumberOfTuples()); + CPPUNIT_ASSERT(dai4->getInfoOnComponent(0)=="c0da1"); + CPPUNIT_ASSERT(dai4->getInfoOnComponent(1)=="c1da1"); + CPPUNIT_ASSERT(dai4->getInfoOnComponent(2)=="c0da3"); + CPPUNIT_ASSERT(dai4->getInfoOnComponent(3)=="c1da3"); + CPPUNIT_ASSERT(dai4->getInfoOnComponent(4)=="c2da3"); + for(int i=0;i<35;i++) + CPPUNIT_ASSERT_EQUAL((int)expected1[i],dai4->getIJ(0,i)); + // + dai4->decrRef(); + da4->decrRef(); + dai3->decrRef(); + dai1->decrRef(); + da1C->decrRef(); + da1->decrRef(); + da2->decrRef(); + da3->decrRef(); +} + +void MEDCouplingBasicsTest::testFieldMeld1() +{ + MEDCouplingUMesh *m=build3DSurfTargetMesh_1(); + MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); + f1->setMesh(m); + DataArrayDouble *da1=DataArrayDouble::New(); + const double arr1[5]={12.,23.,34.,45.,56.}; + da1->alloc(5,1); + std::copy(arr1,arr1+5,da1->getPointer()); + da1->setInfoOnComponent(0,"aaa"); + f1->setArray(da1); + f1->setTime(3.4,2,1); + f1->checkCoherency(); + // + MEDCouplingFieldDouble *f2=f1->deepCpy(); + f2->setMesh(f1->getMesh()); + f2->checkCoherency(); + f2->changeNbOfComponents(2,5.); + (*f2)=5.; + f2->getArray()->setInfoOnComponent(0,"bbb"); + f2->getArray()->setInfoOnComponent(1,"ccc"); + f2->checkCoherency(); + // + MEDCouplingFieldDouble *f3=MEDCouplingFieldDouble::MeldFields(f2,f1); + f3->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(5,f3->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(3,f3->getNumberOfComponents()); + CPPUNIT_ASSERT(f3->getArray()->getInfoOnComponent(0)=="bbb"); + CPPUNIT_ASSERT(f3->getArray()->getInfoOnComponent(1)=="ccc"); + CPPUNIT_ASSERT(f3->getArray()->getInfoOnComponent(2)=="aaa"); + const double expected1[15]={5.,5.,12.,5.,5.,23.,5.,5.,34.,5.,5.,45.,5.,5.,56.}; + for(int i=0;i<15;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f3->getIJ(0,i),1e-12); + int dt,it; + double time=f3->getTime(dt,it); + CPPUNIT_ASSERT_DOUBLES_EQUAL(3.4,time,1e-14); + CPPUNIT_ASSERT_EQUAL(2,dt); + CPPUNIT_ASSERT_EQUAL(1,it); + // + MEDCouplingFieldDouble *f4=f2->buildNewTimeReprFromThis(NO_TIME,false); + MEDCouplingFieldDouble *f5=f1->buildNewTimeReprFromThis(NO_TIME,false); + MEDCouplingFieldDouble *f6=MEDCouplingFieldDouble::MeldFields(f4,f5); + f6->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(5,f6->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(3,f6->getNumberOfComponents()); + CPPUNIT_ASSERT(f6->getArray()->getInfoOnComponent(0)=="bbb"); + CPPUNIT_ASSERT(f6->getArray()->getInfoOnComponent(1)=="ccc"); + CPPUNIT_ASSERT(f6->getArray()->getInfoOnComponent(2)=="aaa"); + for(int i=0;i<15;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f6->getIJ(0,i),1e-12); + // + f6->decrRef(); + f4->decrRef(); + f5->decrRef(); + f3->decrRef(); + da1->decrRef(); + f2->decrRef(); + f1->decrRef(); + m->decrRef(); +} + +void MEDCouplingBasicsTest::testMergeNodes2() +{ + MEDCouplingUMesh *m1=build2DTargetMesh_1(); + MEDCouplingUMesh *m2=build2DTargetMesh_1(); + const double vec[2]={0.002,0.}; + m2->translate(vec); + // + std::vector tmp(2); + tmp[0]=m1; + tmp[1]=m2; + MEDCouplingUMesh *m3=MEDCouplingUMesh::MergeUMeshes(tmp); + bool b; + int newNbOfNodes; + DataArrayInt *da=m3->mergeNodes2(0.01,b,newNbOfNodes); + CPPUNIT_ASSERT_EQUAL(9,m3->getNumberOfNodes()); + const double expected1[18]={-0.299,-0.3, 0.201,-0.3, 0.701,-0.3, -0.299,0.2, 0.201,0.2, 0.701,0.2, -0.299,0.7, 0.201,0.7, 0.701,0.7}; + for(int i=0;i<18;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],m3->getCoords()->getIJ(0,i),1e-13); + // + da->decrRef(); + m3->decrRef(); + m1->decrRef(); + m2->decrRef(); +} + +void MEDCouplingBasicsTest::testMergeField2() +{ + MEDCouplingUMesh *m=build2DTargetMesh_1(); + MEDCouplingFieldDouble *f1=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); + f1->setMesh(m); + DataArrayDouble *arr=DataArrayDouble::New(); + arr->alloc(5,2); + arr->fillWithValue(2.); + f1->setArray(arr); + arr->decrRef(); + MEDCouplingFieldDouble *f2=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); + f2->setMesh(m); + arr=DataArrayDouble::New(); + arr->alloc(5,2); + arr->fillWithValue(5.); + f2->setArray(arr); + arr->decrRef(); + MEDCouplingFieldDouble *f3=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); + f3->setMesh(m); + arr=DataArrayDouble::New(); + arr->alloc(5,2); + arr->fillWithValue(7.); + f3->setArray(arr); + arr->decrRef(); + // + std::vector tmp(3); + tmp[0]=f1; tmp[1]=f2; tmp[2]=f3; + MEDCouplingFieldDouble *f4=MEDCouplingFieldDouble::MergeFields(tmp); + CPPUNIT_ASSERT_EQUAL(15,f4->getMesh()->getNumberOfCells()); + const double expected1[30]={2.,2.,2.,2.,2.,2.,2.,2.,2.,2., 5.,5.,5.,5.,5.,5.,5.,5.,5.,5., 7.,7.,7.,7.,7.,7.,7.,7.,7.,7.}; + for(int i=0;i<30;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f4->getIJ(0,i),1.e-13); + // + f4->decrRef(); + f1->decrRef(); + f2->decrRef(); + f3->decrRef(); + m->decrRef(); +} + +void MEDCouplingBasicsTest::testDAIBuildComplement1() +{ + DataArrayInt *a=DataArrayInt::New(); + const int tab[4]={3,1,7,8}; + a->alloc(4,1); + std::copy(tab,tab+4,a->getPointer()); + DataArrayInt *b=a->buildComplement(12); + CPPUNIT_ASSERT_EQUAL(8,b->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,b->getNumberOfComponents()); + const int expected1[8]={0,2,4,5,6,9,10,11}; + for(int i=0;i<8;i++) + CPPUNIT_ASSERT_EQUAL(expected1[i],b->getIJ(0,i)); + b->decrRef(); + a->decrRef(); +} + +void MEDCouplingBasicsTest::testDAIBuildUnion1() +{ + DataArrayInt *a=DataArrayInt::New(); + const int tab1[4]={3,1,7,8}; + a->alloc(4,1); + std::copy(tab1,tab1+4,a->getPointer()); + DataArrayInt *c=DataArrayInt::New(); + const int tab2[5]={5,3,0,18,8}; + c->alloc(5,1); + std::copy(tab2,tab2+5,c->getPointer()); + DataArrayInt *b=a->buildUnion(c); + CPPUNIT_ASSERT_EQUAL(7,b->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,b->getNumberOfComponents()); + const int expected1[7]={0,1,3,5,7,8,18}; + for(int i=0;i<7;i++) + CPPUNIT_ASSERT_EQUAL(expected1[i],b->getIJ(0,i)); + c->decrRef(); + b->decrRef(); + a->decrRef(); +} + +void MEDCouplingBasicsTest::testDAIBuildIntersection1() +{ + DataArrayInt *a=DataArrayInt::New(); + const int tab1[4]={3,1,7,8}; + a->alloc(4,1); + std::copy(tab1,tab1+4,a->getPointer()); + DataArrayInt *c=DataArrayInt::New(); + const int tab2[5]={5,3,0,18,8}; + c->alloc(5,1); + std::copy(tab2,tab2+5,c->getPointer()); + DataArrayInt *b=a->buildIntersection(c); + CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,b->getNumberOfComponents()); + const int expected1[2]={3,8}; + for(int i=0;i<2;i++) + CPPUNIT_ASSERT_EQUAL(expected1[i],b->getIJ(0,i)); + c->decrRef(); + b->decrRef(); + a->decrRef(); +} + +void MEDCouplingBasicsTest::testDAIDeltaShiftIndex1() +{ + DataArrayInt *a=DataArrayInt::New(); + const int tab[7]={1,3,6,7,7,9,15}; + a->alloc(7,1); + std::copy(tab,tab+7,a->getPointer()); + DataArrayInt *b=a->deltaShiftIndex(); + CPPUNIT_ASSERT_EQUAL(6,b->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,b->getNumberOfComponents()); + const int expected1[6]={2,3,1,0,2,6}; + for(int i=0;i<6;i++) + CPPUNIT_ASSERT_EQUAL(expected1[i],b->getIJ(0,i)); + b->decrRef(); + a->decrRef(); +} + +void MEDCouplingBasicsTest::testDaDoubleSelectByTupleIdSafe1() +{ + DataArrayDouble *a=DataArrayDouble::New(); + a->alloc(7,2); + a->setInfoOnComponent(0,"toto"); + a->setInfoOnComponent(1,"tata"); + const double arr1[14]={1.1,11.1,2.1,12.1,3.1,13.1,4.1,14.1,5.1,15.1,6.1,16.1,7.1,17.1}; + std::copy(arr1,arr1+14,a->getPointer()); + // + const int arr2[7]={4,2,0,6,5}; + DataArrayDouble *b=a->selectByTupleIdSafe(arr2,arr2+5); + CPPUNIT_ASSERT_EQUAL(5,b->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(b->getInfoOnComponent(1))=="tata"); + const double expected1[10]={5.1,15.1,3.1,13.1,1.1,11.1,7.1,17.1,6.1,16.1}; + for(int i=0;i<10;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); + const int arr4[5]={4,-1,0,6,5}; + CPPUNIT_ASSERT_THROW(a->selectByTupleIdSafe(arr4,arr4+5),INTERP_KERNEL::Exception); + const int arr5[5]={4,2,0,6,7}; + CPPUNIT_ASSERT_THROW(a->selectByTupleIdSafe(arr5,arr5+5),INTERP_KERNEL::Exception); + b->decrRef(); + a->decrRef(); + // + DataArrayInt *c=DataArrayInt::New(); + c->alloc(7,2); + c->setInfoOnComponent(0,"toto"); + c->setInfoOnComponent(1,"tata"); + const int arr3[14]={1,11,2,12,3,13,4,14,5,15,6,16,7,17}; + std::copy(arr3,arr3+14,c->getPointer()); + DataArrayInt *d=c->selectByTupleIdSafe(arr2,arr2+5); + CPPUNIT_ASSERT_EQUAL(5,d->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,d->getNumberOfComponents()); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(0))=="toto"); + CPPUNIT_ASSERT(std::string(d->getInfoOnComponent(1))=="tata"); + const int expected2[10]={5,15,3,13,1,11,7,17,6,16}; + for(int i=0;i<10;i++) + CPPUNIT_ASSERT_EQUAL(expected2[i],d->getIJ(0,i)); + CPPUNIT_ASSERT_THROW(c->selectByTupleIdSafe(arr4,arr4+5),INTERP_KERNEL::Exception); + CPPUNIT_ASSERT_THROW(c->selectByTupleIdSafe(arr5,arr5+5),INTERP_KERNEL::Exception); + c->decrRef(); + d->decrRef(); +} + +void MEDCouplingBasicsTest::testAreCellsIncludedIn1() +{ + MEDCouplingUMesh *m=build3DSurfTargetMesh_1(); + const int pt[2]={1,3}; + MEDCouplingUMesh *m2=(MEDCouplingUMesh *)m->buildPartOfMySelf(pt,pt+2,true); + DataArrayInt *tmp; + CPPUNIT_ASSERT(m->areCellsIncludedIn(m2,0,tmp)); + CPPUNIT_ASSERT_EQUAL(2,tmp->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,tmp->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(pt[0],tmp->getIJ(0,0)); + CPPUNIT_ASSERT_EQUAL(pt[1],tmp->getIJ(0,1)); + tmp->decrRef(); + CPPUNIT_ASSERT(!m2->areCellsIncludedIn(m,0,tmp)); + tmp->decrRef(); + m2->decrRef(); + m->decrRef(); +} + +void MEDCouplingBasicsTest::testDAIBuildSubstraction1() +{ + DataArrayInt *a=DataArrayInt::New(); + const int aa[]={2,3,6,8,9}; + a->alloc(5,1); + std::copy(aa,aa+5,a->getPointer()); + DataArrayInt *b=DataArrayInt::New(); + const int bb[]={1,3,5,9,11}; + b->alloc(5,1); + std::copy(bb,bb+5,b->getPointer()); + // + DataArrayInt *c=a->buildSubstraction(b); + CPPUNIT_ASSERT_EQUAL(3,c->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,c->getNumberOfComponents()); + const int expected1[3]={2,6,8}; + CPPUNIT_ASSERT(std::equal(expected1,expected1+3,c->getConstPointer())); + // + c->decrRef(); + b->decrRef(); + a->decrRef(); +} + +void MEDCouplingBasicsTest::testBuildOrthogonalField2() +{ + MEDCouplingUMesh *m=build2DTargetMesh_1(); + DataArrayInt *d1=DataArrayInt::New(); + DataArrayInt *d2=DataArrayInt::New(); + DataArrayInt *d3=DataArrayInt::New(); + DataArrayInt *d4=DataArrayInt::New(); + MEDCouplingUMesh *m1=m->buildDescendingConnectivity(d1,d2,d3,d4); + // + MEDCouplingFieldDouble *f1=m1->buildOrthogonalField(); + DataArrayDouble *da1=f1->getArray(); + CPPUNIT_ASSERT_EQUAL(2,da1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(13,da1->getNumberOfTuples()); + // + const double expected1[26]={-1.,0.,0.,1.,1.,0.,0.,-1.,0.707106781186548,0.707106781186548,0.,-1.,0.,1.,1.,0.,0.,1.,1.,0.,-1.,0.,0.,1.,1.,0.}; + for(int i=0;i<26;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],da1->getIJ(0,i),1e-14); + // + f1->decrRef(); + m1->decrRef(); + d1->decrRef(); + d2->decrRef(); + d3->decrRef(); + d4->decrRef(); + m->decrRef(); +} + +void MEDCouplingBasicsTest::testUMInsertNextCell1() +{ + double targetCoords[18]={-0.3,-0.3, 0.2,-0.3, 0.7,-0.3, -0.3,0.2, 0.2,0.2, 0.7,0.2, -0.3,0.7, 0.2,0.7, 0.7,0.7 }; + int targetConn[18]={0,3,4,1, 1,4,2, 4,5,2, 6,7,4,3, 7,8,5,4}; + MEDCouplingUMesh *targetMesh=MEDCouplingUMesh::New(); + targetMesh->allocateCells(5); + CPPUNIT_ASSERT_THROW(targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn),INTERP_KERNEL::Exception); + targetMesh->setMeshDimension(2); + targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn); + CPPUNIT_ASSERT_THROW(targetMesh->insertNextCell(INTERP_KERNEL::NORM_TETRA4,4,targetConn),INTERP_KERNEL::Exception); + CPPUNIT_ASSERT_THROW(targetMesh->insertNextCell(INTERP_KERNEL::NORM_SEG2,2,targetConn),INTERP_KERNEL::Exception); + CPPUNIT_ASSERT_THROW(targetMesh->insertNextCell(INTERP_KERNEL::NORM_POINT1,1,targetConn),INTERP_KERNEL::Exception); + targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn+4); + targetMesh->insertNextCell(INTERP_KERNEL::NORM_TRI3,3,targetConn+7); + targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+10); + targetMesh->insertNextCell(INTERP_KERNEL::NORM_QUAD4,4,targetConn+14); + targetMesh->finishInsertingCells(); + DataArrayDouble *myCoords=DataArrayDouble::New(); + myCoords->alloc(9,2); + std::copy(targetCoords,targetCoords+18,myCoords->getPointer()); + targetMesh->setCoords(myCoords); + myCoords->decrRef(); + targetMesh->checkCoherency(); + targetMesh->decrRef(); +} + +void MEDCouplingBasicsTest::testFieldOperatorDivDiffComp1() +{ + MEDCouplingUMesh *m=build2DTargetMesh_1(); + DataArrayInt *d1=DataArrayInt::New(); + DataArrayInt *d2=DataArrayInt::New(); + DataArrayInt *d3=DataArrayInt::New(); + DataArrayInt *d4=DataArrayInt::New(); + MEDCouplingUMesh *m1=m->buildDescendingConnectivity(d1,d2,d3,d4); + // + MEDCouplingFieldDouble *f1=m1->buildOrthogonalField(); + const double arr1[13]={2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.}; + DataArrayDouble *arr=DataArrayDouble::New(); + arr->alloc(13,1); + std::copy(arr1,arr1+13,arr->getPointer()); + MEDCouplingFieldDouble *f2=MEDCouplingFieldDouble::New(ON_CELLS); + f2->setArray(arr); + f2->setMesh(m1); + f2->checkCoherency(); + // + MEDCouplingFieldDouble *f3=(*f1)/(*f2); + CPPUNIT_ASSERT_THROW((*f2)/(*f1),INTERP_KERNEL::Exception); + f3->checkCoherency(); + (*f1)/=(*f2); + CPPUNIT_ASSERT(f1->isEqual(f3,1e-10,1e-10)); + CPPUNIT_ASSERT_THROW((*f2)/=(*f1),INTERP_KERNEL::Exception); + const double expected1[26]={-0.5, 0.0, 0.0, 0.33333333333333331, 0.25, 0.0, 0.0, -0.20000000000000001, 0.117851130197758, 0.117851130197758, 0.0, -0.14285714285714285, 0.0, 0.125, 0.1111111111111111, 0.0, 0.0, 0.10000000000000001, 0.090909090909090912, 0.0, -0.083333333333333329, 0.0, 0.0, 0.076923076923076927, 0.071428571428571425, 0.0}; + for(int i=0;i<26;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],f3->getIJ(0,i),1e-10); + // + f3->decrRef(); + f2->decrRef(); + arr->decrRef(); + f1->decrRef(); + m1->decrRef(); + d1->decrRef(); + d2->decrRef(); + d3->decrRef(); + d4->decrRef(); + m->decrRef(); +} + +void MEDCouplingBasicsTest::testDARearrange1() +{ + DataArrayInt *da1=DataArrayInt::New(); + da1->alloc(12,1); + da1->iota(0); + const int *ptr=da1->getConstPointer(); + // + CPPUNIT_ASSERT_EQUAL(12,da1->getNbOfElems()); + CPPUNIT_ASSERT_EQUAL(1,da1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(12,da1->getNumberOfTuples()); + da1->rearrange(4); + CPPUNIT_ASSERT(ptr==da1->getConstPointer()); + CPPUNIT_ASSERT_EQUAL(12,da1->getNbOfElems()); + CPPUNIT_ASSERT_EQUAL(4,da1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(3,da1->getNumberOfTuples()); + for(int i=0;i<12;i++) + CPPUNIT_ASSERT_EQUAL(i,da1->getIJ(0,i)); + // + da1->rearrange(6); + CPPUNIT_ASSERT(ptr==da1->getConstPointer()); + CPPUNIT_ASSERT_EQUAL(12,da1->getNbOfElems()); + CPPUNIT_ASSERT_EQUAL(6,da1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(2,da1->getNumberOfTuples()); + for(int i=0;i<12;i++) + CPPUNIT_ASSERT_EQUAL(i,da1->getIJ(0,i)); + // + CPPUNIT_ASSERT_THROW(da1->rearrange(7),INTERP_KERNEL::Exception); + // + da1->rearrange(12); + CPPUNIT_ASSERT(ptr==da1->getConstPointer()); + CPPUNIT_ASSERT_EQUAL(12,da1->getNbOfElems()); + CPPUNIT_ASSERT_EQUAL(12,da1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(1,da1->getNumberOfTuples()); + for(int i=0;i<12;i++) + CPPUNIT_ASSERT_EQUAL(i,da1->getIJ(0,i)); + // + da1->rearrange(3); + CPPUNIT_ASSERT(ptr==da1->getConstPointer()); + CPPUNIT_ASSERT_EQUAL(12,da1->getNbOfElems()); + CPPUNIT_ASSERT_EQUAL(3,da1->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(4,da1->getNumberOfTuples()); + for(int i=0;i<12;i++) + CPPUNIT_ASSERT_EQUAL(i,da1->getIJ(0,i)); + //double + DataArrayDouble *da2=da1->convertToDblArr(); + da1->decrRef(); + const double *ptr2=da2->getConstPointer(); + // + CPPUNIT_ASSERT_EQUAL(12,da2->getNbOfElems()); + CPPUNIT_ASSERT_EQUAL(3,da2->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(4,da2->getNumberOfTuples()); + da2->rearrange(4); + CPPUNIT_ASSERT(ptr2==da2->getConstPointer()); + CPPUNIT_ASSERT_EQUAL(12,da2->getNbOfElems()); + CPPUNIT_ASSERT_EQUAL(4,da2->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(3,da2->getNumberOfTuples()); + for(int i=0;i<12;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL((double)i,da2->getIJ(0,i),1e-14); + // + da2->rearrange(6); + CPPUNIT_ASSERT(ptr2==da2->getConstPointer()); + CPPUNIT_ASSERT_EQUAL(12,da2->getNbOfElems()); + CPPUNIT_ASSERT_EQUAL(6,da2->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(2,da2->getNumberOfTuples()); + for(int i=0;i<12;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL((double)i,da2->getIJ(0,i),1e-14); + // + CPPUNIT_ASSERT_THROW(da2->rearrange(7),INTERP_KERNEL::Exception); + // + da2->rearrange(1); + CPPUNIT_ASSERT(ptr2==da2->getConstPointer()); + CPPUNIT_ASSERT_EQUAL(12,da2->getNbOfElems()); + CPPUNIT_ASSERT_EQUAL(1,da2->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(12,da2->getNumberOfTuples()); + for(int i=0;i<12;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL((double)i,da2->getIJ(0,i),1e-14); + // + da2->rearrange(3); + CPPUNIT_ASSERT(ptr2==da2->getConstPointer()); + CPPUNIT_ASSERT_EQUAL(12,da2->getNbOfElems()); + CPPUNIT_ASSERT_EQUAL(3,da2->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(4,da2->getNumberOfTuples()); + for(int i=0;i<12;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL((double)i,da2->getIJ(0,i),1e-14); + da2->decrRef(); +} + +void MEDCouplingBasicsTest::testGetDifferentValues1() +{ + DataArrayInt *da1=DataArrayInt::New(); + const int arr[12]={1,2,3,2,2,3,5,1,5,5,2,2}; + da1->alloc(4,3); + std::copy(arr,arr+12,da1->getPointer()); + std::set s=da1->getDifferentValues(); + const int expected1[4]={1,2,3,5}; + CPPUNIT_ASSERT_EQUAL(4,(int)s.size()); + CPPUNIT_ASSERT(std::equal(expected1,expected1+4,s.begin())); + da1->decrRef(); +} + +void MEDCouplingBasicsTest::testDAIBuildPermutationArr1() +{ + DataArrayInt *a=DataArrayInt::New(); + const int vala[5]={4,5,6,7,8}; + a->alloc(5,1); + std::copy(vala,vala+5,a->getPointer()); + DataArrayInt *b=DataArrayInt::New(); + const int valb[5]={5,4,8,6,7}; + b->alloc(5,1); + std::copy(valb,valb+5,b->getPointer()); + DataArrayInt *c=a->buildPermutationArr(*b); + const int expect1[5]={1,0,4,2,3}; + CPPUNIT_ASSERT_EQUAL(5,c->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,c->getNumberOfComponents()); + CPPUNIT_ASSERT(std::equal(expect1,expect1+5,c->getConstPointer())); + CPPUNIT_ASSERT(a->isEqualWithoutConsideringStrAndOrder(*b)); + b->setIJ(0,0,9); + CPPUNIT_ASSERT(!a->isEqualWithoutConsideringStrAndOrder(*b)); + CPPUNIT_ASSERT_THROW(a->buildPermutationArr(*b),INTERP_KERNEL::Exception); + a->setIJ(3,0,4); + b->setIJ(0,0,5); + b->setIJ(4,0,4);//;a==[4,5,6,4,8] and b==[5,4,8,6,4] + CPPUNIT_ASSERT(a->isEqualWithoutConsideringStrAndOrder(*b)); + c->decrRef(); + c=a->buildPermutationArr(*b); + const int expect2[5]={1,3,4,2,3}; + CPPUNIT_ASSERT(std::equal(expect2,expect2+5,c->getConstPointer())); + DataArrayDouble *d=b->convertToDblArr(); + b->sort(); + const int expect3[5]={4,4,5,6,8}; + CPPUNIT_ASSERT(std::equal(expect3,expect3+5,b->getConstPointer())); + d->sort(); + CPPUNIT_ASSERT_EQUAL(5,d->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,d->getNumberOfComponents()); + for(int i=0;i<5;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(double(expect3[i]),d->getIJ(i,0),1e-14); + // + d->decrRef(); + c->decrRef(); + a->decrRef(); + b->decrRef(); +} + +void MEDCouplingBasicsTest::testAreCellsIncludedIn2() +{ + const char myName[]="Vitoo"; + MEDCouplingUMesh *m=build3DSurfTargetMesh_1(); + MEDCouplingUMesh *m2=(MEDCouplingUMesh *)m->buildPartOfMySelf(0,0,true); + CPPUNIT_ASSERT_EQUAL(0,m2->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(3,m2->getSpaceDimension()); + CPPUNIT_ASSERT_EQUAL(2,m2->getMeshDimension()); + m2->setName(myName); + DataArrayInt *tmp; + CPPUNIT_ASSERT(m->areCellsIncludedIn(m2,0,tmp)); + CPPUNIT_ASSERT(std::string(myName)==tmp->getName()); + CPPUNIT_ASSERT_EQUAL(0,tmp->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(1,tmp->getNumberOfComponents()); + m->decrRef(); + m2->decrRef(); + tmp->decrRef(); +} + +void MEDCouplingBasicsTest::testUMeshGetPartBarycenterAndOwner1() +{ + MEDCouplingUMesh *m1=build2DTargetMesh_1(); + const int part[3]={1,0,4}; + DataArrayDouble *b=m1->getPartBarycenterAndOwner(part,part+3); + CPPUNIT_ASSERT_EQUAL(2,b->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(3,b->getNumberOfTuples()); + const double expected1[6]={0.36666666666666665,-0.13333333333333333,-0.05,-0.05,0.45,0.45}; + for(int i=0;i<6;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); + b->decrRef(); + m1->decrRef(); +} + +void MEDCouplingBasicsTest::testUMeshGetPartMeasureField1() +{ + MEDCouplingUMesh *m1=build2DTargetMesh_1(); + const int part[3]={1,0,4}; + DataArrayDouble *b=m1->getPartMeasureField(true,part,part+3); + CPPUNIT_ASSERT_EQUAL(1,b->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(3,b->getNumberOfTuples()); + const double expected1[3]={0.125,0.25,0.25}; + for(int i=0;i<3;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getIJ(0,i),1e-14); + b->decrRef(); + m1->decrRef(); +} + +void MEDCouplingBasicsTest::testUMeshBuildPartOrthogonalField1() +{ + MEDCouplingUMesh *m1=build2DTargetMesh_1(); + m1->changeSpaceDimension(3); + const int part[3]={1,0,4}; + MEDCouplingFieldDouble *b=m1->buildPartOrthogonalField(part,part+3); + CPPUNIT_ASSERT_EQUAL(3,b->getArray()->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(3,b->getArray()->getNumberOfTuples()); + const double expected1[9]={0.,0.,-1.,0.,0.,-1.,0.,0.,-1.}; + for(int i=0;i<9;i++) + CPPUNIT_ASSERT_DOUBLES_EQUAL(expected1[i],b->getArray()->getIJ(0,i),1e-14); + b->decrRef(); + m1->decrRef(); +} + +void MEDCouplingBasicsTest::testUMeshGetTypesOfPart1() +{ + MEDCouplingUMesh *m1=build2DTargetMesh_1(); + const int part1[]={0,3,4}; + std::set s; + s=m1->getTypesOfPart(part1,part1+3); + CPPUNIT_ASSERT(s.size()==1); + CPPUNIT_ASSERT(*s.begin()==INTERP_KERNEL::NORM_QUAD4); + const int part2[]={2,2,2,1}; + s=m1->getTypesOfPart(part2,part2+4); + CPPUNIT_ASSERT(s.size()==1); + CPPUNIT_ASSERT(*s.begin()==INTERP_KERNEL::NORM_TRI3); + const int part3[]={3,2,1}; + s=m1->getTypesOfPart(part3,part3+3); + CPPUNIT_ASSERT(s.size()==2); + CPPUNIT_ASSERT(*s.begin()==INTERP_KERNEL::NORM_TRI3); + CPPUNIT_ASSERT(*(++s.begin())==INTERP_KERNEL::NORM_QUAD4); + m1->decrRef(); +} + +void MEDCouplingBasicsTest::testUMeshKeepCellIdsByType1() +{ + MEDCouplingUMesh *m1=build2DTargetMesh_1(); + const int part1[3]={0,3,4}; + DataArrayInt *a=m1->keepCellIdsByType(INTERP_KERNEL::NORM_TRI3,part1,part1+3); + CPPUNIT_ASSERT_EQUAL(1,a->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(0,a->getNumberOfTuples()); + a->decrRef(); + // + const int part2[5]={3,2,0,2,4}; + a=m1->keepCellIdsByType(INTERP_KERNEL::NORM_TRI3,part2,part2+5); + CPPUNIT_ASSERT_EQUAL(1,a->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(2,a->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,a->getIJ(0,0)); + CPPUNIT_ASSERT_EQUAL(2,a->getIJ(1,0)); + a->decrRef(); + // + a=m1->keepCellIdsByType(INTERP_KERNEL::NORM_QUAD4,part2,part2+5); + CPPUNIT_ASSERT_EQUAL(1,a->getNumberOfComponents()); + CPPUNIT_ASSERT_EQUAL(3,a->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(3,a->getIJ(0,0)); + CPPUNIT_ASSERT_EQUAL(0,a->getIJ(1,0)); + CPPUNIT_ASSERT_EQUAL(4,a->getIJ(2,0)); + // + a->decrRef(); + m1->decrRef(); +} + +void MEDCouplingBasicsTest::testDAIAggregateMulti1() +{ + DataArrayInt *a=DataArrayInt::New(); + a->setName("aa"); + a->alloc(4,1); + a->iota(0); + a->rearrange(2); + DataArrayInt *b=DataArrayInt::New(); + b->setName("bb"); + b->alloc(6,1); + b->iota(0); + b->rearrange(2); + // + std::vector v(2); + v[0]=a; v[1]=b; + DataArrayInt *c=DataArrayInt::Aggregate(v); + CPPUNIT_ASSERT_EQUAL(5,c->getNumberOfTuples()); + CPPUNIT_ASSERT_EQUAL(2,c->getNumberOfComponents()); + CPPUNIT_ASSERT(c->getName()=="aa"); + const int expect1[10]={0,1,2,3,0,1,2,3,4,5}; + for(int i=0;i<10;i++) + CPPUNIT_ASSERT_EQUAL(expect1[i],c->getIJ(0,i)); + // + c->decrRef(); + a->decrRef(); + b->decrRef(); +} + +void MEDCouplingBasicsTest::testMergeUMeshes2() +{ + MEDCouplingUMesh *m1=build3DSurfTargetMesh_1(); + MEDCouplingUMesh *m2=build3DSurfTargetMesh_1(); + MEDCouplingUMesh *m3=build3DSurfTargetMesh_1(); + // + const int vec1[3]={0,2,3}; + MEDCouplingUMesh *m2_2=(MEDCouplingUMesh *)m2->buildPartOfMySelf(vec1,vec1+3,false); + const int vec2[2]={1,1}; + MEDCouplingUMesh *m3_2=(MEDCouplingUMesh *)m3->buildPartOfMySelf(vec2,vec2+2,false); + // + std::vector ms(3); + ms[0]=m1; ms[1]=m2_2; ms[2]=m3_2; + // + MEDCouplingUMesh *m4=MEDCouplingUMesh::MergeUMeshes(ms); + m4->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(10,m4->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(20,m4->getNumberOfNodes()); + CPPUNIT_ASSERT_EQUAL(45,m4->getMeshLength()); + // + const int vec3[5]={0,1,2,3,4}; + MEDCouplingUMesh *m4_1=(MEDCouplingUMesh *)m4->buildPartOfMySelf(vec3,vec3+5,false); + m4_1->setName(m1->getName()); + CPPUNIT_ASSERT(m4_1->isEqual(m1,1e-12)); + m4_1->decrRef(); + // + const int vec4[3]={5,6,7}; + MEDCouplingUMesh *m4_2=(MEDCouplingUMesh *)m4->buildPartOfMySelf(vec4,vec4+3,false); + DataArrayInt *cellCor=0; + DataArrayInt *nodeCor=0; + m4_2->checkGeoEquivalWith(m2_2,10,1e-12,cellCor,nodeCor); + CPPUNIT_ASSERT(cellCor==0); + CPPUNIT_ASSERT(nodeCor==0); + m4_2->decrRef(); + // + const int vec5[2]={8,9}; + MEDCouplingUMesh *m4_3=(MEDCouplingUMesh *)m4->buildPartOfMySelf(vec5,vec5+2,false); + CPPUNIT_ASSERT_EQUAL(2,m4_3->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(3,m4_3->getNumberOfNodes()); + m3_2->zipCoords(); + m4_3->setName(m3_2->getName()); + CPPUNIT_ASSERT(m4_3->isEqual(m3_2,1e-12)); + m4_3->decrRef(); + // + m4->decrRef(); + m1->decrRef(); + m2->decrRef(); + m2_2->decrRef(); + m3->decrRef(); + m3_2->decrRef(); +} + +void MEDCouplingBasicsTest::testBuild0DMeshFromCoords1() +{ + const double sourceCoords[12]={-0.3,-0.3,0., 0.7,-0.3,0., -0.3,0.7,0., 0.7,0.7,0.}; + DataArrayDouble *coo=DataArrayDouble::New(); + coo->alloc(4,3); + coo->setName("My0D"); + std::copy(sourceCoords,sourceCoords+12,coo->getPointer()); + MEDCouplingUMesh *m=MEDCouplingUMesh::Build0DMeshFromCoords(coo); + m->checkCoherency(); + CPPUNIT_ASSERT_EQUAL(4,m->getNumberOfNodes()); + CPPUNIT_ASSERT_EQUAL(4,m->getNumberOfCells()); + CPPUNIT_ASSERT_EQUAL(3,m->getSpaceDimension()); + CPPUNIT_ASSERT_EQUAL(0,m->getMeshDimension()); + const std::set& types=m->getAllTypes(); + CPPUNIT_ASSERT_EQUAL(1,(int)types.size()); + CPPUNIT_ASSERT_EQUAL(INTERP_KERNEL::NORM_POINT1,*types.begin()); + for(int i=0;i<4;i++) + { + std::vector conn; + m->getNodeIdsOfCell(i,conn); + CPPUNIT_ASSERT_EQUAL(1,(int)conn.size()); + CPPUNIT_ASSERT_EQUAL(i,conn[0]); + CPPUNIT_ASSERT(INTERP_KERNEL::NORM_POINT1==m->getTypeOfCell(i)); + } + CPPUNIT_ASSERT(std::string(m->getName())=="My0D"); + m->decrRef(); + coo->decrRef(); +} + diff --git a/src/MEDCoupling/Test/MEDCouplingBasicsTest4.cxx b/src/MEDCoupling/Test/MEDCouplingBasicsTest4.cxx new file mode 100644 index 000000000..d495c7a9f --- /dev/null +++ b/src/MEDCoupling/Test/MEDCouplingBasicsTest4.cxx @@ -0,0 +1,98 @@ +// Copyright (C) 2007-2010 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + +#include "MEDCouplingBasicsTest.hxx" +#include "MEDCouplingUMesh.hxx" +#include "MEDCouplingCMesh.hxx" +#include "MEDCouplingExtrudedMesh.hxx" +#include "MEDCouplingFieldDouble.hxx" +#include "MEDCouplingMemArray.hxx" +#include "MEDCouplingGaussLocalization.hxx" +#include "MEDCouplingMultiFields.hxx" +#include "MEDCouplingFieldOverTime.hxx" + +#include +#include +#include + +using namespace ParaMEDMEM; + +void MEDCouplingBasicsTest::testDescriptionInMeshTimeUnit1() +{ + static const char text1[]="totoTTEDD"; + MEDCouplingUMesh *m=build2DTargetMesh_1(); + m->setDescription(text1); + CPPUNIT_ASSERT(std::string(m->getDescription())==text1); + MEDCouplingUMesh *m2=(MEDCouplingUMesh *)m->deepCpy(); + CPPUNIT_ASSERT(m->isEqual(m2,1e-12)); + CPPUNIT_ASSERT(std::string(m2->getDescription())==text1); + m2->setDescription("ggg"); + CPPUNIT_ASSERT(!m->isEqual(m2,1e-12)); + m2->decrRef(); + // + MEDCouplingFieldDouble *f=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME); + f->setTimeUnit(text1); + CPPUNIT_ASSERT(std::string(f->getTimeUnit())==text1); + MEDCouplingFieldDouble *f2=f->deepCpy(); + CPPUNIT_ASSERT(std::string(f2->getTimeUnit())==text1); + f2->decrRef(); + // + f->decrRef(); + m->decrRef(); +} + +void MEDCouplingBasicsTest::testMultiFields1() +{ + MEDCouplingMultiFields *mfs=buildMultiFields_1(); + std::vector ms=mfs->getMeshes(); + std::vector refs; + std::vector dms=mfs->getDifferentMeshes(refs); + std::vector das=mfs->getArrays(); + std::vector< std::vector > refs2; + std::vector das2=mfs->getDifferentArrays(refs2); + // + CPPUNIT_ASSERT_EQUAL(5,(int)ms.size()); + CPPUNIT_ASSERT_EQUAL(2,(int)dms.size()); + CPPUNIT_ASSERT_EQUAL(6,(int)das.size()); + CPPUNIT_ASSERT_EQUAL(5,(int)das2.size()); + // + MEDCouplingMultiFields *mfs2=mfs->deepCpy(); + CPPUNIT_ASSERT(mfs->isEqual(mfs2,1e-12,1e-12)); + mfs2->decrRef(); + // + mfs->decrRef(); +} + +void MEDCouplingBasicsTest::testFieldOverTime1() +{ + std::vector fs=buildMultiFields_2(); + CPPUNIT_ASSERT_THROW(MEDCouplingFieldOverTime::New(fs),INTERP_KERNEL::Exception); + MEDCouplingFieldDouble *f4bis=fs[4]->buildNewTimeReprFromThis(ONE_TIME,false); + fs[4]->decrRef(); + fs[4]=f4bis; + CPPUNIT_ASSERT_THROW(MEDCouplingFieldOverTime::New(fs),INTERP_KERNEL::Exception); + f4bis->setTime(2.7,20,21); + MEDCouplingFieldOverTime *fot=MEDCouplingFieldOverTime::New(fs); + MEDCouplingDefinitionTime dt=fot->getDefinitionTimeZone(); + dt.appendRepr(std::cout); + // + for(std::vector::iterator it=fs.begin();it!=fs.end();it++) + (*it)->decrRef(); + fot->decrRef(); +} diff --git a/src/MEDCoupling/Test/Makefile.am b/src/MEDCoupling/Test/Makefile.am index 875fcf4ae..282b92059 100755 --- a/src/MEDCoupling/Test/Makefile.am +++ b/src/MEDCoupling/Test/Makefile.am @@ -26,7 +26,8 @@ TestMEDCoupling_CPPFLAGS=@CPPUNIT_INCLUDES@ @PTHREAD_CFLAGS@ -I$(srcdir)/.. -I$( TestMEDCoupling_LDFLAGS = @CPPUNIT_LIBS@ ../libmedcoupling.la ../../INTERP_KERNEL/libinterpkernel.la dist_TestMEDCoupling_SOURCES = TestMEDCoupling.cxx MEDCouplingBasicsTest.hxx MEDCouplingBasicsTest0.cxx MEDCouplingBasicsTest1.cxx \ - MEDCouplingBasicsTest2.cxx MEDCouplingBasicsTestInterp.cxx MEDCouplingBasicsTestData1.hxx + MEDCouplingBasicsTest2.cxx MEDCouplingBasicsTest3.cxx MEDCouplingBasicsTestInterp.cxx MEDCouplingBasicsTestData1.hxx \ + MEDCouplingBasicsTest4.cxx TestMEDCouplingRemapper_CPPFLAGS=@CPPUNIT_INCLUDES@ @PTHREAD_CFLAGS@ -I$(srcdir)/.. -I$(srcdir)/../../INTERP_KERNEL/Bases -I$(srcdir)/../../INTERP_KERNELTest -I$(srcdir)/../../INTERP_KERNEL -I$(srcdir)/../../INTERP_KERNEL/Geometric2D diff --git a/src/MEDCoupling_Swig/MEDCoupling.i b/src/MEDCoupling_Swig/MEDCoupling.i index fb0289529..1513af1b5 100644 --- a/src/MEDCoupling_Swig/MEDCoupling.i +++ b/src/MEDCoupling_Swig/MEDCoupling.i @@ -34,6 +34,9 @@ #include "MEDCouplingFieldTemplate.hxx" #include "MEDCouplingGaussLocalization.hxx" #include "MEDCouplingAutoRefCountObjectPtr.hxx" +#include "MEDCouplingMultiFields.hxx" +#include "MEDCouplingFieldOverTime.hxx" +#include "MEDCouplingDefinitionTime.hxx" #include "MEDCouplingTypemaps.i" #include "InterpKernelAutoPtr.hxx" @@ -56,6 +59,11 @@ using namespace INTERP_KERNEL; $result=convertMesh($1,$owner); } +%typemap(out) ParaMEDMEM::MEDCouplingMultiFields* +{ + $result=convertMultiFields($1,$owner); +} + #ifdef WITH_NUMPY2 %init %{ import_array(); %} #endif @@ -111,6 +119,7 @@ using namespace INTERP_KERNEL; %newobject ParaMEDMEM::DataArrayInt::keepSelectedComponents; %newobject ParaMEDMEM::DataArrayInt::selectByTupleId; %newobject ParaMEDMEM::DataArrayInt::selectByTupleIdSafe; +%newobject ParaMEDMEM::DataArrayInt::checkAndPreparePermutation; %newobject ParaMEDMEM::DataArrayInt::renumber; %newobject ParaMEDMEM::DataArrayInt::renumberR; %newobject ParaMEDMEM::DataArrayInt::renumberAndReduce; @@ -166,6 +175,7 @@ using namespace INTERP_KERNEL; %newobject ParaMEDMEM::DataArrayDouble::fromPolarToCart; %newobject ParaMEDMEM::DataArrayDouble::fromCylToCart; %newobject ParaMEDMEM::DataArrayDouble::fromSpherToCart; +%newobject ParaMEDMEM::MEDCouplingMesh::deepCpy; %newobject ParaMEDMEM::MEDCouplingMesh::getCoordinatesAndOwner; %newobject ParaMEDMEM::MEDCouplingMesh::getBarycenterAndOwner; %newobject ParaMEDMEM::MEDCouplingMesh::buildOrthogonalField; @@ -207,6 +217,10 @@ using namespace INTERP_KERNEL; %newobject ParaMEDMEM::MEDCouplingExtrudedMesh::build3DUnstructuredMesh; %newobject ParaMEDMEM::MEDCouplingCMesh::New; %newobject ParaMEDMEM::MEDCouplingCMesh::getCoordsAt; +%newobject ParaMEDMEM::MEDCouplingMultiFields::New; +%newobject ParaMEDMEM::MEDCouplingMultiFields::deepCpy; +%newobject ParaMEDMEM::MEDCouplingFieldOverTime::New; + %feature("unref") DataArrayDouble "$this->decrRef();" %feature("unref") MEDCouplingPointSet "$this->decrRef();" %feature("unref") MEDCouplingMesh "$this->decrRef();" @@ -216,6 +230,7 @@ using namespace INTERP_KERNEL; %feature("unref") DataArrayInt "$this->decrRef();" %feature("unref") MEDCouplingField "$this->decrRef();" %feature("unref") MEDCouplingFieldDouble "$this->decrRef();" +%feature("unref") MEDCouplingMultiFields "$this->decrRef();" %rename(assign) *::operator=; %ignore ParaMEDMEM::MemArray::operator=; @@ -262,10 +277,13 @@ namespace ParaMEDMEM class MEDCouplingMesh : public RefCountObject, public TimeLabel { public: - void setName(const char *name) { _name=name; } - const char *getName() const { return _name.c_str(); } + void setName(const char *name); + const char *getName() const; + void setDescription(const char *descr); + const char *getDescription() const; virtual MEDCouplingMeshType getType() const throw(INTERP_KERNEL::Exception) = 0; bool isStructured() const throw(INTERP_KERNEL::Exception); + virtual MEDCouplingMesh *deepCpy() const = 0; virtual bool isEqual(const MEDCouplingMesh *other, double prec) const throw(INTERP_KERNEL::Exception); virtual bool isEqualWithoutConsideringStr(const MEDCouplingMesh *other, double prec) const throw(INTERP_KERNEL::Exception) = 0; virtual void copyTinyStringsFrom(const MEDCouplingMesh *other) throw(INTERP_KERNEL::Exception); @@ -1785,6 +1803,9 @@ namespace ParaMEDMEM { public: static MEDCouplingFieldDouble *New(TypeOfField type, TypeOfTimeDiscretization td=NO_TIME); + static MEDCouplingFieldDouble *New(const MEDCouplingFieldTemplate *ft, TypeOfTimeDiscretization td=NO_TIME); + void setTimeUnit(const char *unit); + const char *getTimeUnit() const; void copyTinyStringsFrom(const MEDCouplingFieldDouble *other) throw(INTERP_KERNEL::Exception); void copyTinyAttrFrom(const MEDCouplingFieldDouble *other) throw(INTERP_KERNEL::Exception); std::string simpleRepr() const; @@ -1885,6 +1906,35 @@ namespace ParaMEDMEM return ret; } + PyObject *getArrays() const throw(INTERP_KERNEL::Exception) + { + std::vector arrs=self->getArrays(); + for(std::vector::iterator it=arrs.begin();it!=arrs.end();it++) + if(*it) + (*it)->incrRef(); + int sz=arrs.size(); + PyObject *ret=PyTuple_New(sz); + for(int i=0;i tmp; + convertPyObjToVecDataArrayDblCst(ls,tmp); + int sz=tmp.size(); + std::vector arrs(sz); + for(int i=0;i(tmp[i]); + self->setArrays(arrs); + } + DataArrayDouble *getEndArray() const throw(INTERP_KERNEL::Exception) { DataArrayDouble *ret=self->getEndArray(); @@ -2094,5 +2144,199 @@ namespace ParaMEDMEM { public: static MEDCouplingFieldTemplate *New(const MEDCouplingFieldDouble *f) throw(INTERP_KERNEL::Exception); + std::string simpleRepr() const; + std::string advancedRepr() const; + %extend + { + std::string __str__() const + { + return self->simpleRepr(); + } + } + }; + + class MEDCouplingMultiFields : public RefCountObject, public TimeLabel + { + public: + int getNumberOfFields() const; + MEDCouplingMultiFields *deepCpy() const; + virtual std::string simpleRepr() const; + virtual std::string advancedRepr() const; + virtual bool isEqual(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const; + virtual bool isEqualWithoutConsideringStr(const MEDCouplingMultiFields *other, double meshPrec, double valsPrec) const; + virtual void checkCoherency() const throw(INTERP_KERNEL::Exception); + %extend + { + std::string __str__() const + { + return self->simpleRepr(); + } + static MEDCouplingMultiFields *New(PyObject *li) throw(INTERP_KERNEL::Exception) + { + std::vector tmp; + convertPyObjToVecFieldDblCst(li,tmp); + int sz=tmp.size(); + std::vector fs(sz); + for(int i=0;i(tmp[i]); + return MEDCouplingMultiFields::New(fs); + } + PyObject *getFields() const + { + std::vector fields=self->getFields(); + int sz=fields.size(); + PyObject *res = PyList_New(sz); + for(int i=0;iincrRef(); + PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(fields[i]),SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 )); + } + else + { + PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(0),SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble, 0 )); + } + } + return res; + } + PyObject *getFieldAtPos(int id) const throw(INTERP_KERNEL::Exception) + { + const MEDCouplingFieldDouble *ret=self->getFieldAtPos(id); + if(ret) + { + ret->incrRef(); + return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 ); + } + else + return SWIG_NewPointerObj(SWIG_as_voidptr(0),SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble, 0 ); + } + PyObject *getMeshes() const throw(INTERP_KERNEL::Exception) + { + std::vector ms=self->getMeshes(); + int sz=ms.size(); + PyObject *res = PyList_New(sz); + for(int i=0;iincrRef(); + PyList_SetItem(res,i,convertMesh(ms[i], SWIG_POINTER_OWN | 0 )); + } + else + { + PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(0),SWIGTYPE_p_ParaMEDMEM__MEDCouplingUMesh, 0 )); + } + } + return res; + } + PyObject *getDifferentMeshes() const throw(INTERP_KERNEL::Exception) + { + std::vector refs; + std::vector ms=self->getDifferentMeshes(refs); + int sz=ms.size(); + PyObject *res = PyList_New(sz); + for(int i=0;iincrRef(); + PyList_SetItem(res,i,convertMesh(ms[i], SWIG_POINTER_OWN | 0 )); + } + else + { + PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(0),SWIGTYPE_p_ParaMEDMEM__MEDCouplingUMesh, 0 )); + } + } + // + PyObject *ret=PyTuple_New(2); + PyTuple_SetItem(ret,0,res); + PyTuple_SetItem(ret,1,convertIntArrToPyList2(refs)); + return ret; + } + PyObject *getArrays() const throw(INTERP_KERNEL::Exception) + { + std::vector ms=self->getArrays(); + int sz=ms.size(); + PyObject *res = PyList_New(sz); + for(int i=0;iincrRef(); + PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(ms[i]),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 )); + } + else + { + PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(0),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, 0 )); + } + } + return res; + } + PyObject *getDifferentArrays() const throw(INTERP_KERNEL::Exception) + { + std::vector< std::vector > refs; + std::vector ms=self->getDifferentArrays(refs); + int sz=ms.size(); + PyObject *res = PyList_New(sz); + PyObject *res2 = PyList_New(sz); + for(int i=0;iincrRef(); + PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(ms[i]),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 )); + } + else + { + PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(0),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, 0 )); + } + PyList_SetItem(res2,i,convertIntArrToPyList2(refs[i])); + } + // + PyObject *ret=PyTuple_New(2); + PyTuple_SetItem(ret,0,res); + PyTuple_SetItem(ret,1,res2); + return ret; + } + } + }; + + class MEDCouplingDefinitionTime + { + public: + %extend + { + std::string __str__() const + { + std::ostringstream oss; + self->appendRepr(oss); + return oss.str(); + } + } + }; + + class MEDCouplingFieldOverTime : public MEDCouplingMultiFields + { + public: + double getTimeTolerance() const throw(INTERP_KERNEL::Exception); + MEDCouplingDefinitionTime getDefinitionTimeZone() const; + %extend + { + std::string __str__() const + { + return self->simpleRepr(); + } + static MEDCouplingFieldOverTime *New(PyObject *li) throw(INTERP_KERNEL::Exception) + { + std::vector tmp; + convertPyObjToVecFieldDblCst(li,tmp); + int sz=tmp.size(); + std::vector fs(sz); + for(int i=0;i(tmp[i]); + return MEDCouplingFieldOverTime::New(fs); + } + } }; } diff --git a/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py b/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py index fb59d4ce5..002d8dd0d 100644 --- a/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py +++ b/src/MEDCoupling_Swig/MEDCouplingBasicsTest.py @@ -5966,6 +5966,45 @@ class MEDCouplingBasicsTest(unittest.TestCase): pass self.assertEqual(m.getName(),"My0D"); pass + + def testDescriptionInMeshTimeUnit1(self): + text1="totoTTEDD"; + m=MEDCouplingDataForTest.build2DTargetMesh_1(); + m.setDescription(text1); + self.assertEqual(m.getDescription(),text1); + m2=m.deepCpy(); + self.assertTrue(m.isEqual(m2,1e-12)); + self.assertEqual(m2.getDescription(),text1); + m2.setDescription("ggg"); + self.assertTrue(not m.isEqual(m2,1e-12)); + # + f=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME); + f.setTimeUnit(text1); + self.assertEqual(f.getTimeUnit(),text1); + f2=f.deepCpy(); + self.assertEqual(f2.getTimeUnit(),text1); + # + pass + + def testMultiFields1(self): + mfs=MEDCouplingDataForTest.buildMultiFields_1(); + ms=mfs.getMeshes(); + dms,refs=mfs.getDifferentMeshes() + das=mfs.getArrays(); + das2,refs2=mfs.getDifferentArrays() + self.assertEqual(5,len(mfs.getFields())) + self.assertEqual(1,len(mfs.getFields()[0].getArrays())); + self.assertEqual(2,len(mfs.getFields()[1].getArrays())); + self.assertEqual(1,len(mfs.getFields()[2].getArrays())); + self.assertEqual(1,len(mfs.getFields()[3].getArrays())); + self.assertEqual(1,len(mfs.getFields()[4].getArrays())); + self.assertEqual(5,len(ms)); + self.assertEqual(2,len(dms)); + self.assertEqual(6,len(das)); + self.assertEqual(5,len(das2)); + mfs2=mfs.deepCpy(); + self.assertTrue(mfs.isEqual(mfs2,1e-12,1e-12)) + pass def setUp(self): pass diff --git a/src/MEDCoupling_Swig/MEDCouplingDataForTest.py b/src/MEDCoupling_Swig/MEDCouplingDataForTest.py index e00c447ea..846495e78 100644 --- a/src/MEDCoupling_Swig/MEDCouplingDataForTest.py +++ b/src/MEDCoupling_Swig/MEDCouplingDataForTest.py @@ -321,6 +321,61 @@ class MEDCouplingDataForTest: targetMesh.setCoords(myCoords); return targetMesh; + def buildMultiFields_1(cls): + m1=MEDCouplingDataForTest.build2DTargetMesh_1(); + m1.setName("m1"); + m2=MEDCouplingDataForTest.build2DTargetMesh_1(); + m2.setName("m2"); + vals0=[-0.7,-1.,-2.,-3.,-4.]; + vals1=[0.,1.,2.,3.,4.,0.1,0.2,0.3,0.4]; + vals1_1=[170.,171.,172.,173.,174.,170.1,170.2,170.3,170.4]; + vals2=[5.,6.,7.,8.,9.]; + vals4=[15.,16.,17.,18.,19.]; + d0=DataArrayDouble.New(); + d0.setValues(vals0,5,1); + d1=DataArrayDouble.New(); + d1.setValues(vals1,9,1); + d1_1=DataArrayDouble.New(); + d1_1.setValues(vals1_1,9,1); + d2=DataArrayDouble.New(); + d2.setValues(vals2,5,1); + d4=DataArrayDouble.New(); + d4.setValues(vals4,5,1); + d0.setName("d0"); d1.setName("d1"); d1_1.setName("d1_1"); d2.setName("d2"); d4.setName("d4"); + d0.setInfoOnComponent(0,"c1"); + d1.setInfoOnComponent(0,"c6"); + d1_1.setInfoOnComponent(0,"c9"); + d2.setInfoOnComponent(0,"c5"); + d4.setInfoOnComponent(0,"c7"); + f0=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME); + f0.setMesh(m1); + f0.setArray(d0); + f0.setTime(0.2,5,6); + f0.setName("f0"); + f1=MEDCouplingFieldDouble.New(ON_NODES,LINEAR_TIME); + f1.setMesh(m1); + f1.setArrays([d1,d1_1]); + f1.setStartTime(0.7,7,8); + f1.setEndTime(1.2,9,10); + f1.setName("f1"); + f2=MEDCouplingFieldDouble.New(ON_CELLS,CONST_ON_TIME_INTERVAL); + f2.setMesh(m2); + f2.setArray(d2); + f2.setTime(1.2,11,12); + f2.setEndTime(1.5,13,14); + f2.setName("f2"); + f3=MEDCouplingFieldDouble.New(ON_CELLS,ONE_TIME); + f3.setMesh(m1); + f3.setArray(d2); + f3.setTime(1.7,15,16); + f3.setName("f3"); + f4=MEDCouplingFieldDouble.New(ON_CELLS,NO_TIME); + f4.setMesh(m2); + f4.setArray(d4); + f4.setName("f4"); + ret=MEDCouplingMultiFields.New([f0,f1,f2,f3,f4]); + return ret; + build2DTargetMesh_1=classmethod(build2DTargetMesh_1) build2DSourceMesh_1=classmethod(build2DSourceMesh_1) build3DTargetMesh_1=classmethod(build3DTargetMesh_1) @@ -335,4 +390,5 @@ class MEDCouplingDataForTest: build2DCurveTargetMesh_3=classmethod(build2DCurveTargetMesh_3) build2DTargetMesh_3=classmethod(build2DTargetMesh_3) build2DTargetMesh_4=classmethod(build2DTargetMesh_4) + buildMultiFields_1=classmethod(buildMultiFields_1) pass diff --git a/src/MEDCoupling_Swig/MEDCouplingTypemaps.i b/src/MEDCoupling_Swig/MEDCouplingTypemaps.i index a42063aec..7dfc7fa10 100644 --- a/src/MEDCoupling_Swig/MEDCouplingTypemaps.i +++ b/src/MEDCoupling_Swig/MEDCouplingTypemaps.i @@ -39,6 +39,16 @@ static PyObject* convertMesh(ParaMEDMEM::MEDCouplingMesh* mesh, int owner) throw return ret; } +static PyObject* convertMultiFields(ParaMEDMEM::MEDCouplingMultiFields *mfs, int owner) throw(INTERP_KERNEL::Exception) +{ + PyObject *ret=0; + if(dynamic_cast(mfs)) + ret=SWIG_NewPointerObj((void*)mfs,SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldOverTime,owner); + else + ret=SWIG_NewPointerObj((void*)mfs,SWIGTYPE_p_ParaMEDMEM__MEDCouplingMultiFields,owner); + return ret; +} + static PyObject *convertIntArrToPyList(const int *ptr, int size) throw(INTERP_KERNEL::Exception) { #ifndef WITH_NUMPY2