return getFather()->getMesh();
}
+MEDFileEquivalencePair *MEDFileEquivalencePair::deepCpy(MEDFileEquivalences *father) const
+{
+ MEDCouplingAutoRefCountObjectPtr<MEDFileEquivalencePair> ret(new MEDFileEquivalencePair(father,_name,_description));
+ const MEDFileEquivalenceCell *cell(_cell);
+ if(cell)
+ ret->_cell=cell->deepCpy(const_cast<MEDFileEquivalencePair *>(this));
+ const MEDFileEquivalenceNode *node(_node);
+ if(node)
+ ret->_node=node->deepCpy(const_cast<MEDFileEquivalencePair *>(this));
+ return ret.retn();
+}
+
+bool MEDFileEquivalencePair::isEqual(const MEDFileEquivalencePair *other, std::string& what) const
+{
+ if(_name!=other->_name)
+ {
+ std::ostringstream oss; oss << "Names differs : " << _name << " != " << other->_name << " !";
+ what=oss.str();
+ return false;
+ }
+ if(_description!=other->_description)
+ {
+ std::ostringstream oss; oss << "Description differs : " << _description << " != " << other->_description << " !";
+ what=oss.str();
+ return false;
+ }
+ const MEDFileEquivalenceCell *c1(_cell),*c2(other->_cell);
+ if((c1 && !c2) || (!c1 && c2))
+ {
+ std::ostringstream oss; oss << "Cell def of Equiv " << _name << " are defined for this and not for other (or reversely) !";
+ what=oss.str();
+ return false;
+ }
+ if(c1 && c2)
+ if(!c1->isEqual(c2,what))
+ return false;
+ const MEDFileEquivalenceNode *n1(_node),*n2(other->_node);
+ if((n1 && !n2) || (!n1 && n2))
+ {
+ std::ostringstream oss; oss << "Node def of Equiv " << _name << " are defined for this and not for other (or reversely) !";
+ what=oss.str();
+ return false;
+ }
+ if(n1 && n2)
+ if(!n1->isEqual(n2,what))
+ return false;
+ return true;
+}
+
+void MEDFileEquivalencePair::getRepr(std::ostream& oss) const
+{
+ const MEDFileEquivalenceNode *node(_node);
+ const MEDFileEquivalenceCell *cell(_cell);
+ oss << std::endl << " name of equivalence : " << _name << std::endl;
+ oss << " description of equivalence : " << _description << std::endl;
+ oss << " Node : ";
+ if(!node)
+ oss << "None" << std::endl;
+ else
+ node->getRepr(oss);
+ oss << " Cell : ";
+ if(!cell)
+ oss << "None" << std::endl;
+ else
+ cell->getRepr(oss);
+}
+
MEDFileEquivalencePair *MEDFileEquivalencePair::New(MEDFileEquivalences *father, const std::string& name)
{
return new MEDFileEquivalencePair(father,name,std::string());
return elt;
}
+MEDFileEquivalences *MEDFileEquivalences::deepCpy(MEDFileMesh *owner) const
+{
+ MEDCouplingAutoRefCountObjectPtr<MEDFileEquivalences> ret(new MEDFileEquivalences(owner));
+ ret->deepCpyFrom(*this);
+ return ret.retn();
+}
+
+bool MEDFileEquivalences::isEqual(const MEDFileEquivalences *other, std::string& what) const
+{
+ std::size_t sz(_equ.size());
+ if(sz!=other->_equ.size())
+ {
+ what="Equivalences differs : not same number !";
+ return false;
+ }
+ for(std::size_t i=0;i<sz;i++)
+ {
+ const MEDFileEquivalencePair *thisp(_equ[i]),*otherp(other->_equ[i]);
+ if(!thisp && !otherp)
+ continue;
+ if(thisp && otherp)
+ {
+ if(!thisp->isEqual(otherp,what))
+ {
+ std::ostringstream oss; oss << "At Eq #" << i << " there is a difference !";
+ what=oss.str()+what;
+ return false;
+ }
+ }
+ else
+ {
+ std::ostringstream oss; oss << "At Eq #" << i << " defined in this not is other (or reversely) !";
+ what=oss.str()+what;
+ return false;
+ }
+ }
+}
+
+void MEDFileEquivalences::getRepr(std::ostream& oss) const
+{
+ std::size_t ii(0);
+ for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileEquivalencePair> >::const_iterator it=_equ.begin();it!=_equ.end();it++,ii++)
+ {
+ const MEDFileEquivalencePair *elt(*it);
+ oss << "Equivalence #" << ii << " : " ;
+ if(elt)
+ elt->getRepr(oss);
+ else
+ oss << "None" << std::endl;
+ }
+}
+
void MEDFileEquivalences::killEquivalenceWithName(const std::string& name)
{
std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileEquivalencePair> >::iterator it(_equ.begin());
}
}
+void MEDFileEquivalences::deepCpyFrom(const MEDFileEquivalences& other)
+{
+ for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileEquivalencePair> >::const_iterator it=other._equ.begin();it!=other._equ.end();it++)
+ {
+ const MEDFileEquivalencePair *elt(*it);
+ MEDCouplingAutoRefCountObjectPtr<MEDFileEquivalencePair> eltCpy;
+ if(elt)
+ {
+ eltCpy=elt->deepCpy(this);
+ }
+ _equ.push_back(eltCpy);
+ }
+}
+
MEDFileEquivalenceBase::MEDFileEquivalenceBase(MEDFileEquivalencePair *father):_father(father)
{
}
return ret;
}
+bool MEDFileEquivalenceData::isEqual(const MEDFileEquivalenceData *other, std::string& what) const
+{
+ const DataArrayInt *d1(_data),*d2(other->_data);
+ if((!d1 && d2) || (d1 && !d2))
+ {
+ what="Data array is defined in this not in other (or reversely) !";
+ return false;
+ }
+ if(d1 && d2)
+ {
+ if(!d1->isEqualIfNotWhy(*d2,what))
+ return false;
+ }
+ return true;
+}
+
void MEDFileEquivalenceData::writeLL(med_idt fid, med_entity_type medtype, med_geometry_type medgt) const
{
return sizeof(MEDFileEquivalenceCellType);
}
+MEDFileEquivalenceCellType *MEDFileEquivalenceCellType::deepCpy(MEDFileEquivalencePair *owner) const
+{
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da;
+ if(getArray())
+ da=getArray()->deepCpy();
+ return new MEDFileEquivalenceCellType(owner,_type,da);
+}
+
+bool MEDFileEquivalenceCellType::isEqual(const MEDFileEquivalenceCellType *other, std::string& what) const
+{
+ if(_type!=other->_type)
+ {
+ what="Geo types differs !";
+ return false;
+ }
+ return MEDFileEquivalenceData::isEqual(other,what);
+}
+
+void MEDFileEquivalenceCellType::getRepr(std::ostream& oss) const
+{
+ const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(_type));
+ const DataArrayInt *da(getArray());
+ oss << cm.getRepr() << ":";
+ if(da)
+ oss << da->getNumberOfTuples() << " tuples";
+ else
+ oss << "no dataarray";
+ oss << ",";
+}
+
void MEDFileEquivalenceCellType::write(med_idt fid) const
{
writeLL(fid,MED_CELL,typmai3[_type]);
}
}
+MEDFileEquivalenceCell *MEDFileEquivalenceCell::deepCpy(MEDFileEquivalencePair *owner) const
+{
+ MEDCouplingAutoRefCountObjectPtr<MEDFileEquivalenceCell> ret(new MEDFileEquivalenceCell(owner));
+ for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileEquivalenceCellType> >::const_iterator it=_types.begin();it!=_types.end();it++)
+ {
+ const MEDFileEquivalenceCellType *elt(*it);
+ MEDCouplingAutoRefCountObjectPtr<MEDFileEquivalenceCellType> eltCpy;
+ if(elt)
+ eltCpy=elt->deepCpy(owner);
+ ret->_types.push_back(eltCpy);
+ }
+ return ret.retn();
+}
+
+bool MEDFileEquivalenceCell::isEqual(const MEDFileEquivalenceCell *other, std::string& what) const
+{
+ std::size_t sz(_types.size());
+ if(sz!=other->_types.size())
+ {
+ std::ostringstream oss; oss << "Nb of geo types differs : " << sz << " != " << other->_types.size();
+ what=oss.str();
+ return false;
+ }
+ for(std::size_t i=0;i<sz;i++)
+ {
+ const MEDFileEquivalenceCellType *ct1(_types[i]),*ct2(other->_types[i]);
+ if((ct1 && !ct2) || (!ct1 && ct2))
+ {
+ std::ostringstream oss; oss << "At gt #" << i << " this is defined not other (or reversely !)";
+ what=oss.str();
+ return false;
+ }
+ if(ct1 && ct2)
+ {
+ if(!ct1->isEqual(ct2,what))
+ {
+ std::ostringstream oss; oss << "At gt #" << i << " of Eq " << getFather()->getName() << " it differs !";
+ what=oss.str()+what;
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+void MEDFileEquivalenceCell::getRepr(std::ostream& oss) const
+{
+ for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileEquivalenceCellType> >::const_iterator it=_types.begin();it!=_types.end();it++)
+ {
+ const MEDFileEquivalenceCellType *elt(*it);
+ if(elt)
+ elt->getRepr(oss);
+ }
+}
+
DataArrayInt *MEDFileEquivalenceCell::getArray(INTERP_KERNEL::NormalizedCellType type)
{
for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileEquivalenceCellType> >::iterator it=_types.begin();it!=_types.end();it++)
{
writeLL(fid,MED_NODE,MED_NONE);
}
+
+MEDFileEquivalenceNode *MEDFileEquivalenceNode::deepCpy(MEDFileEquivalencePair *owner) const
+{
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da;
+ if(getArray())
+ da=getArray()->deepCpy();
+ MEDCouplingAutoRefCountObjectPtr<MEDFileEquivalenceNode> ret(new MEDFileEquivalenceNode(owner,da));
+ return ret.retn();
+}
+
+bool MEDFileEquivalenceNode::isEqual(const MEDFileEquivalenceNode *other, std::string& what) const
+{
+ return MEDFileEquivalenceData::isEqual(other,what);
+}
+
+void MEDFileEquivalenceNode::getRepr(std::ostream& oss) const
+{
+ const DataArrayInt *da(getArray());
+ if(!da)
+ oss << " No dataarray defined !" << std::endl;
+ else
+ oss << da->getNumberOfTuples() << " tuples in node equivalence." << std::endl;
+}
MEDFileEquivalences *getFather() { return _father; }
const MEDFileMesh *getMesh() const;
MEDFileMesh *getMesh();
+ MEDFileEquivalencePair *deepCpy(MEDFileEquivalences *father) const;
+ bool isEqual(const MEDFileEquivalencePair *other, std::string& what) const;
+ void getRepr(std::ostream& oss) const;
static MEDFileEquivalencePair *New(MEDFileEquivalences *father, const std::string& name);
MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
std::string getMeshName() const;
void pushEquivalence(MEDFileEquivalencePair *elt);
static MEDFileEquivalences *New(MEDFileMesh *owner) { return new MEDFileEquivalences(owner); }
+ MEDFileEquivalences *deepCpy(MEDFileMesh *owner) const;
+ bool isEqual(const MEDFileEquivalences *other, std::string& what) const;
+ void getRepr(std::ostream& oss) const;
public:
MEDLOADER_EXPORT MEDFileEquivalencePair *getEquivalence(int i);
MEDLOADER_EXPORT MEDFileEquivalencePair *getEquivalenceWithName(const std::string& name);
static void CheckDataArray(const DataArrayInt *data);
private:
MEDFileEquivalences(MEDFileMesh *owner):_owner(owner) { }
+ void deepCpyFrom(const MEDFileEquivalences& other);
private:
MEDFileMesh *_owner;
std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileEquivalencePair> > _equ;
MEDLOADER_EXPORT const DataArrayInt *getArray() const { return _data; }
MEDLOADER_EXPORT DataArrayInt *getArray() { return _data; }
MEDLOADER_EXPORT std::vector<const BigMemoryObject *> getDirectChildrenWithNull() const;
+ bool isEqual(const MEDFileEquivalenceData *other, std::string& what) const;
protected:
void writeLL(med_idt fid, med_entity_type medtype, med_geometry_type medgt) const;
protected:
MEDFileEquivalenceCellType(MEDFileEquivalencePair *owner, INTERP_KERNEL::NormalizedCellType type, DataArrayInt *data):MEDFileEquivalenceData(owner,data),_type(type) { }
MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
INTERP_KERNEL::NormalizedCellType getType() const { return _type; }
+ MEDFileEquivalenceCellType *deepCpy(MEDFileEquivalencePair *owner) const;
+ bool isEqual(const MEDFileEquivalenceCellType *other, std::string& what) const;
+ void getRepr(std::ostream& oss) const;
public:
void write(med_idt fid) const;
private:
MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
static MEDFileEquivalenceCell *Load(med_idt fid, MEDFileEquivalencePair *owner);
void write(med_idt fid) const;
+ MEDFileEquivalenceCell *deepCpy(MEDFileEquivalencePair *owner) const;
+ bool isEqual(const MEDFileEquivalenceCell *other, std::string& what) const;
+ void getRepr(std::ostream& oss) const;
public:
MEDLOADER_EXPORT void clear() { _types.clear(); }
MEDLOADER_EXPORT std::size_t size() const { return _types.size(); }
MEDFileEquivalenceNode(MEDFileEquivalencePair *owner, DataArrayInt *data):MEDFileEquivalenceData(owner,data) { }
MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const;
void write(med_idt fid) const;
+ MEDFileEquivalenceNode *deepCpy(MEDFileEquivalencePair *owner) const;
+ bool isEqual(const MEDFileEquivalenceNode *other, std::string& what) const;
+ void getRepr(std::ostream& oss) const;
private:
~MEDFileEquivalenceNode() { }
};
return false;
if(!areFamsEqual(other,what))
return false;
+ if(!areEquivalencesEqual(other,what))
+ return false;
return true;
}
MEDFileMesh *MEDFileUMesh::deepCpy() const
{
MEDCouplingAutoRefCountObjectPtr<MEDFileUMesh> ret=new MEDFileUMesh(*this);
+ ret->deepCpyEquivalences(*this);
if((const DataArrayDouble*)_coords)
ret->_coords=_coords->deepCpy();
if((const DataArrayInt*)_fam_coords)
_equiv=MEDFileEquivalences::Load(fid,nbOfEq,this);
}
+void MEDFileMesh::deepCpyEquivalences(const MEDFileMesh& other)
+{
+ const MEDFileEquivalences *equiv(other._equiv);
+ if(equiv)
+ _equiv=equiv->deepCpy(this);
+}
+
+bool MEDFileMesh::areEquivalencesEqual(const MEDFileMesh *other, std::string& what) const
+{
+ const MEDFileEquivalences *thisEq(_equiv),*otherEq(other->_equiv);
+ if(!thisEq && !otherEq)
+ return true;
+ if(thisEq && otherEq)
+ return thisEq->isEqual(otherEq,what);
+ else
+ {
+ what+="Equivalence differs : defined in this and not in other (or reversely) !";
+ return false;
+ }
+}
+
+void MEDFileMesh::getEquivalencesRepr(std::ostream& oss) const
+{
+ const MEDFileEquivalences *equiv(_equiv);
+ if(!equiv)
+ return ;
+ oss << "(******************************)\n(* EQUIVALENCES OF THE MESH : *)\n(******************************)\n";
+ _equiv->getRepr(oss);
+}
+
/*!
* \brief Return number of joints, which is equal to number of adjacent mesh domains
*/
}
oss << std::endl << std::endl;
getFamilyRepr(oss);
+ getEquivalencesRepr(oss);
return oss.str();
}
MEDFileMesh *MEDFileCMesh::deepCpy() const
{
MEDCouplingAutoRefCountObjectPtr<MEDFileCMesh> ret=new MEDFileCMesh(*this);
+ ret->deepCpyEquivalences(*this);
if((const MEDCouplingCMesh*)_cmesh)
ret->_cmesh=static_cast<MEDCouplingCMesh*>(_cmesh->deepCpy());
ret->deepCpyAttributes();
MEDFileMesh *MEDFileCurveLinearMesh::deepCpy() const
{
MEDCouplingAutoRefCountObjectPtr<MEDFileCurveLinearMesh> ret=new MEDFileCurveLinearMesh(*this);
+ ret->deepCpyEquivalences(*this);
if((const MEDCouplingCurveLinearMesh*)_clmesh)
ret->_clmesh=static_cast<MEDCouplingCurveLinearMesh*>(_clmesh->deepCpy());
ret->deepCpyAttributes();
