From 70d5fb9d64c0e66f284d169c083569f0983fef66 Mon Sep 17 00:00:00 2001 From: =?utf8?q?C=C3=A9dric=20Aguerre?= Date: Wed, 2 Dec 2015 14:13:24 +0100 Subject: [PATCH] mv MEDFileEquivalence to medtool subdirectory --- src/MEDLoader/MEDFileEquivalence.cxx | 769 +++++++++++++++++++++++++++ src/MEDLoader/MEDFileEquivalence.hxx | 202 +++++++ 2 files changed, 971 insertions(+) create mode 100644 src/MEDLoader/MEDFileEquivalence.cxx create mode 100644 src/MEDLoader/MEDFileEquivalence.hxx diff --git a/src/MEDLoader/MEDFileEquivalence.cxx b/src/MEDLoader/MEDFileEquivalence.cxx new file mode 100644 index 000000000..5f9ff6de4 --- /dev/null +++ b/src/MEDLoader/MEDFileEquivalence.cxx @@ -0,0 +1,769 @@ +// Copyright (C) 2007-2015 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, or (at your option) any later version. +// +// 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 +// +// Author : Anthony Geay (EDF R&D) + +#include "MEDFileEquivalence.hxx" +#include "MEDFileSafeCaller.txx" +#include "MEDCouplingMemArray.hxx" +#include "MEDLoaderBase.hxx" +#include "MEDFileMesh.hxx" +#include "InterpKernelAutoPtr.hxx" + +extern med_geometry_type typmai[MED_N_CELL_FIXED_GEO]; +extern INTERP_KERNEL::NormalizedCellType typmai2[MED_N_CELL_FIXED_GEO]; +extern med_geometry_type typmai3[34]; +extern med_geometry_type typmainoeud[1]; + +using namespace ParaMEDMEM; + +MEDFileEquivalencePair *MEDFileEquivalencePair::Load(MEDFileEquivalences *father, med_idt fid, const std::string& name, const std::string &desc) +{ + if(!father) + throw INTERP_KERNEL::Exception("MEDFileEquivalencePair::Load : father is NULL ! Should not !"); + MEDCouplingAutoRefCountObjectPtr ret(new MEDFileEquivalencePair(father,name,desc)); + ret->load(fid); + return ret.retn(); +} + +void MEDFileEquivalencePair::write(med_idt fid) const +{ + std::string meshName(getFather()->getMeshName()); + INTERP_KERNEL::AutoPtr meshName2(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE)); + INTERP_KERNEL::AutoPtr name(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE)); + INTERP_KERNEL::AutoPtr desc(MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE)); + MEDLoaderBase::safeStrCpy(meshName.c_str(),MED_NAME_SIZE,meshName2,getFather()->getMesh()->getTooLongStrPolicy()); + MEDLoaderBase::safeStrCpy(_name.c_str(),MED_NAME_SIZE,name,getFather()->getMesh()->getTooLongStrPolicy()); + MEDLoaderBase::safeStrCpy(_description.c_str(),MED_COMMENT_SIZE,desc,getFather()->getMesh()->getTooLongStrPolicy()); + MEDFILESAFECALLERWR0(MEDequivalenceCr,(fid,meshName2,name,desc)); + const MEDFileEquivalenceCell *cell(_cell); + if(cell) + cell->write(fid); + const MEDFileEquivalenceNode *node(_node); + if(node) + node->write(fid); +} + +const MEDFileMesh *MEDFileEquivalencePair::getMesh() const +{ + return getFather()->getMesh(); +} + +MEDFileMesh *MEDFileEquivalencePair::getMesh() +{ + return getFather()->getMesh(); +} + +MEDFileEquivalencePair *MEDFileEquivalencePair::deepCpy(MEDFileEquivalences *father) const +{ + MEDCouplingAutoRefCountObjectPtr ret(new MEDFileEquivalencePair(father,_name,_description)); + const MEDFileEquivalenceCell *cell(_cell); + if(cell) + ret->_cell=cell->deepCpy(const_cast(this)); + const MEDFileEquivalenceNode *node(_node); + if(node) + ret->_node=node->deepCpy(const_cast(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()); +} + +std::vector MEDFileEquivalencePair::getDirectChildrenWithNull() const +{ + std::vector ret(2); + ret[0]=_cell; ret[1]=_node; + return ret; +} + +void MEDFileEquivalencePair::setArray(int meshDimRelToMaxExt, DataArrayInt *da) +{ + if(meshDimRelToMaxExt>1) + throw INTERP_KERNEL::Exception("MEDFileEquivalencePair::setArray : meshDimRelToMaxExt must be in [1,0,-1,-2,-3] at most !"); + if(meshDimRelToMaxExt==1) + { + MEDFileEquivalenceNode *node(_node); + if(!node) + { + _node=new MEDFileEquivalenceNode(this,0); + node=_node; + } + node->setArray(da); + } + else + { + MEDFileEquivalenceCell *cell(_cell); + if(!cell) + { + _cell=new MEDFileEquivalenceCell(this); + cell=_cell; + } + cell->setArray(meshDimRelToMaxExt,da); + } +} + +/*! + * The returned pointer is a borrowed pointer. + */ +MEDFileEquivalenceCell *MEDFileEquivalencePair::initCell() +{ + _cell=new MEDFileEquivalenceCell(this); + return _cell; +} + +/*! + * The returned pointer is a borrowed pointer. + */ +MEDFileEquivalenceNode *MEDFileEquivalencePair::initNode() +{ + _node=new MEDFileEquivalenceNode(this,0); + return _node; +} + +std::size_t MEDFileEquivalencePair::getHeapMemorySizeWithoutChildren() const +{ + return 0; +} + +void MEDFileEquivalencePair::load(med_idt fid) +{ + std::string meshName(_father->getMeshName()); + int dt,it; + _father->getDtIt(dt,it); + med_int ncor; + MEDFILESAFECALLERRD0(MEDequivalenceCorrespondenceSize,(fid,meshName.c_str(),_name.c_str(),dt,it,MED_NODE,MED_NONE,&ncor)); + if(ncor>0) + { + MEDCouplingAutoRefCountObjectPtr da(DataArrayInt::New()); + da->alloc(ncor*2); + MEDFILESAFECALLERRD0(MEDequivalenceCorrespondenceRd,(fid,meshName.c_str(),_name.c_str(),dt,it,MED_NODE,MED_NONE,da->getPointer())); + da->applyLin(1,-1); + da->rearrange(2); + MEDCouplingAutoRefCountObjectPtr node(new MEDFileEquivalenceNode(this,da)); + _node=node; + } + _cell=MEDFileEquivalenceCell::Load(fid,this); +} + +std::vector MEDFileEquivalences::getDirectChildrenWithNull() const +{ + std::size_t sz(_equ.size()); + std::vector ret(sz); + for(std::size_t i=0;igetIteration(); it=_owner->getOrder(); +} + +std::string MEDFileEquivalences::getMeshName() const +{ + return _owner->getName(); +} + +void MEDFileEquivalences::pushEquivalence(MEDFileEquivalencePair *elt) +{ + MEDCouplingAutoRefCountObjectPtr elta(elt); + if(elt) + elt->incrRef(); + _equ.push_back(elta); +} + +MEDFileEquivalencePair *MEDFileEquivalences::getEquivalence(int i) +{ + int sz(size()); + if(i<0 || i>=sz) + { + std::ostringstream oss; oss << "MEDFileEquivalences::getEquivalence : invalid id ! Must be in [0," << sz << ") !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } + return _equ[i]; +} + +MEDFileEquivalencePair *MEDFileEquivalences::getEquivalenceWithName(const std::string& name) +{ + for(std::vector< MEDCouplingAutoRefCountObjectPtr >::iterator it=_equ.begin();it!=_equ.end();it++) + { + MEDFileEquivalencePair *elt(*it); + if(elt) + { + if(elt->getName()==name) + return elt; + } + } + std::ostringstream oss; oss << "MEDFileEquivalences::getEquivalenceWithName : no equivalence with name \"" << name << "\" ! Must be in [ "; + std::vector eqs(getEquivalenceNames()); + std::copy(eqs.begin(),eqs.end(),std::ostream_iterator(oss,", ")); + oss << "] !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); +} + +int MEDFileEquivalences::size() const +{ + return _equ.size(); +} + +std::vector MEDFileEquivalences::getEquivalenceNames() const +{ + std::vector ret; + for(std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_equ.begin();it!=_equ.end();it++) + { + const MEDFileEquivalencePair *elt(*it); + if(elt) + { + ret.push_back(elt->getName()); + } + } + return ret; +} + +MEDFileEquivalencePair *MEDFileEquivalences::appendEmptyEquivalenceWithName(const std::string& name) +{ + MEDCouplingAutoRefCountObjectPtr elt(MEDFileEquivalencePair::New(this,name)); + _equ.push_back(elt); + return elt; +} + +MEDFileEquivalences *MEDFileEquivalences::deepCpy(MEDFileMesh *owner) const +{ + MEDCouplingAutoRefCountObjectPtr 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_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 >::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 >::iterator it(_equ.begin()); + for(;it!=_equ.end();it++) + { + const MEDFileEquivalencePair *elt(*it); + if(elt && elt->getName()==name) + break; + } + if(it==_equ.end()) + { + std::ostringstream oss; oss << "MEDFileEquivalences::killEquivalenceWithName : Equivalence with name \"" << name << "\" not found !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } + _equ.erase(it); +} + +void MEDFileEquivalences::killEquivalenceAt(int i) +{ + int sz(size()); + if(i<0 || i>=sz) + { + std::ostringstream oss; oss << "MEDFileEquivalences::killEquivalenceAt : Id must be in [0," << sz << ") !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } + std::vector< MEDCouplingAutoRefCountObjectPtr >::iterator it(_equ.begin()); + for(int j=0;j >::const_iterator it=_equ.begin();it!=_equ.end();it++) + { + const MEDFileEquivalencePair *elt(*it); + if(elt) + elt->write(fid); + } +} + +int MEDFileEquivalences::PresenceOfEquivalences(med_idt fid, const std::string& meshName) +{ + med_int nequ(MEDnEquivalence(fid,meshName.c_str())); + return nequ; +} + +MEDFileEquivalences *MEDFileEquivalences::Load(med_idt fid, int nbOfEq, MEDFileMesh *owner) +{ + MEDCouplingAutoRefCountObjectPtr ret(new MEDFileEquivalences(owner)); + if(!owner) + throw INTERP_KERNEL::Exception("MEDFileEquivalences::Load : owner is NULL !"); + std::string meshName(owner->getName()); + for(int i=0;i equ(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE)); + INTERP_KERNEL::AutoPtr desc(MEDLoaderBase::buildEmptyString(MED_COMMENT_SIZE)); + int nstep,nocstpncor; + MEDFILESAFECALLERRD0(MEDequivalenceInfo,(fid,meshName.c_str(),i+1,equ,desc,&nstep,&nocstpncor)); + std::string eqName(MEDLoaderBase::buildStringFromFortran(equ,MED_NAME_SIZE)),eqDescName(MEDLoaderBase::buildStringFromFortran(desc,MED_COMMENT_SIZE)); + MEDCouplingAutoRefCountObjectPtr eqv(MEDFileEquivalencePair::Load(ret,fid,eqName,eqDescName)); + ret->pushEquivalence(eqv); + } + return ret.retn(); +} + +void MEDFileEquivalences::CheckDataArray(const DataArrayInt *data) +{ + if(!data) + return; + data->checkAllocated(); + if(data->getNumberOfComponents()!=2) + { + std::ostringstream oss; oss << "MEDFileEquivalences::CheckDataArray : Input DataArray must have 2 components !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } +} + +void MEDFileEquivalences::deepCpyFrom(const MEDFileEquivalences& other) +{ + for(std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=other._equ.begin();it!=other._equ.end();it++) + { + const MEDFileEquivalencePair *elt(*it); + MEDCouplingAutoRefCountObjectPtr eltCpy; + if(elt) + { + eltCpy=elt->deepCpy(this); + } + _equ.push_back(eltCpy); + } +} + +MEDFileEquivalenceBase::MEDFileEquivalenceBase(MEDFileEquivalencePair *father):_father(father) +{ +} + +MEDFileEquivalenceData::MEDFileEquivalenceData(MEDFileEquivalencePair *owner, DataArrayInt *data):MEDFileEquivalenceBase(owner),_data(data) +{ + if(data) + data->incrRef(); +} + +void MEDFileEquivalenceData::setArray(DataArrayInt *data) +{ + MEDFileEquivalences::CheckDataArray(data); + _data=data; + if(data) + data->incrRef(); +} + +std::vector MEDFileEquivalenceData::getDirectChildrenWithNull() const +{ + std::vector ret(1); + ret[0]=_data; + 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 +{ + + const DataArrayInt *da(getArray()); + if(!da) + return ; + MEDFileEquivalences::CheckDataArray(da); + const MEDFileMesh *mesh(getFather()->getMesh()); + int dt,it; + mesh->getTime(dt,it); + std::string meshName(mesh->getName()); + std::string equName(getFather()->getName()); + INTERP_KERNEL::AutoPtr meshName2(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE)); + INTERP_KERNEL::AutoPtr name(MEDLoaderBase::buildEmptyString(MED_NAME_SIZE)); + MEDLoaderBase::safeStrCpy(meshName.c_str(),MED_NAME_SIZE,meshName2,getFather()->getMesh()->getTooLongStrPolicy()); + MEDLoaderBase::safeStrCpy(equName.c_str(),MED_NAME_SIZE,name,getFather()->getMesh()->getTooLongStrPolicy()); + MEDCouplingAutoRefCountObjectPtr da2(da->deepCpy()); da2->rearrange(1); da2->applyLin(1,1); da2->rearrange(2); + MEDFILESAFECALLERWR0(MEDequivalenceCorrespondenceWr,(fid,meshName2,name,dt,it,medtype,medgt,da2->getNumberOfTuples(),da2->begin())); +} + +std::size_t MEDFileEquivalenceCellType::getHeapMemorySizeWithoutChildren() const +{ + return sizeof(MEDFileEquivalenceCellType); +} + +MEDFileEquivalenceCellType *MEDFileEquivalenceCellType::deepCpy(MEDFileEquivalencePair *owner) const +{ + MEDCouplingAutoRefCountObjectPtr 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]); +} + +std::vector MEDFileEquivalenceCell::getDirectChildrenWithNull() const +{ + std::size_t sz(_types.size()); + std::vector ret(sz); + for(std::size_t i=0;i ret(new MEDFileEquivalenceCell(owner)); + ret->load(fid); + if(ret->size()>0) + return ret.retn(); + else + return 0; +} + +void MEDFileEquivalenceCell::write(med_idt fid) const +{ + for(std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_types.begin();it!=_types.end();it++) + { + const MEDFileEquivalenceCellType *ct(*it); + if(ct) + ct->write(fid); + } +} + +MEDFileEquivalenceCell *MEDFileEquivalenceCell::deepCpy(MEDFileEquivalencePair *owner) const +{ + MEDCouplingAutoRefCountObjectPtr ret(new MEDFileEquivalenceCell(owner)); + for(std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_types.begin();it!=_types.end();it++) + { + const MEDFileEquivalenceCellType *elt(*it); + MEDCouplingAutoRefCountObjectPtr 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_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 >::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 >::iterator it=_types.begin();it!=_types.end();it++) + { + MEDFileEquivalenceCellType *elt(*it); + if(elt && elt->getType()==type) + return elt->getArray(); + } + std::ostringstream oss; oss << "MEDFileEquivalenceCell::getArray : In Equivalence \"" << getFather()->getName() << "\" the geotype " << type << " is not available !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); +} + +void MEDFileEquivalenceCell::setArray(int meshDimRelToMax, DataArrayInt *da) +{ + if(!da) + return ; + MEDFileEquivalences::CheckDataArray(da); + MEDFileMesh *mm(getMesh()); + int totalNbOfCells(mm->getNumberOfCellsAtLevel(meshDimRelToMax)); + // + MEDCouplingAutoRefCountObjectPtr tmp(da->deepCpy()); tmp->rearrange(1); + int maxv,minv; + tmp->getMinMaxValues(minv,maxv); + if((minv<0 || minv>=totalNbOfCells) || (maxv<0 || maxv>=totalNbOfCells)) + { + std::ostringstream oss; oss << "MEDFileEquivalenceCell::setArray : Input 2 component DataArray has incorrect values ! all values must be in [0," << totalNbOfCells << ") !"; + throw INTERP_KERNEL::Exception(oss.str().c_str()); + } + // + std::vector gts(mm->getGeoTypesAtLevel(meshDimRelToMax)); + int startId(0),endId; + std::vector compS(1,0); + for(std::vector::const_iterator it=gts.begin();it!=gts.end();it++) + { + endId=startId+mm->getNumberOfCellsWithType(*it); + MEDCouplingAutoRefCountObjectPtr da0(da->keepSelectedComponents(compS)); + MEDCouplingAutoRefCountObjectPtr ids(da0->getIdsInRange(startId,endId)); + MEDCouplingAutoRefCountObjectPtr da1(da->selectByTupleIdSafe(ids->begin(),ids->end())); + da1->applyLin(1,-startId); + setArrayForType(*it,da1); + startId=endId; + } +} + +void MEDFileEquivalenceCell::setArrayForType(INTERP_KERNEL::NormalizedCellType type, DataArrayInt *da) +{ + for(std::vector< MEDCouplingAutoRefCountObjectPtr >::iterator it=_types.begin();it!=_types.end();it++) + { + MEDFileEquivalenceCellType *elt(*it); + if(elt && elt->getType()==type) + { + elt->setArray(da); + return ; + } + } + MEDCouplingAutoRefCountObjectPtr newElt(new MEDFileEquivalenceCellType(getFather(),type,da)); + _types.push_back(newElt); +} + +std::vector MEDFileEquivalenceCell::getTypes() const +{ + std::vector ret; + for(std::vector< MEDCouplingAutoRefCountObjectPtr >::const_iterator it=_types.begin();it!=_types.end();it++) + { + const MEDFileEquivalenceCellType *elt(*it); + if(elt) + ret.push_back(elt->getType()); + } + return ret; +} + +void MEDFileEquivalenceCell::load(med_idt fid) +{ + std::string meshName(getFather()->getFather()->getMeshName()),name(getName()); + int dt,it; + getFather()->getFather()->getDtIt(dt,it); + for(int i=0;i0) + { + MEDCouplingAutoRefCountObjectPtr da(DataArrayInt::New()); + da->alloc(ncor*2); + MEDFILESAFECALLERRD0(MEDequivalenceCorrespondenceRd,(fid,meshName.c_str(),name.c_str(),dt,it,MED_CELL,typmai[i],da->getPointer())); + da->applyLin(1,-1); + da->rearrange(2); + MEDCouplingAutoRefCountObjectPtr ct(new MEDFileEquivalenceCellType(getFather(),typmai2[i],da)); + _types.push_back(ct); + } + } +} + +std::size_t MEDFileEquivalenceNode::getHeapMemorySizeWithoutChildren() const +{ + return sizeof(MEDFileEquivalenceNode); +} + +void MEDFileEquivalenceNode::write(med_idt fid) const +{ + writeLL(fid,MED_NODE,MED_NONE); +} + +MEDFileEquivalenceNode *MEDFileEquivalenceNode::deepCpy(MEDFileEquivalencePair *owner) const +{ + MEDCouplingAutoRefCountObjectPtr da; + if(getArray()) + da=getArray()->deepCpy(); + MEDCouplingAutoRefCountObjectPtr 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; +} diff --git a/src/MEDLoader/MEDFileEquivalence.hxx b/src/MEDLoader/MEDFileEquivalence.hxx new file mode 100644 index 000000000..bcf14904b --- /dev/null +++ b/src/MEDLoader/MEDFileEquivalence.hxx @@ -0,0 +1,202 @@ +// Copyright (C) 2007-2015 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, or (at your option) any later version. +// +// 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 +// +// Author : Anthony Geay (EDF R&D) + +#ifndef __MEDFILEEQUIVALENCE_HXX__ +#define __MEDFILEEQUIVALENCE_HXX__ + +#include "MEDLoaderDefines.hxx" +#include "MEDCouplingRefCountObject.hxx" +#include "MEDCouplingMemArray.hxx" +#include "MEDFileUtilities.hxx" +#include "MEDCouplingAutoRefCountObjectPtr.hxx" + +#include + +namespace ParaMEDMEM +{ + class MEDFileEquivalenceCell; + class MEDFileEquivalenceNode; + class MEDFileEquivalences; + class MEDFileMesh; + + class MEDFileEquivalencePair : public RefCountObject + { + public: + static MEDFileEquivalencePair *Load(MEDFileEquivalences *father, med_idt fid, const std::string& name, const std::string &desc); + void write(med_idt fid) const; + const MEDFileEquivalences *getFather() const { return _father; } + 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 getDirectChildrenWithNull() const; + MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const; + public: + MEDLOADER_EXPORT std::string getName() const { return _name; } + MEDLOADER_EXPORT void setName(const std::string& name) { _name=name; } + MEDLOADER_EXPORT std::string getDescription() const { return _description; } + MEDLOADER_EXPORT void setDescription(const std::string& descr) { _description=descr; } + MEDLOADER_EXPORT MEDFileEquivalenceCell *initCell(); + MEDLOADER_EXPORT MEDFileEquivalenceNode *initNode(); + MEDLOADER_EXPORT MEDFileEquivalenceCell *getCell() { return _cell; } + MEDLOADER_EXPORT MEDFileEquivalenceNode *getNode() { return _node; } + MEDLOADER_EXPORT void setArray(int meshDimRelToMaxExt, DataArrayInt *da); + private: + MEDFileEquivalencePair(MEDFileEquivalences *father, const std::string& name, const std::string& desc):_father(father),_name(name),_description(desc) { } + void load(med_idt fid); + private: + MEDFileEquivalences *_father; + std::string _name; + std::string _description; + MEDCouplingAutoRefCountObjectPtr _cell; + MEDCouplingAutoRefCountObjectPtr _node; + }; + + class MEDFileEquivalences : public RefCountObject + { + public: + MEDLOADER_EXPORT std::vector getDirectChildrenWithNull() const; + MEDLOADER_EXPORT std::size_t getHeapMemorySizeWithoutChildren() const; + MEDLOADER_EXPORT const MEDFileMesh *getMesh() const { return _owner; } + MEDLOADER_EXPORT MEDFileMesh *getMesh() { return _owner; } + void getDtIt(int &dt, int &it) 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); + MEDLOADER_EXPORT int size() const; + MEDLOADER_EXPORT std::vector getEquivalenceNames() const; + MEDLOADER_EXPORT MEDFileEquivalencePair *appendEmptyEquivalenceWithName(const std::string& name); + MEDLOADER_EXPORT void killEquivalenceWithName(const std::string& name); + MEDLOADER_EXPORT void killEquivalenceAt(int i); + MEDLOADER_EXPORT void clear(); + public: + void write(med_idt fid) const; + static int PresenceOfEquivalences(med_idt fid, const std::string& meshName); + static MEDFileEquivalences *Load(med_idt fid, int nbOfEq, MEDFileMesh *owner); + static void CheckDataArray(const DataArrayInt *data); + private: + MEDFileEquivalences(MEDFileMesh *owner):_owner(owner) { } + void deepCpyFrom(const MEDFileEquivalences& other); + private: + MEDFileMesh *_owner; + std::vector< MEDCouplingAutoRefCountObjectPtr > _equ; + }; + + class MEDFileEquivalenceBase : public RefCountObject + { + protected: + MEDFileEquivalenceBase(MEDFileEquivalencePair *father); + const MEDFileEquivalencePair *getFather() const { return _father; } + MEDFileEquivalencePair *getFather() { return _father; } + const MEDFileMesh *getMesh() const { return getFather()->getMesh(); } + MEDFileMesh *getMesh() { return getFather()->getMesh(); } + protected: + ~MEDFileEquivalenceBase() { } + private: + MEDFileEquivalencePair *_father; + }; + + class MEDFileEquivalenceData : public MEDFileEquivalenceBase + { + public: + MEDFileEquivalenceData(MEDFileEquivalencePair *owner, DataArrayInt *data); + MEDLOADER_EXPORT void setArray(DataArrayInt *data); + MEDLOADER_EXPORT const DataArrayInt *getArray() const { return _data; } + MEDLOADER_EXPORT DataArrayInt *getArray() { return _data; } + MEDLOADER_EXPORT std::vector 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: + ~MEDFileEquivalenceData() { } + protected: + MEDCouplingAutoRefCountObjectPtr _data; + }; + + class MEDFileEquivalenceCellType : public MEDFileEquivalenceData + { + public: + 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: + ~MEDFileEquivalenceCellType() { } + private: + INTERP_KERNEL::NormalizedCellType _type; + }; + + class MEDFileEquivalenceCell : public MEDFileEquivalenceBase + { + public: + MEDLOADER_EXPORT std::vector getDirectChildrenWithNull() const; + 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(); } + MEDLOADER_EXPORT DataArrayInt *getArray(INTERP_KERNEL::NormalizedCellType type); + MEDLOADER_EXPORT void setArray(int meshDimRelToMax, DataArrayInt *da); + MEDLOADER_EXPORT void setArrayForType(INTERP_KERNEL::NormalizedCellType type, DataArrayInt *da); + MEDLOADER_EXPORT std::vector getTypes() const; + public: + MEDFileEquivalenceCell(MEDFileEquivalencePair *owner):MEDFileEquivalenceBase(owner) { } + private: + ~MEDFileEquivalenceCell() { } + private: + void load(med_idt fid); + std::string getName() const { return getFather()->getName(); } + private: + std::vector< MEDCouplingAutoRefCountObjectPtr > _types; + }; + + class MEDFileEquivalenceNode : public MEDFileEquivalenceData + { + public: + 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() { } + }; +} + +#endif + -- 2.39.2