-// Copyright (C) 2007-2013 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2014 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.
+// 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
#include <limits>
#include <cmath>
+extern med_geometry_type typmai3[34];
+
using namespace ParaMEDMEM;
const char MEDFileMesh::DFT_FAM_NAME[]="FAMILLE_ZERO";
return ret;
}
-std::vector<const BigMemoryObject *> MEDFileMesh::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileMesh::getDirectChildrenWithNull() const
{
return std::vector<const BigMemoryObject *>();
}
* \throw If there is no meshes in the file.
* \throw If the mesh in the file is of a not supported type.
*/
-MEDFileMesh *MEDFileMesh::New(const char *fileName, MEDFileMeshReadSelector *mrs)
+MEDFileMesh *MEDFileMesh::New(const std::string& fileName, MEDFileMeshReadSelector *mrs)
{
std::vector<std::string> ms=MEDLoader::GetMeshNames(fileName);
if(ms.empty())
}
MEDFileUtilities::CheckFileForRead(fileName);
ParaMEDMEM::MEDCouplingMeshType meshType;
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
+ MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
int dt,it;
std::string dummy2;
- MEDFileMeshL2::GetMeshIdFromName(fid,ms.front().c_str(),meshType,dt,it,dummy2);
+ MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dt,it,dummy2);
switch(meshType)
- {
+ {
case UNSTRUCTURED:
{
MEDCouplingAutoRefCountObjectPtr<MEDFileUMesh> ret=MEDFileUMesh::New();
- ret->loadUMeshFromFile(fid,ms.front().c_str(),dt,it,mrs);
+ ret->loadUMeshFromFile(fid,ms.front(),dt,it,mrs);
return (MEDFileUMesh *)ret.retn();
}
case CARTESIAN:
{
MEDCouplingAutoRefCountObjectPtr<MEDFileCMesh> ret=MEDFileCMesh::New();
- ret->loadCMeshFromFile(fid,ms.front().c_str(),dt,it,mrs);
+ ret->loadCMeshFromFile(fid,ms.front(),dt,it,mrs);
return (MEDFileCMesh *)ret.retn();
}
case CURVE_LINEAR:
{
MEDCouplingAutoRefCountObjectPtr<MEDFileCurveLinearMesh> ret=MEDFileCurveLinearMesh::New();
- ret->loadCLMeshFromFile(fid,ms.front().c_str(),dt,it,mrs);
+ ret->loadCLMeshFromFile(fid,ms.front(),dt,it,mrs);
return (MEDFileCurveLinearMesh *)ret.retn();
}
default:
std::ostringstream oss; oss << "MEDFileMesh::New : MED file exists and has mesh '" << ms.front() << "' exists but unsupported type yet !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- }
+ }
}
/*!
* \throw If there is no mesh with given attributes in the file.
* \throw If the mesh in the file is of a not supported type.
*/
-MEDFileMesh *MEDFileMesh::New(const char *fileName, const char *mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+MEDFileMesh *MEDFileMesh::New(const std::string& fileName, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
MEDFileUtilities::CheckFileForRead(fileName);
ParaMEDMEM::MEDCouplingMeshType meshType;
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
+ MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
int dummy0,dummy1;
std::string dummy2;
MEDFileMeshL2::GetMeshIdFromName(fid,mName,meshType,dummy0,dummy1,dummy2);
switch(meshType)
- {
+ {
case UNSTRUCTURED:
{
MEDCouplingAutoRefCountObjectPtr<MEDFileUMesh> ret=MEDFileUMesh::New();
std::ostringstream oss; oss << "MEDFileMesh::New : MED file exists and has mesh '" << mName << "' exists but unsupported type yet !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- }
+ }
}
/*!
* \throw If the mesh name is not set.
* \throw If \a mode == 1 and the same data is present in an existing file.
*/
-void MEDFileMesh::write(const char *fileName, int mode) const
+void MEDFileMesh::write(const std::string& fileName, int mode) const
{
med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
+ MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
std::ostringstream oss; oss << "MEDFileMesh : error on attempt to write in file : \"" << fileName << "\"";
- MEDFileUtilities::CheckMEDCode(fid,fid,oss.str().c_str());
+ MEDFileUtilities::CheckMEDCode(fid,fid,oss.str());
write(fid);
}
return true;
}
+void MEDFileMesh::setName(const std::string& name)
+{
+ _name=name;
+}
+
/*!
* Clears redundant attributes of incorporated data arrays.
*/
void MEDFileMesh::clearNonDiscrAttributes() const
{
-
+
}
bool MEDFileMesh::changeNames(const std::vector< std::pair<std::string,std::string> >& modifTab)
_families=other._families;
}
+
+/*!
+ * This method clear all the groups in the map.
+ * So this method does not operate at all on arrays.
+ * So this method can lead to orphan families.
+ *
+ * \sa MEDFileMesh::clearFamMap, MEDFileMesh::clearFamGrpMaps
+ */
+void MEDFileMesh::clearGrpMap()
+{
+ _groups.clear();
+}
+
+/*!
+ * This method clear all the families in the map.
+ * So this method does not operate at all on arrays.
+ * WARNING ! if there are some groups lying on cleared families, those groups will be impacted !
+ *
+ * \sa MEDFileMesh::clearFamMap, MEDFileMesh::clearFamGrpMaps
+ */
+void MEDFileMesh::clearFamMap()
+{
+ _families.clear();
+}
+
+/*!
+ * This method clear all the families and groups in the map.
+ * So this method does not operate at all on arrays.
+ * As all groups and families entry will be removed after
+ * the call of MEDFileMesh::setFamilyFieldArr method with 0 or None (python) in the 2nd parameter can be useful to reduce the size of the object.
+ *
+ * \sa MEDFileMesh::clearFamMap, MEDFileMesh::clearFamMap
+ */
+void MEDFileMesh::clearFamGrpMaps()
+{
+ clearGrpMap();
+ clearFamMap();
+}
+
/*!
* Returns names of families constituting a group.
* \param [in] name - the name of the group of interest.
* \return std::vector<std::string> - a sequence of names of the families.
* \throw If the name of a nonexistent group is specified.
*/
-std::vector<std::string> MEDFileMesh::getFamiliesOnGroup(const char *name) const
+std::vector<std::string> MEDFileMesh::getFamiliesOnGroup(const std::string& name) const
{
std::string oname(name);
std::map<std::string, std::vector<std::string> >::const_iterator it=_groups.find(oname);
* \return std::vector<int> - sequence of ids of the families.
* \throw If the name of a nonexistent group is specified.
*/
-std::vector<int> MEDFileMesh::getFamiliesIdsOnGroup(const char *name) const
+std::vector<int> MEDFileMesh::getFamiliesIdsOnGroup(const std::string& name) const
{
std::string oname(name);
std::map<std::string, std::vector<std::string> >::const_iterator it=_groups.find(oname);
* \param [in] name - the name of the group of interest.
* \param [in] fams - a sequence of names of families constituting the group.
*/
-void MEDFileMesh::setFamiliesOnGroup(const char *name, const std::vector<std::string>& fams)
+void MEDFileMesh::setFamiliesOnGroup(const std::string& name, const std::vector<std::string>& fams)
{
std::string oname(name);
_groups[oname]=fams;
* \param [in] famIds - a sequence of ids of families constituting the group.
* \throw If a family name is not found by its id.
*/
-void MEDFileMesh::setFamiliesIdsOnGroup(const char *name, const std::vector<int>& famIds)
+void MEDFileMesh::setFamiliesIdsOnGroup(const std::string& name, const std::vector<int>& famIds)
{
std::string oname(name);
std::vector<std::string> fams(famIds.size());
* \param [in] name - the name of the family of interest.
* \return std::vector<std::string> - a sequence of names of groups including the family.
*/
-std::vector<std::string> MEDFileMesh::getGroupsOnFamily(const char *name) const
+std::vector<std::string> MEDFileMesh::getGroupsOnFamily(const std::string& name) const
{
std::vector<std::string> ret;
for(std::map<std::string, std::vector<std::string> >::const_iterator it1=_groups.begin();it1!=_groups.end();it1++)
* \param [in] grps - a sequence of group names to add the family in.
* \throw If a family named \a famName not yet exists.
*/
-void MEDFileMesh::setGroupsOnFamily(const char *famName, const std::vector<std::string>& grps)
+void MEDFileMesh::setGroupsOnFamily(const std::string& famName, const std::vector<std::string>& grps)
{
std::string fName(famName);
const std::map<std::string,int>::const_iterator it=_families.find(fName);
std::map<std::string,int> newFams;
for(std::map<std::string,int>::const_iterator it=_families.begin();it!=_families.end();it++)
{
- std::vector<std::string> grps=getGroupsOnFamily((*it).first.c_str());
+ std::vector<std::string> grps=getGroupsOnFamily((*it).first);
if(grps.size()==1 && groups[grps[0]].size()==1)
{
if(newFams.find(grps[0])!=newFams.end())
* \param [in] name - the name of the group to remove.
* \throw If no group with such a \a name exists.
*/
-void MEDFileMesh::removeGroup(const char *name)
+void MEDFileMesh::removeGroup(const std::string& name)
{
std::string oname(name);
std::map<std::string, std::vector<std::string> >::iterator it=_groups.find(oname);
* \param [in] name - the name of the family to remove.
* \throw If no family with such a \a name exists.
*/
-void MEDFileMesh::removeFamily(const char *name)
+void MEDFileMesh::removeFamily(const std::string& name)
{
std::string oname(name);
std::map<std::string, int >::iterator it=_families.find(oname);
else
{
ret.push_back((*it).first);
- std::vector<std::string> grpsOnEraseFam=getGroupsOnFamily((*it).first.c_str());
+ std::vector<std::string> grpsOnEraseFam=getGroupsOnFamily((*it).first);
for(std::vector<std::string>::const_iterator it2=grpsOnEraseFam.begin();it2!=grpsOnEraseFam.end();it2++)
{
std::map<std::string, std::vector<std::string> >::iterator it3=grps.find(*it2);//it3!=grps.empty() thanks to copy
* \throw If no group named \a oldName exists in \a this mesh.
* \throw If a group named \a newName already exists.
*/
-void MEDFileMesh::changeGroupName(const char *oldName, const char *newName)
+void MEDFileMesh::changeGroupName(const std::string& oldName, const std::string& newName)
{
std::string oname(oldName);
std::map<std::string, std::vector<std::string> >::iterator it=_groups.find(oname);
* \throw If no family named \a oldName exists in \a this mesh.
* \throw If a family named \a newName already exists.
*/
-void MEDFileMesh::changeFamilyName(const char *oldName, const char *newName)
+void MEDFileMesh::changeFamilyName(const std::string& oldName, const std::string& newName)
{
std::string oname(oldName);
std::map<std::string, int >::iterator it=_families.find(oname);
{
oss << " Group \"" << (*it).first << "\" on following families :\n";
for(std::vector<std::string>::const_iterator it2=(*it).second.begin();it2!=(*it).second.end();it2++)
- oss << " \"" << *it2 << "\n";
+ oss << " \"" << *it2 << "\n";
}
oss << "Second group description :\n";
for(std::map<std::string, std::vector<std::string> >::const_iterator it=other->_groups.begin();it!=other->_groups.end();it++)
* \param [in] groupName - the group name.
* \return bool - \c true the group \a groupName exists in \a this mesh.
*/
-bool MEDFileMesh::existsGroup(const char *groupName) const
+bool MEDFileMesh::existsGroup(const std::string& groupName) const
{
std::string grpName(groupName);
return _groups.find(grpName)!=_groups.end();
* \param [in] familyName - the family name.
* \return bool - \c true the family \a familyName exists in \a this mesh.
*/
-bool MEDFileMesh::existsFamily(const char *familyName) const
+bool MEDFileMesh::existsFamily(const std::string& familyName) const
{
std::string fname(familyName);
return _families.find(fname)!=_families.end();
* \param [in] familyName - the family name.
* \param [in] id - a new id of the family.
*/
-void MEDFileMesh::setFamilyId(const char *familyName, int id)
+void MEDFileMesh::setFamilyId(const std::string& familyName, int id)
{
std::string fname(familyName);
_families[fname]=id;
}
-void MEDFileMesh::setFamilyIdUnique(const char *familyName, int id)
+void MEDFileMesh::setFamilyIdUnique(const std::string& familyName, int id)
{
std::string fname(familyName);
for(std::map<std::string,int>::const_iterator it=_families.begin();it!=_families.end();it++)
* \param [in] famId - an id of the family.
* \throw If a family with the same name or id already exists in \a this mesh.
*/
-void MEDFileMesh::addFamily(const char *familyName, int famId)
+void MEDFileMesh::addFamily(const std::string& familyName, int famId)
{
std::string fname(familyName);
std::map<std::string,int>::const_iterator it=_families.find(fname);
if(it==_families.end())
{
- for(std::map<std::string,int>::const_iterator it2=_families.begin();it2!=_families.end();it2++)
- if((*it2).second==famId)
- {
- std::ostringstream oss;
- oss << "MEDFileMesh::addFamily : Family \"" << (*it2).first << "\" already exists with specified id : " << famId << " !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- _families[fname]=famId;
+ for(std::map<std::string,int>::const_iterator it2=_families.begin();it2!=_families.end();it2++)
+ if((*it2).second==famId)
+ {
+ std::ostringstream oss;
+ oss << "MEDFileMesh::addFamily : Family \"" << (*it2).first << "\" already exists with specified id : " << famId << " !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ _families[fname]=famId;
}
else
{
* \throw If no mesh entities of dimension \a meshDimRelToMaxExt exist in \a this mesh.
* \throw If no family field of dimension \a meshDimRelToMaxExt is present in \a this mesh.
*/
-void MEDFileMesh::createGroupOnAll(int meshDimRelToMaxExt, const char *groupName)
+void MEDFileMesh::createGroupOnAll(int meshDimRelToMaxExt, const std::string& groupName)
{
std::string grpName(groupName);
std::vector<int> levs=getNonEmptyLevelsExt();
std::string famName=getFamilyNameGivenId(*it2);
std::ostringstream oss; oss << "Family_" << maxFamId;
std::string zeName=CreateNameNotIn(oss.str(),allFams);
- addFamilyOnAllGroupsHaving(famName.c_str(),zeName.c_str());
+ addFamilyOnAllGroupsHaving(famName,zeName);
_families[zeName]=maxFamId;
(const_cast<DataArrayInt *>(fieldFamIds))->changeValue(*it2,maxFamId);
maxFamId++;
* \throw If \a grpName or \a famName is an empty string.
* \throw If no family named \a famName is present in \a this mesh.
*/
-void MEDFileMesh::addFamilyOnGrp(const char *grpName, const char *famName)
+void MEDFileMesh::addFamilyOnGrp(const std::string& grpName, const std::string& famName)
{
std::string grpn(grpName);
std::string famn(famName);
* This method is quite underground because it can lead to unconsistency because family 'otherFamName' is \b not added into _families.
* This method is used by MEDFileMesh::keepFamIdsOnlyOnLevs method.
*/
-void MEDFileMesh::addFamilyOnAllGroupsHaving(const char *famName, const char *otherFamName)
+void MEDFileMesh::addFamilyOnAllGroupsHaving(const std::string& famName, const std::string& otherFamName)
{
std::string famNameCpp(famName);
std::string otherCpp(otherFamName);
}
}
-void MEDFileMesh::changeAllGroupsContainingFamily(const char *familyNameToChange, const std::vector<std::string>& newFamiliesNames)
+void MEDFileMesh::changeAllGroupsContainingFamily(const std::string& familyNameToChange, const std::vector<std::string>& newFamiliesNames)
{
ChangeAllGroupsContainingFamily(_groups,familyNameToChange,newFamiliesNames);
}
-void MEDFileMesh::ChangeAllGroupsContainingFamily(std::map<std::string, std::vector<std::string> >& groups, const char *familyNameToChange, const std::vector<std::string>& newFamiliesNames)
+void MEDFileMesh::ChangeAllGroupsContainingFamily(std::map<std::string, std::vector<std::string> >& groups, const std::string& familyNameToChange, const std::vector<std::string>& newFamiliesNames)
{
std::string fam(familyNameToChange);
for(std::map<std::string, std::vector<std::string> >::iterator it=groups.begin();it!=groups.end();it++)
* \return int - the id of the family of interest.
* \throw If no family with such a \a name exists.
*/
-int MEDFileMesh::getFamilyId(const char *name) const
+int MEDFileMesh::getFamilyId(const std::string& name) const
{
std::string oname(name);
std::map<std::string, int>::const_iterator it=_families.find(oname);
if(allIds->presenceOfValue(*it3))
{
std::string famName=getFamilyNameGivenId(*it3);
- std::vector<std::string> grps=getGroupsOnFamily(famName.c_str());
+ std::vector<std::string> grps=getGroupsOnFamily(famName);
ren[*it3]=maxId;
bool dummy;
std::string newFam=findOrCreateAndGiveFamilyWithId(maxId,dummy);
for(std::vector<std::string>::const_iterator it4=grps.begin();it4!=grps.end();it4++)
- addFamilyOnGrp((*it4).c_str(),newFam.c_str());
+ addFamilyOnGrp((*it4),newFam);
}
}
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=fam->getIdsEqualList(&(*it2).second[0],&(*it2).second[0]+(*it2).second.size());
* \throw If the name of a nonexistent group is specified.
* \throw If the family field is missing for \a meshDimRelToMaxExt.
*/
-DataArrayInt *MEDFileMesh::getGroupArr(int meshDimRelToMaxExt, const char *grp, bool renum) const
+DataArrayInt *MEDFileMesh::getGroupArr(int meshDimRelToMaxExt, const std::string& grp, bool renum) const
{
std::vector<std::string> tmp(1);
tmp[0]=grp;
* is to delete this array using decrRef() as it is no more needed.
* \throw If the family field is missing for \a meshDimRelToMaxExt.
*/
-DataArrayInt *MEDFileMesh::getFamilyArr(int meshDimRelToMaxExt, const char *fam, bool renum) const
+DataArrayInt *MEDFileMesh::getFamilyArr(int meshDimRelToMaxExt, const std::string& fam, bool renum) const
{
std::vector<std::string> tmp(1);
tmp[0]=fam;
* \throw If the name of a nonexistent group is specified.
* \throw If the family field is missing for nodes.
*/
-DataArrayInt *MEDFileMesh::getNodeGroupArr(const char *grp, bool renum) const
+DataArrayInt *MEDFileMesh::getNodeGroupArr(const std::string& grp, bool renum) const
{
std::vector<std::string> tmp(1);
tmp[0]=grp;
* \throw If the name of a nonexistent group is specified.
* \throw If the family field is missing for nodes.
*/
-DataArrayInt *MEDFileMesh::getNodeFamilyArr(const char *fam, bool renum) const
+DataArrayInt *MEDFileMesh::getNodeFamilyArr(const std::string& fam, bool renum) const
{
std::vector<std::string> tmp(1);
tmp[0]=fam;
for(unsigned int ii=0;ii<grps.size();ii++)
{
grps2[ii]=MEDFileUMeshSplitL1::Renumber(getRevNumberFieldAtLevel(meshDimRelToMaxExt),grps[ii]);
- grps2[ii]->setName(grps[ii]->getName().c_str());
+ grps2[ii]->setName(grps[ii]->getName());
}
std::vector<const DataArrayInt *> grps3(grps2.begin(),grps2.end());
fam=DataArrayInt::MakePartition(grps3,sz,fidsOfGroups);
}
}
+std::vector<INTERP_KERNEL::NormalizedCellType> MEDFileMesh::getAllGeoTypes() const
+{
+ std::vector<int> levs(getNonEmptyLevels());
+ std::vector<INTERP_KERNEL::NormalizedCellType> ret;
+ for(std::vector<int>::const_iterator it=levs.begin();it!=levs.end();it++)
+ {
+ std::vector<INTERP_KERNEL::NormalizedCellType> elts(getGeoTypesAtLevel(*it));
+ ret.insert(ret.end(),elts.begin(),elts.end());
+ }
+ return ret;
+}
+
std::vector<int> MEDFileMesh::getDistributionOfTypes(int meshDimRelToMax) const
{
MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> mLev(getGenMeshAtLevel(meshDimRelToMax));
{
oss << "- Family with name \"" << (*it).first << "\" with number " << (*it).second << std::endl;
oss << " - Groups lying on this family : ";
- std::vector<std::string> grps=getGroupsOnFamily((*it).first.c_str());
+ std::vector<std::string> grps=getGroupsOnFamily((*it).first);
std::copy(grps.begin(),grps.end(),std::ostream_iterator<std::string>(oss," "));
oss << std::endl << std::endl;
}
* \throw If there is no mesh with given attributes in the file.
* \throw If the mesh in the file is not an unstructured one.
*/
-MEDFileUMesh *MEDFileUMesh::New(const char *fileName, const char *mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+MEDFileUMesh *MEDFileUMesh::New(const std::string& fileName, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
+ MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
return new MEDFileUMesh(fid,mName,dt,it,mrs);
}
* \throw If there is no meshes in the file.
* \throw If the mesh in the file is not an unstructured one.
*/
-MEDFileUMesh *MEDFileUMesh::New(const char *fileName, MEDFileMeshReadSelector *mrs)
+MEDFileUMesh *MEDFileUMesh::New(const std::string& fileName, MEDFileMeshReadSelector *mrs)
{
std::vector<std::string> ms=MEDLoader::GetMeshNames(fileName);
if(ms.empty())
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
+ MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
int dt,it;
ParaMEDMEM::MEDCouplingMeshType meshType;
std::string dummy2;
- MEDFileMeshL2::GetMeshIdFromName(fid,ms.front().c_str(),meshType,dt,it,dummy2);
- return new MEDFileUMesh(fid,ms.front().c_str(),dt,it,mrs);
+ MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dt,it,dummy2);
+ return new MEDFileUMesh(fid,ms.front(),dt,it,mrs);
}
/*!
return ret;
}
-std::vector<const BigMemoryObject *> MEDFileUMesh::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileUMesh::getDirectChildrenWithNull() const
{
- std::vector<const BigMemoryObject *> ret(MEDFileMesh::getDirectChildren());
- if((const DataArrayDouble*)_coords)
- ret.push_back((const DataArrayDouble*)_coords);
- if((const DataArrayInt *)_fam_coords)
- ret.push_back((const DataArrayInt *)_fam_coords);
- if((const DataArrayInt *)_num_coords)
- ret.push_back((const DataArrayInt *)_num_coords);
- if((const DataArrayInt *)_rev_num_coords)
- ret.push_back((const DataArrayInt *)_rev_num_coords);
- if((const DataArrayAsciiChar *)_name_coords)
- ret.push_back((const DataArrayAsciiChar *)_name_coords);
+ std::vector<const BigMemoryObject *> ret(MEDFileMesh::getDirectChildrenWithNull());
+ ret.push_back((const DataArrayDouble*)_coords);
+ ret.push_back((const DataArrayInt *)_fam_coords);
+ ret.push_back((const DataArrayInt *)_num_coords);
+ ret.push_back((const DataArrayInt *)_rev_num_coords);
+ ret.push_back((const DataArrayAsciiChar *)_name_coords);
for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
- if((const MEDFileUMeshSplitL1*) *it)
- ret.push_back((const MEDFileUMeshSplitL1*) *it);
+ ret.push_back((const MEDFileUMeshSplitL1*) *it);
return ret;
}
}
}
+void MEDFileUMesh::setName(const std::string& name)
+{
+ for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::iterator it=_ms.begin();it!=_ms.end();it++)
+ if((MEDFileUMeshSplitL1 *)(*it)!=0)
+ (*it)->setName(name);
+ MEDFileMesh::setName(name);
+}
+
MEDFileUMesh::MEDFileUMesh()
{
}
-MEDFileUMesh::MEDFileUMesh(med_idt fid, const char *mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+MEDFileUMesh::MEDFileUMesh(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
try
- {
+{
loadUMeshFromFile(fid,mName,dt,it,mrs);
- }
+}
catch(INTERP_KERNEL::Exception& e)
- {
+{
throw e;
- }
+}
-void MEDFileUMesh::loadUMeshFromFile(med_idt fid, const char *mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+void MEDFileUMesh::loadUMeshFromFile(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
MEDFileUMeshL2 loaderl2;
ParaMEDMEM::MEDCouplingMeshType meshType;
}
MEDmeshCr(fid,maa,spaceDim,mdim,MED_UNSTRUCTURED_MESH,desc,"",MED_SORT_DTIT,MED_CARTESIAN,comp,unit);
MEDmeshUniversalNameWr(fid,maa);
- MEDFileUMeshL2::WriteCoords(fid,maa,_iteration,_order,_time,_coords,_fam_coords,_num_coords,_name_coords);
+ std::string meshName(MEDLoaderBase::buildStringFromFortran(maa,MED_NAME_SIZE));
+ MEDFileUMeshL2::WriteCoords(fid,meshName,_iteration,_order,_time,_coords,_fam_coords,_num_coords,_name_coords);
for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
if((const MEDFileUMeshSplitL1 *)(*it)!=0)
- (*it)->write(fid,maa,mdim);
- MEDFileUMeshL2::WriteFamiliesAndGrps(fid,maa,_families,_groups,_too_long_str);
+ (*it)->write(fid,meshName,mdim);
+ MEDFileUMeshL2::WriteFamiliesAndGrps(fid,meshName,_families,_groups,_too_long_str);
}
/*!
* \param [in] grp - the name of the group of interest.
* \return std::vector<int> - a sequence of the relative dimensions.
*/
-std::vector<int> MEDFileUMesh::getGrpNonEmptyLevels(const char *grp) const
+std::vector<int> MEDFileUMesh::getGrpNonEmptyLevels(const std::string& grp) const
{
std::vector<std::string> fams=getFamiliesOnGroup(grp);
return getFamsNonEmptyLevels(fams);
* \param [in] grp - the name of the group of interest.
* \return std::vector<int> - a sequence of the relative dimensions.
*/
-std::vector<int> MEDFileUMesh::getGrpNonEmptyLevelsExt(const char *grp) const
+std::vector<int> MEDFileUMesh::getGrpNonEmptyLevelsExt(const std::string& grp) const
{
std::vector<std::string> fams=getFamiliesOnGroup(grp);
return getFamsNonEmptyLevelsExt(fams);
* \param [in] fam - the name of the family of interest.
* \return std::vector<int> - a sequence of the relative dimensions.
*/
-std::vector<int> MEDFileUMesh::getFamNonEmptyLevels(const char *fam) const
+std::vector<int> MEDFileUMesh::getFamNonEmptyLevels(const std::string& fam) const
{
std::vector<std::string> fams(1,std::string(fam));
return getFamsNonEmptyLevels(fams);
* \param [in] fam - the name of the family of interest.
* \return std::vector<int> - a sequence of the relative dimensions.
*/
-std::vector<int> MEDFileUMesh::getFamNonEmptyLevelsExt(const char *fam) const
+std::vector<int> MEDFileUMesh::getFamNonEmptyLevelsExt(const std::string& fam) const
{
std::vector<std::string> fams(1,std::string(fam));
return getFamsNonEmptyLevelsExt(fams);
std::vector<std::string> allGrps=getGroupsNames();
for(std::vector<std::string>::const_iterator it=allGrps.begin();it!=allGrps.end();it++)
{
- std::vector<int> levs=getGrpNonEmptyLevelsExt((*it).c_str());
+ std::vector<int> levs=getGrpNonEmptyLevelsExt((*it));
if(std::find(levs.begin(),levs.end(),meshDimRelToMaxExt)!=levs.end())
ret.push_back(*it);
}
return coo->getNumberOfTuples();
}
+bool MEDFileUMesh::hasImplicitPart() const
+{
+ return false;
+}
+
+int MEDFileUMesh::buildImplicitPartIfAny(INTERP_KERNEL::NormalizedCellType gt) const
+{
+ throw INTERP_KERNEL::Exception("MEDFileUMesh::buildImplicitPartIfAny : unstructured meshes do not have implicit part !");
+}
+
+void MEDFileUMesh::releaseImplicitPartIfAny() const
+{
+}
+
void MEDFileUMesh::whichAreNodesFetched(const MEDFileField1TSStructItem& st, const MEDFileFieldGlobsReal *globs, std::vector<bool>& nodesFetched) const
{
std::size_t sz(st.getNumberOfItems());
m->computeNodeIdsAlg(nodesFetched);
else
{
- const DataArrayInt *arr(globs->getProfile(st[i].getPflName().c_str()));
+ const DataArrayInt *arr(globs->getProfile(st[i].getPflName()));
MEDCouplingAutoRefCountObjectPtr<MEDCoupling1GTUMesh> m2(dynamic_cast<MEDCoupling1GTUMesh *>(m->buildPartOfMySelf(arr->begin(),arr->end(),true)));
m2->computeNodeIdsAlg(nodesFetched);
}
* \throw If the name of a nonexistent group is specified.
* \throw If there are no mesh entities of \a meshDimRelToMaxExt dimension in \a this mesh.
*/
-MEDCouplingUMesh *MEDFileUMesh::getGroup(int meshDimRelToMaxExt, const char *grp, bool renum) const
+MEDCouplingUMesh *MEDFileUMesh::getGroup(int meshDimRelToMaxExt, const std::string& grp, bool renum) const
{
synchronizeTinyInfoOnLeaves();
std::vector<std::string> tmp(1);
std::vector<std::string> fams2=getFamiliesOnGroups(grps);
MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> zeRet=getFamilies(meshDimRelToMaxExt,fams2,renum);
if(grps.size()==1 && ((MEDCouplingUMesh *)zeRet))
- zeRet->setName(grps[0].c_str());
+ zeRet->setName(grps[0]);
return zeRet.retn();
}
* \throw If a name of a nonexistent family is present in \a grps.
* \throw If there are no mesh entities of \a meshDimRelToMaxExt dimension in \a this mesh.
*/
-MEDCouplingUMesh *MEDFileUMesh::getFamily(int meshDimRelToMaxExt, const char *fam, bool renum) const
+MEDCouplingUMesh *MEDFileUMesh::getFamily(int meshDimRelToMaxExt, const std::string& fam, bool renum) const
{
synchronizeTinyInfoOnLeaves();
std::vector<std::string> tmp(1);
else
zeRet=l1->getFamilyPart(0,0,renum);
if(fams.size()==1 && ((MEDCouplingUMesh *)zeRet))
- zeRet->setName(fams[0].c_str());
+ zeRet->setName(fams[0]);
return zeRet.retn();
}
MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> cc=_coords->deepCpy();
umesh->setCoords(cc);
MEDFileUMeshSplitL1::ClearNonDiscrAttributes(umesh);
- umesh->setName(getName().c_str());
+ umesh->setName(getName());
return umesh;
}
}
return getMeshAtLevel(-3,renum);
}
+/*!
+ * This method is for advanced users. There is two storing strategy of mesh in \a this.
+ * Either MEDCouplingUMesh, or vector of MEDCoupling1GTUMesh instances.
+ * When assignement is done the first one is done, which is not optimal in write mode for MED file.
+ * This method allows to switch from MEDCouplingUMesh mode to MEDCoupling1GTUMesh mode.
+ */
+void MEDFileUMesh::forceComputationOfParts() const
+{
+ for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileUMeshSplitL1> >::const_iterator it=_ms.begin();it!=_ms.end();it++)
+ {
+ const MEDFileUMeshSplitL1 *elt(*it);
+ if(elt)
+ elt->forceComputationOfParts();
+ }
+}
+
/*!
* This method returns a vector of mesh parts containing each exactly one geometric type.
* This method will never launch an automatic computation of split by type (an INTERP_KERNEL::Exception will be then thrown).
MEDFileUMeshSplitL1 *MEDFileUMesh::getMeshAtLevSafe(int meshDimRelToMaxExt)
{
- if(meshDimRelToMaxExt==1)
+ if(meshDimRelToMaxExt==1)
throw INTERP_KERNEL::Exception("Dimension request is invalid : asking for node level (1) !");
if(meshDimRelToMaxExt>1)
throw INTERP_KERNEL::Exception("Dimension request is invalid (>1) !");
_groups.erase(*it);
}
-void MEDFileUMesh::duplicateNodesOnM1Group(const char *grpNameM1, DataArrayInt *&nodesDuplicated, DataArrayInt *&cellsModified, DataArrayInt *&cellsNotModified)
+void MEDFileUMesh::duplicateNodesOnM1Group(const std::string& grpNameM1, DataArrayInt *&nodesDuplicated, DataArrayInt *&cellsModified, DataArrayInt *&cellsNotModified)
{
std::vector<int> levs=getNonEmptyLevels();
if(std::find(levs.begin(),levs.end(),0)==levs.end() || std::find(levs.begin(),levs.end(),-1)==levs.end())
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> szOfCellGrpOfSameType(tmp00);
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> idInMsOfCellGrpOfSameType(tmp11);
//
- newm1->setName(getName().c_str());
+ newm1->setName(getName());
const DataArrayInt *fam=getFamilyFieldAtLevel(-1);
if(!fam)
throw INTERP_KERNEL::Exception("MEDFileUMesh::duplicateNodesOnM1Group : internal problem !");
setMeshAtLevel(-1,newm1);
setFamilyFieldArr(-1,newFam);
std::string grpName2(grpNameM1); grpName2+="_dup";
- addFamily(grpName2.c_str(),idd);
- addFamilyOnGrp(grpName2.c_str(),grpName2.c_str());
+ addFamily(grpName2,idd);
+ addFamilyOnGrp(grpName2,grpName2);
//
fam=_fam_coords;
if(fam)
bool hasChanged=m->unPolyze();
DataArrayInt *fake=0;
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2nCellsPart=m->getLevArrPerCellTypes(MEDCouplingUMesh::MEDMEM_ORDER,
- MEDCouplingUMesh::MEDMEM_ORDER+MEDCouplingUMesh::N_MEDMEM_ORDER,fake);
+ MEDCouplingUMesh::MEDMEM_ORDER+MEDCouplingUMesh::N_MEDMEM_ORDER,fake);
fake->decrRef();
renumCellsSplited.push_back(o2nCellsPart); memorySaverIfThrow.push_back(o2nCellsPart);
if(hasChanged)
if(existsFamily(*famId))
{
std::string locFamName2=getFamilyNameGivenId(*famId); std::vector<std::string> v(2); v[0]=locFamName2; v[1]=locFamName;
- ChangeAllGroupsContainingFamily(groups,getFamilyNameGivenId(*famId).c_str(),v);
+ ChangeAllGroupsContainingFamily(groups,getFamilyNameGivenId(*famId),v);
}
maxVal++;
} // modifying all other groups on *famId to lie on maxVal and lie the grp on maxVal
if(existsFamily(*famId))
{
std::string n1(FindOrCreateAndGiveFamilyWithId(families,isNodeGroup?maxVal:-maxVal,created)); std::vector<std::string> v(2); v[0]=n1; v[1]=n2;
- ChangeAllGroupsContainingFamily(groups,getFamilyNameGivenId(*famId).c_str(),v);
+ ChangeAllGroupsContainingFamily(groups,getFamilyNameGivenId(*famId),v);
}
maxVal+=2;
}
for(std::vector<const MEDCouplingUMesh *>::const_iterator it=ms.begin();it!=ms.end();it++)
{
int mdim=(*it)->getMeshDimension();
- setName((*it)->getName().c_str());
+ setName((*it)->getName());
setMeshAtLevel(mdim-zeDim,const_cast<MEDCouplingUMesh *>(*it),renum);
}
- setName(name.c_str());
+ setName(name);
}
/*!
return MEDFileMesh::getHeapMemorySizeWithoutChildren();
}
-std::vector<const BigMemoryObject *> MEDFileStructuredMesh::getDirectChildren() const
-{
- std::vector<const BigMemoryObject *> ret(MEDFileMesh::getDirectChildren());
- if((const DataArrayInt *)_fam_nodes)
- ret.push_back((const DataArrayInt *)_fam_nodes);
- if((const DataArrayInt *)_num_nodes)
- ret.push_back((const DataArrayInt *)_num_nodes);
- if((const DataArrayInt *)_fam_cells)
- ret.push_back((const DataArrayInt *)_fam_cells);
- if((const DataArrayInt *)_num_cells)
- ret.push_back((const DataArrayInt *)_num_nodes);
- if((const DataArrayInt *)_rev_num_nodes)
- ret.push_back((const DataArrayInt *)_rev_num_nodes);
- if((const DataArrayInt *)_rev_num_cells)
- ret.push_back((const DataArrayInt *)_rev_num_cells);
+std::vector<const BigMemoryObject *> MEDFileStructuredMesh::getDirectChildrenWithNull() const
+{
+ std::vector<const BigMemoryObject *> ret(MEDFileMesh::getDirectChildrenWithNull());
+ ret.push_back((const DataArrayInt *)_fam_nodes);
+ ret.push_back((const DataArrayInt *)_num_nodes);
+ ret.push_back((const DataArrayAsciiChar *)_names_nodes);
+ ret.push_back((const DataArrayInt *)_fam_cells);
+ ret.push_back((const DataArrayInt *)_num_cells);
+ ret.push_back((const DataArrayAsciiChar *)_names_cells);
+ ret.push_back((const DataArrayInt *)_fam_faces);
+ ret.push_back((const DataArrayInt *)_num_faces);
+ ret.push_back((const DataArrayInt *)_rev_num_nodes);
+ ret.push_back((const DataArrayAsciiChar *)_names_faces);
+ ret.push_back((const DataArrayInt *)_rev_num_cells);
+ ret.push_back((const MEDCoupling1SGTUMesh*)_faces_if_necessary);
return ret;
}
int val=_fam_cells->getMaxValue(tmp);
ret=std::max(ret,std::abs(val));
}
+ if((const DataArrayInt *)_fam_faces)
+ {
+ int val=_fam_faces->getMaxValue(tmp);
+ ret=std::max(ret,std::abs(val));
+ }
return ret;
}
int val=_fam_cells->getMaxValue(tmp);
ret=std::max(ret,val);
}
+ if((const DataArrayInt *)_fam_faces)
+ {
+ int val=_fam_faces->getMaxValue(tmp);
+ ret=std::max(ret,val);
+ }
return ret;
}
int val=_fam_cells->getMinValue(tmp);
ret=std::min(ret,val);
}
+ if((const DataArrayInt *)_fam_faces)
+ {
+ int val=_fam_faces->getMinValue(tmp);
+ ret=std::min(ret,val);
+ }
return ret;
}
return false;
}
}
+ famc1=_fam_faces;
+ famc2=otherC->_fam_faces;
+ if((famc1==0 && famc2!=0) || (famc1!=0 && famc2==0))
+ {
+ what="Mismatch of families arr on faces ! One is defined and not other !";
+ return false;
+ }
+ if(famc1)
+ {
+ bool ret=famc1->isEqual(*famc2);
+ if(!ret)
+ {
+ what="Families arr on faces differ !";
+ return false;
+ }
+ }
famc1=_num_nodes;
famc2=otherC->_num_nodes;
if((famc1==0 && famc2!=0) || (famc1!=0 && famc2==0))
return false;
}
}
+ famc1=_num_faces;
+ famc2=otherC->_num_faces;
+ if((famc1==0 && famc2!=0) || (famc1!=0 && famc2==0))
+ {
+ what="Mismatch of numbering arr on faces ! One is defined and not other !";
+ return false;
+ }
+ if(famc1)
+ {
+ bool ret=famc1->isEqual(*famc2);
+ if(!ret)
+ {
+ what="Numbering arr on faces differ !";
+ return false;
+ }
+ }
const DataArrayAsciiChar *d1=_names_cells;
const DataArrayAsciiChar *d2=otherC->_names_cells;
if((d1==0 && d2!=0) || (d1!=0 && d2==0))
return false;
}
}
+ d1=_names_faces;
+ d2=otherC->_names_faces;
+ if((d1==0 && d2!=0) || (d1!=0 && d2==0))
+ {
+ what="Mismatch of naming arr on faces ! One is defined and not other !";
+ return false;
+ }
+ if(d1)
+ {
+ bool ret=d1->isEqual(*d2);
+ if(!ret)
+ {
+ what="Naming arr on faces differ !";
+ return false;
+ }
+ }
d1=_names_nodes;
d2=otherC->_names_nodes;
if((d1==0 && d2!=0) || (d1!=0 && d2==0))
tmp=_num_cells;
if(tmp)
(const_cast<DataArrayInt *>(tmp))->setName("");
+ tmp=_fam_faces;
+ if(tmp)
+ (const_cast<DataArrayInt *>(tmp))->setName("");
+ tmp=_num_faces;
+ if(tmp)
+ (const_cast<DataArrayInt *>(tmp))->setName("");
}
/*!
*/
DataArrayInt *MEDFileStructuredMesh::getFamiliesArr(int meshDimRelToMaxExt, const std::vector<std::string>& fams, bool renum) const
{
- if(meshDimRelToMaxExt!=0 && meshDimRelToMaxExt!=1)
- throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getFamiliesArr : Only available for levels 0 or 1 !");
- std::vector<int> famIds=getFamiliesIds(fams);
- if(meshDimRelToMaxExt==1)
- {
- if((const DataArrayInt *)_fam_nodes)
- {
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da;
- if(!famIds.empty())
- da=_fam_nodes->getIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
- else
- da=_fam_nodes->getIdsEqualList(0,0);
- if(renum)
- return MEDFileUMeshSplitL1::Renumber(_num_nodes,da);
- else
- return da.retn();
- }
- else
- throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getFamiliesArr : no family array specified on nodes !");
- }
- else
- {
- if((const DataArrayInt *)_fam_cells)
- {
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da;
- if(!famIds.empty())
- da=_fam_cells->getIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
- else
- da=_fam_cells->getIdsEqualList(0,0);
- if(renum)
- return MEDFileUMeshSplitL1::Renumber(_num_cells,da);
- else
- return da.retn();
- }
- else
- throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getFamiliesArr : no family array specified on cells !");
- }
+ std::vector<int> famIds(getFamiliesIds(fams));
+ switch(meshDimRelToMaxExt)
+ {
+ case 1:
+ {
+ if((const DataArrayInt *)_fam_nodes)
+ {
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da;
+ if(!famIds.empty())
+ da=_fam_nodes->getIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
+ else
+ da=_fam_nodes->getIdsEqualList(0,0);
+ if(renum)
+ return MEDFileUMeshSplitL1::Renumber(_num_nodes,da);
+ else
+ return da.retn();
+ }
+ else
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getFamiliesArr : no family array specified on nodes !");
+ break;
+ }
+ case 0:
+ {
+ if((const DataArrayInt *)_fam_cells)
+ {
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da;
+ if(!famIds.empty())
+ da=_fam_cells->getIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
+ else
+ da=_fam_cells->getIdsEqualList(0,0);
+ if(renum)
+ return MEDFileUMeshSplitL1::Renumber(_num_cells,da);
+ else
+ return da.retn();
+ }
+ else
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getFamiliesArr : no family array specified on cells !");
+ break;
+ }
+ case -1:
+ {
+ if((const DataArrayInt *)_fam_faces)
+ {
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> da;
+ if(!famIds.empty())
+ da=_fam_faces->getIdsEqualList(&famIds[0],&famIds[0]+famIds.size());
+ else
+ da=_fam_faces->getIdsEqualList(0,0);
+ if(renum)
+ return MEDFileUMeshSplitL1::Renumber(_num_faces,da);
+ else
+ return da.retn();
+ }
+ else
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getFamiliesArr : no family array specified on faces !");
+ break;
+ }
+ default:
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getFamiliesArr : input meshDimRelative must be in [0,1,-1] !");
+ }
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getFamiliesArr : unmanaged case !");
}
/*!
* \param [in] famArr - the array of the family field.
* \throw If there are no mesh entities of \a meshDimRelToMaxExt dimension in \a this mesh.
* \throw If \a famArr has an invalid size.
- * \throw If \a meshDimRelToMaxExt != 0 and \a meshDimRelToMaxExt != 1.
+ * \throw If \a meshDimRelToMaxExt != 0 and \a meshDimRelToMaxExt != 1 and \a meshDimRelToMaxExt != -1.
*/
void MEDFileStructuredMesh::setFamilyFieldArr(int meshDimRelToMaxExt, DataArrayInt *famArr)
{
- if(meshDimRelToMaxExt!=0 && meshDimRelToMaxExt!=1)
- throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setRenumFieldArr : Only available for levels 0 or 1 !");
- const MEDCouplingStructuredMesh *mesh=getStructuredMesh();
+ const MEDCouplingStructuredMesh *mesh(getStructuredMesh());
if(!mesh)
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setFamilyFieldArr : no structured mesh specified ! Impossible to set family array !");
- if(meshDimRelToMaxExt==0)
- {
- int nbCells=mesh->getNumberOfCells();
- famArr->checkNbOfTuplesAndComp(nbCells,1,"MEDFileStructuredMesh::setFamilyFieldArr : Problem in size of Family arr ! Mismatch with number of cells of mesh !");
- _fam_cells=famArr;
- }
- else
- {
- int nbNodes=mesh->getNumberOfNodes();
- famArr->checkNbOfTuplesAndComp(nbNodes,1,"MEDFileStructuredMesh::setFamilyFieldArr : Problem in size of Family arr ! Mismatch with number of nodes of mesh !");
- _fam_nodes=famArr;
- }
+ switch(meshDimRelToMaxExt)
+ {
+ case 0:
+ {
+ int nbCells=mesh->getNumberOfCells();
+ famArr->checkNbOfTuplesAndComp(nbCells,1,"MEDFileStructuredMesh::setFamilyFieldArr : Problem in size of Family arr ! Mismatch with number of cells of mesh !");
+ _fam_cells=famArr;
+ break;
+ }
+ case 1:
+ {
+ int nbNodes=mesh->getNumberOfNodes();
+ famArr->checkNbOfTuplesAndComp(nbNodes,1,"MEDFileStructuredMesh::setFamilyFieldArr : Problem in size of Family arr ! Mismatch with number of nodes of mesh !");
+ _fam_nodes=famArr;
+ break;
+ }
+ case -1:
+ {
+ int nbCells=mesh->getNumberOfCellsOfSubLevelMesh();
+ famArr->checkNbOfTuplesAndComp(nbCells,1,"MEDFileStructuredMesh::setFamilyFieldArr : Problem in size of Family arr ! Mismatch with number of faces of mesh !");
+ _fam_faces=famArr;
+ break;
+ }
+ default:
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setFamilyFieldArr : Only available for levels 0 or 1 or -1 !");
+ }
if(famArr)
famArr->incrRef();
}
*/
void MEDFileStructuredMesh::setRenumFieldArr(int meshDimRelToMaxExt, DataArrayInt *renumArr)
{
- if(meshDimRelToMaxExt!=0 && meshDimRelToMaxExt!=1)
- throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setRenumFieldArr : Only available for levels 0 or 1 !");
const MEDCouplingStructuredMesh *mesh=getStructuredMesh();
if(!mesh)
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setRenumFieldArr : no structured mesh specified ! Impossible to set number array !");
- if(meshDimRelToMaxExt==0)
- {
- int nbCells=mesh->getNumberOfCells();
- renumArr->checkNbOfTuplesAndComp(nbCells,1,"MEDFileStructuredMesh::setRenumFieldArr : Problem in size of Renum arr ! Mismatch with number of cells of mesh !");
- _num_cells=renumArr;
- }
- else
- {
- int nbNodes=mesh->getNumberOfNodes();
- renumArr->checkNbOfTuplesAndComp(nbNodes,1,"MEDFileStructuredMesh::setRenumFieldArr : Problem in size of Family arr ! Mismatch with number of nodes of mesh !");
- _num_nodes=renumArr;
- }
+ switch(meshDimRelToMaxExt)
+ {
+ case 0:
+ {
+ int nbCells=mesh->getNumberOfCells();
+ renumArr->checkNbOfTuplesAndComp(nbCells,1,"MEDFileStructuredMesh::setRenumFieldArr : Problem in size of Renum arr ! Mismatch with number of cells of mesh !");
+ _num_cells=renumArr;
+ break;
+ }
+ case 1:
+ {
+ int nbNodes=mesh->getNumberOfNodes();
+ renumArr->checkNbOfTuplesAndComp(nbNodes,1,"MEDFileStructuredMesh::setRenumFieldArr : Problem in size of Family arr ! Mismatch with number of nodes of mesh !");
+ _num_nodes=renumArr;
+ break;
+ }
+ case -1:
+ {
+ int nbCells=mesh->getNumberOfCellsOfSubLevelMesh();
+ renumArr->checkNbOfTuplesAndComp(nbCells,1,"MEDFileStructuredMesh::setRenumFieldArr : Problem in size of Renum arr ! Mismatch with number of faces of mesh !");
+ _num_faces=renumArr;
+ break;
+ }
+ default:
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setRenumFieldArr : Only available for levels 0 or 1 or -1 !");
+ }
if(renumArr)
renumArr->incrRef();
}
*/
void MEDFileStructuredMesh::setNameFieldAtLevel(int meshDimRelToMaxExt, DataArrayAsciiChar *nameArr)
{
- if(meshDimRelToMaxExt!=0 && meshDimRelToMaxExt!=1)
- throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setNameFieldAtLevel : Only available for levels 0 or 1 !");
- const MEDCouplingStructuredMesh *mesh=getStructuredMesh();
+ const MEDCouplingStructuredMesh *mesh(getStructuredMesh());
if(!mesh)
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setNameFieldAtLevel : no structured mesh specified ! Impossible to set names array !");
- if(meshDimRelToMaxExt==0)
- {
- int nbCells=mesh->getNumberOfCells();
- nameArr->checkNbOfTuplesAndComp(nbCells,MED_SNAME_SIZE,"MEDFileStructuredMesh::setNameFieldAtLevel : Problem in size of names arr ! Mismatch with number of cells of mesh !");
- _names_cells=nameArr;
- }
- else
- {
- int nbNodes=mesh->getNumberOfNodes();
- nameArr->checkNbOfTuplesAndComp(nbNodes,MED_SNAME_SIZE,"MEDFileStructuredMesh::setNameFieldAtLevel : Problem in size of names arr ! Mismatch with number of nodes of mesh !");
- _names_nodes=nameArr;
- }
+ switch(meshDimRelToMaxExt)
+ {
+ case 0:
+ {
+ int nbCells=mesh->getNumberOfCells();
+ nameArr->checkNbOfTuplesAndComp(nbCells,MED_SNAME_SIZE,"MEDFileStructuredMesh::setNameFieldAtLevel : Problem in size of names arr ! Mismatch with number of cells of mesh !");
+ _names_cells=nameArr;
+ break;
+ }
+ case 1:
+ {
+ int nbNodes=mesh->getNumberOfNodes();
+ nameArr->checkNbOfTuplesAndComp(nbNodes,MED_SNAME_SIZE,"MEDFileStructuredMesh::setNameFieldAtLevel : Problem in size of names arr ! Mismatch with number of nodes of mesh !");
+ _names_nodes=nameArr;
+ break;
+ }
+ case -1:
+ {
+ int nbCells=mesh->getNumberOfCellsOfSubLevelMesh();
+ nameArr->checkNbOfTuplesAndComp(nbCells,MED_SNAME_SIZE,"MEDFileStructuredMesh::setNameFieldAtLevel : Problem in size of names arr ! Mismatch with number of faces of mesh !");
+ _names_cells=nameArr;
+ }
+ default:
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::setNameFieldAtLevel : Only available for levels 0 or 1 or -1 !");
+ }
if(nameArr)
nameArr->incrRef();
}
*/
const DataArrayInt *MEDFileStructuredMesh::getFamilyFieldAtLevel(int meshDimRelToMaxExt) const
{
- if(meshDimRelToMaxExt!=0 && meshDimRelToMaxExt!=1)
- throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getFamilyFieldAtLevel : Only available for levels 0 or 1 !");
- if(meshDimRelToMaxExt==0)
- return _fam_cells;
- else
- return _fam_nodes;
+ switch(meshDimRelToMaxExt)
+ {
+ case 0:
+ return _fam_cells;
+ case 1:
+ return _fam_nodes;
+ case -1:
+ return _fam_faces;
+ default:
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getFamilyFieldAtLevel : Only available for levels 0 or 1 or -1 !");
+ }
}
/*!
*/
const DataArrayInt *MEDFileStructuredMesh::getNumberFieldAtLevel(int meshDimRelToMaxExt) const
{
- if(meshDimRelToMaxExt!=0 && meshDimRelToMaxExt!=1)
- throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getNumberFieldAtLevel : Only available for levels 0 or 1 !");
- if(meshDimRelToMaxExt==0)
- return _num_cells;
- else
- return _num_nodes;
+ switch(meshDimRelToMaxExt)
+ {
+ case 0:
+ return _num_cells;
+ case 1:
+ return _num_nodes;
+ case -1:
+ return _num_faces;
+ default:
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getNumberFieldAtLevel : Only available for levels 0 or 1 or -1 !");
+ }
}
/*!
const DataArrayAsciiChar *MEDFileStructuredMesh::getNameFieldAtLevel(int meshDimRelToMaxExt) const
{
- if(meshDimRelToMaxExt!=0 && meshDimRelToMaxExt!=1)
- throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getNameFieldAtLevel : Only available for levels 0 or 1 !");
- if(meshDimRelToMaxExt==0)
- return _names_cells;
- else
- return _names_nodes;
+ switch(meshDimRelToMaxExt)
+ {
+ case 0:
+ return _names_cells;
+ case 1:
+ return _names_nodes;
+ case -1:
+ return _names_faces;
+ default:
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getNameFieldAtLevel : Only available for levels 0 or 1 or -1 !");
+ }
}
/*!
std::vector<int> MEDFileStructuredMesh::getFamArrNonEmptyLevelsExt() const
{
std::vector<int> ret;
- const DataArrayInt *famNodes(_fam_nodes),*famCells(_fam_cells);
+ const DataArrayInt *famNodes(_fam_nodes),*famCells(_fam_cells),*famFaces(_fam_faces);
if(famNodes)
ret.push_back(1);
if(famCells)
ret.push_back(0);
+ if(famFaces)
+ ret.push_back(-1);
return ret;
}
std::vector<int> MEDFileStructuredMesh::getNumArrNonEmptyLevelsExt() const
{
std::vector<int> ret;
- const DataArrayInt *numNodes(_num_nodes),*numCells(_num_cells);
+ const DataArrayInt *numNodes(_num_nodes),*numCells(_num_cells),*numFaces(_num_faces);
if(numNodes)
ret.push_back(1);
if(numCells)
ret.push_back(0);
+ if(numFaces)
+ ret.push_back(-1);
return ret;
}
std::vector<int> MEDFileStructuredMesh::getNameArrNonEmptyLevelsExt() const
{
std::vector<int> ret;
- const DataArrayAsciiChar *namesCells(_names_cells);
+ const DataArrayAsciiChar *namesNodes(_names_nodes),*namesCells(_names_cells),*namesFaces(_names_faces);
+ if(namesNodes)
+ ret.push_back(1);
if(namesCells)
ret.push_back(0);
+ if(namesFaces)
+ ret.push_back(-1);
return ret;
}
arr=_fam_cells;
if(arr)
arr->changeValue(oldId,newId);
+ arr=_fam_faces;
+ if(arr)
+ arr->changeValue(oldId,newId);
}
void MEDFileStructuredMesh::deepCpyAttributes()
_fam_nodes=_fam_nodes->deepCpy();
if((const DataArrayInt*)_num_nodes)
_num_nodes=_num_nodes->deepCpy();
+ if((const DataArrayAsciiChar*)_names_nodes)
+ _names_nodes=_names_nodes->deepCpy();
if((const DataArrayInt*)_fam_cells)
_fam_cells=_fam_cells->deepCpy();
if((const DataArrayInt*)_num_cells)
_num_cells=_num_cells->deepCpy();
+ if((const DataArrayAsciiChar*)_names_cells)
+ _names_cells=_names_cells->deepCpy();
+ if((const DataArrayInt*)_fam_faces)
+ _fam_faces=_fam_faces->deepCpy();
+ if((const DataArrayInt*)_num_faces)
+ _num_faces=_num_faces->deepCpy();
+ if((const DataArrayAsciiChar*)_names_faces)
+ _names_faces=_names_faces->deepCpy();
if((const DataArrayInt*)_rev_num_nodes)
_rev_num_nodes=_rev_num_nodes->deepCpy();
if((const DataArrayInt*)_rev_num_cells)
/*!
* Returns a pointer to MEDCouplingStructuredMesh held by \a this.
- * \param [in] meshDimRelToMax - it must be \c 0.
+ * \param [in] meshDimRelToMax - it must be \c 0 or \c -1.
* \param [in] renum - it must be \c false.
* \return MEDCouplingMesh * - a pointer to MEDCouplingMesh that the caller is to
* delete using decrRef() as it is no more needed.
{
if(renum)
throw INTERP_KERNEL::Exception("MEDFileCurveLinearMesh does not support renumbering ! To do it perform request of renum array directly !");
- if(meshDimRelToMax!=0)
- throw INTERP_KERNEL::Exception("MEDFileCurveLinearMesh does not support multi level for mesh 0 expected as input !");
- const MEDCouplingStructuredMesh *m=getStructuredMesh();
- if(m)
- m->incrRef();
- return const_cast<MEDCouplingStructuredMesh *>(m);
+ const MEDCouplingStructuredMesh *m(getStructuredMesh());
+ switch(meshDimRelToMax)
+ {
+ case 0:
+ {
+ if(m)
+ m->incrRef();
+ return const_cast<MEDCouplingStructuredMesh *>(m);
+ }
+ case -1:
+ {
+ if(!m)
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getGenMeshAtLevel : level -1 requested must be non empty to be able to compute unstructured sub mesh !");
+ buildMinusOneImplicitPartIfNeeded();
+ MEDCouplingMesh *ret(_faces_if_necessary);
+ if(ret)
+ ret->incrRef();
+ return ret;
+ }
+ default:
+ throw INTERP_KERNEL::Exception("MEDFileCurveLinearMesh does not support multi level for mesh 0 expected as input !");
+ }
}
/*!
*/
int MEDFileStructuredMesh::getSizeAtLevel(int meshDimRelToMaxExt) const
{
- if(meshDimRelToMaxExt!=0 && meshDimRelToMaxExt!=1)
- throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getSizeAtLevel : Only available for levels 0 or 1 !");
- const MEDCouplingStructuredMesh *cmesh=getStructuredMesh();
+ const MEDCouplingStructuredMesh *cmesh(getStructuredMesh());
if(!cmesh)
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getSizeAtLevel : No structured mesh set !");
- if(meshDimRelToMaxExt==0)
- return cmesh->getNumberOfCells();
- else
- return cmesh->getNumberOfNodes();
+ switch(meshDimRelToMaxExt)
+ {
+ case 0:
+ return cmesh->getNumberOfCells();
+ case 1:
+ return cmesh->getNumberOfNodes();
+ case -1:
+ return cmesh->getNumberOfCellsOfSubLevelMesh();
+ default:
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getSizeAtLevel : Only available for levels 0 or 1 or -1 !");
+ }
}
int MEDFileStructuredMesh::getNumberOfNodes() const
{
- const MEDCouplingStructuredMesh *cmesh=getStructuredMesh();
+ const MEDCouplingStructuredMesh *cmesh(getStructuredMesh());
if(!cmesh)
throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getNumberOfNodes : no cartesian mesh set !");
return cmesh->getNumberOfNodes();
}
+bool MEDFileStructuredMesh::hasImplicitPart() const
+{
+ return true;
+}
+
+/*!
+ * \sa MEDFileStructuredMesh::getImplicitFaceMesh
+ */
+int MEDFileStructuredMesh::buildImplicitPartIfAny(INTERP_KERNEL::NormalizedCellType gt) const
+{
+ static const char MSG[]="MEDFileStructuredMesh::buildImplicitPartIfAny : the given geo type is not manageable by a structured mesh !";
+ const MEDCoupling1SGTUMesh *zeFaceMesh(_faces_if_necessary);
+ if(!zeFaceMesh)
+ {
+ const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(getMeshDimension())));
+ if(cm.getReverseExtrudedType()!=gt)
+ throw INTERP_KERNEL::Exception(MSG);
+ buildImplicitPart();
+ return getStructuredMesh()->getNumberOfCellsOfSubLevelMesh();
+ }
+ else
+ {
+ if(gt!=zeFaceMesh->getCellModelEnum())
+ throw INTERP_KERNEL::Exception(MSG);
+ return zeFaceMesh->getNumberOfCells();
+ }
+}
+
+void MEDFileStructuredMesh::buildMinusOneImplicitPartIfNeeded() const
+{
+ const MEDCoupling1SGTUMesh *zeFaceMesh(_faces_if_necessary);
+ if(!zeFaceMesh)
+ buildImplicitPart();
+}
+
+void MEDFileStructuredMesh::buildImplicitPart() const
+{
+ const MEDCouplingStructuredMesh *mcmesh(getStructuredMesh());
+ if(!mcmesh)
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::buildImplicitPart : Unable to build the implicit part of structured mesh because no structured mesh at level 0 defined !");
+ _faces_if_necessary=mcmesh->build1SGTSubLevelMesh();
+}
+
+void MEDFileStructuredMesh::releaseImplicitPartIfAny() const
+{
+ _faces_if_necessary=0;
+}
+
+/*!
+ * Retrieves the internal pointer (no decrRef requested) of the implicit face mesh if any.
+ * To force to build it you can invoke MEDFileStructuredMesh::buildImplicitPartIfAny method.
+ *
+ * \sa MEDFileStructuredMesh::buildImplicitPartIfAny
+ */
+MEDCoupling1SGTUMesh *MEDFileStructuredMesh::getImplicitFaceMesh() const
+{
+ return _faces_if_necessary;
+}
+
+std::vector<INTERP_KERNEL::NormalizedCellType> MEDFileStructuredMesh::getGeoTypesAtLevel(int meshDimRelToMax) const
+{
+ const MEDCouplingStructuredMesh *cmesh(getStructuredMesh());
+ if(!cmesh)
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getGeoTypesAtLevel : No structured mesh set !");
+ switch(meshDimRelToMax)
+ {
+ case 0:
+ {
+ std::vector<INTERP_KERNEL::NormalizedCellType> ret(1,cmesh->getTypeOfCell(0));
+ return ret;
+ }
+ case -1:
+ {
+ int mdim(cmesh->getMeshDimension());
+ if(mdim<1)
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getGeoTypesAtLevel : only one level available for structured meshes ! Input 0 is mandatory or 0D mesh !");
+ std::vector<INTERP_KERNEL::NormalizedCellType> ret(1,MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(mdim-1));
+ return ret;
+ }
+ default:
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::getGeoTypesAtLevel : only 2 levels available at most : 0 and -1 !");
+ }
+}
+
void MEDFileStructuredMesh::whichAreNodesFetched(const MEDFileField1TSStructItem& st, const MEDFileFieldGlobsReal *globs, std::vector<bool>& nodesFetched) const
{
if(st.getNumberOfItems()!=1)
std::fill(nodesFetched.begin(),nodesFetched.end(),true);
return ;
}
- const DataArrayInt *arr(globs->getProfile(st[0].getPflName().c_str()));
+ const DataArrayInt *arr(globs->getProfile(st[0].getPflName()));
const MEDCouplingStructuredMesh *cmesh=getStructuredMesh();//cmesh not null because getNumberOfNodes called before
int sz(nodesFetched.size());
for(const int *work=arr->begin();work!=arr->end();work++)
med_geometry_type MEDFileStructuredMesh::GetGeoTypeFromMeshDim(int meshDim)
{
- med_geometry_type geoTypeReq=MED_NONE;
- switch(meshDim)
- {
- case 3:
- geoTypeReq=MED_HEXA8;
- break;
- case 2:
- geoTypeReq=MED_QUAD4;
- break;
- case 1:
- geoTypeReq=MED_SEG2;
- break;
- case 0:
- geoTypeReq=MED_POINT1;
- break;
- default:
- throw INTERP_KERNEL::Exception("Invalid meshdim detected for structured mesh ! Must be in (1,2,3) !");
- }
- return geoTypeReq;
+ INTERP_KERNEL::NormalizedCellType ct(MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(meshDim));
+ return typmai3[ct];
}
-void MEDFileStructuredMesh::loadStrMeshFromFile(MEDFileStrMeshL2 *strm, med_idt fid, const char *mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+void MEDFileStructuredMesh::LoadStrMeshDAFromFile(med_idt fid, int meshDim, int dt, int it, const std::string& mName, MEDFileMeshReadSelector *mrs,
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt>& famCells, MEDCouplingAutoRefCountObjectPtr<DataArrayInt>& numCells, MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar>& namesCells)
{
- setName(strm->getName());
- setDescription(strm->getDescription());
- setUnivName(strm->getUnivName());
- setIteration(strm->getIteration());
- setOrder(strm->getOrder());
- setTimeValue(strm->getTime());
- setTimeUnit(strm->getTimeUnit());
- MEDFileMeshL2::ReadFamiliesAndGrps(fid,mName,_families,_groups,mrs);
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
- int nbOfElt=MEDmeshnEntity(fid,mName,dt,it,MED_NODE,MED_NONE,MED_FAMILY_NUMBER,MED_NODAL,&chgt,&trsf);
+ med_geometry_type geoTypeReq=MEDFileStructuredMesh::GetGeoTypeFromMeshDim(meshDim);
+ int nbOfElt(0);
+ nbOfElt=MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,MED_FAMILY_NUMBER,MED_NODAL,&chgt,&trsf);
if(nbOfElt>0)
{
- if(!mrs || mrs->isNodeFamilyFieldReading())
+ if(!mrs || mrs->isCellFamilyFieldReading())
{
- _fam_nodes=DataArrayInt::New();
- _fam_nodes->alloc(nbOfElt,1);
- MEDmeshEntityFamilyNumberRd(fid,mName,dt,it,MED_NODE,MED_NONE,_fam_nodes->getPointer());
+ famCells=DataArrayInt::New();
+ famCells->alloc(nbOfElt,1);
+ MEDmeshEntityFamilyNumberRd(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,famCells->getPointer());
}
}
- nbOfElt=MEDmeshnEntity(fid,mName,dt,it,MED_NODE,MED_NONE,MED_NUMBER,MED_NODAL,&chgt,&trsf);
+ nbOfElt=MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,MED_NUMBER,MED_NODAL,&chgt,&trsf);
if(nbOfElt>0)
{
- if(!mrs || mrs->isNodeNumFieldReading())
+ if(!mrs || mrs->isCellNumFieldReading())
{
- _num_nodes=DataArrayInt::New();
- _num_nodes->alloc(nbOfElt,1);
- MEDmeshEntityNumberRd(fid,mName,dt,it,MED_NODE,MED_NONE,_num_nodes->getPointer());
+ numCells=DataArrayInt::New();
+ numCells->alloc(nbOfElt,1);
+ MEDmeshEntityNumberRd(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,numCells->getPointer());
}
}
- int meshDim=getStructuredMesh()->getMeshDimension();
- med_geometry_type geoTypeReq=GetGeoTypeFromMeshDim(meshDim);
- nbOfElt=MEDmeshnEntity(fid,mName,dt,it,MED_CELL,geoTypeReq,MED_FAMILY_NUMBER,MED_NODAL,&chgt,&trsf);
+ nbOfElt=MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,MED_NAME,MED_NODAL,&chgt,&trsf);
if(nbOfElt>0)
{
- if(!mrs || mrs->isCellFamilyFieldReading())
+ if(!mrs || mrs->isCellNameFieldReading())
{
- _fam_cells=DataArrayInt::New();
- _fam_cells->alloc(nbOfElt,1);
- MEDmeshEntityFamilyNumberRd(fid,mName,dt,it,MED_CELL,geoTypeReq,_fam_cells->getPointer());
+ namesCells=DataArrayAsciiChar::New();
+ namesCells->alloc(nbOfElt+1,MED_SNAME_SIZE);//not a bug to avoid the memory corruption due to last \0 at the end
+ MEDmeshEntityNameRd(fid,mName.c_str(),dt,it,MED_CELL,geoTypeReq,namesCells->getPointer());
+ namesCells->reAlloc(nbOfElt);//not a bug to avoid the memory corruption due to last \0 at the end
}
}
- nbOfElt=MEDmeshnEntity(fid,mName,dt,it,MED_CELL,geoTypeReq,MED_NUMBER,MED_NODAL,&chgt,&trsf);
+}
+
+void MEDFileStructuredMesh::loadStrMeshFromFile(MEDFileStrMeshL2 *strm, med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+{
+ setName(strm->getName());
+ setDescription(strm->getDescription());
+ setUnivName(strm->getUnivName());
+ setIteration(strm->getIteration());
+ setOrder(strm->getOrder());
+ setTimeValue(strm->getTime());
+ setTimeUnit(strm->getTimeUnit());
+ MEDFileMeshL2::ReadFamiliesAndGrps(fid,mName,_families,_groups,mrs);
+ med_bool chgt=MED_FALSE,trsf=MED_FALSE;
+ int nbOfElt=MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_FAMILY_NUMBER,MED_NODAL,&chgt,&trsf);
if(nbOfElt>0)
{
- if(!mrs || mrs->isCellNumFieldReading())
+ if(!mrs || mrs->isNodeFamilyFieldReading())
{
- _num_cells=DataArrayInt::New();
- _num_cells->alloc(nbOfElt,1);
- MEDmeshEntityNumberRd(fid,mName,dt,it,MED_CELL,geoTypeReq,_num_cells->getPointer());
+ int nbNodes(getNumberOfNodes());
+ if(nbOfElt>nbNodes)
+ throw INTERP_KERNEL::Exception("MEDFileStructuredMesh::loadStrMeshFromFile : invalid size of family node array regarding number of nodes in this ! File seems to be corrupted !");
+ _fam_nodes=DataArrayInt::New();
+ _fam_nodes->alloc(nbNodes,1);//yes nbNodes and not nbOfElt see next line.
+ if(nbNodes>nbOfElt)//yes it appends some times... It explains surely the mdump implementation. Bug revealed by PARAVIS EDF #2475 on structured.med file where only 12 first nodes are !=0 so nbOfElt=12 and nbOfNodes=378...
+ _fam_nodes->fillWithZero();
+ MEDmeshEntityFamilyNumberRd(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,_fam_nodes->getPointer());
}
}
- nbOfElt=MEDmeshnEntity(fid,mName,dt,it,MED_CELL,geoTypeReq,MED_NAME,MED_NODAL,&chgt,&trsf);
+ nbOfElt=MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_NUMBER,MED_NODAL,&chgt,&trsf);
if(nbOfElt>0)
{
- if(!mrs || mrs->isCellNameFieldReading())
+ if(!mrs || mrs->isNodeNumFieldReading())
{
- _names_cells=DataArrayAsciiChar::New();
- _names_cells->alloc(nbOfElt+1,MED_SNAME_SIZE);//not a bug to avoid the memory corruption due to last \0 at the end
- MEDmeshEntityNameRd(fid,mName,dt,it,MED_CELL,geoTypeReq,_names_cells->getPointer());
- _names_cells->reAlloc(nbOfElt);//not a bug to avoid the memory corruption due to last \0 at the end
+ _num_nodes=DataArrayInt::New();
+ _num_nodes->alloc(nbOfElt,1);
+ MEDmeshEntityNumberRd(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,_num_nodes->getPointer());
}
}
- nbOfElt=MEDmeshnEntity(fid,mName,dt,it,MED_NODE,MED_NONE,MED_NAME,MED_NODAL,&chgt,&trsf);
+ nbOfElt=MEDmeshnEntity(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,MED_NAME,MED_NODAL,&chgt,&trsf);
if(nbOfElt>0)
{
if(!mrs || mrs->isNodeNameFieldReading())
{
_names_nodes=DataArrayAsciiChar::New();
_names_nodes->alloc(nbOfElt+1,MED_SNAME_SIZE);//not a bug to avoid the memory corruption due to last \0 at the end
- MEDmeshEntityNameRd(fid,mName,dt,it,MED_NODE,MED_NONE,_names_nodes->getPointer());
+ MEDmeshEntityNameRd(fid,mName.c_str(),dt,it,MED_NODE,MED_NONE,_names_nodes->getPointer());
_names_nodes->reAlloc(nbOfElt);//not a bug to avoid the memory corruption due to last \0 at the end
}
}
+ int meshDim(getStructuredMesh()->getMeshDimension());
+ LoadStrMeshDAFromFile(fid,meshDim,dt,it,mName,mrs,_fam_cells,_num_cells,_names_cells);
+ if(meshDim>=1)
+ LoadStrMeshDAFromFile(fid,meshDim-1,dt,it,mName,mrs,_fam_faces,_num_faces,_names_faces);
}
-void MEDFileStructuredMesh::writeStructuredLL(med_idt fid, const char *maa) const
+void MEDFileStructuredMesh::writeStructuredLL(med_idt fid, const std::string& maa) const
{
- int meshDim=getStructuredMesh()->getMeshDimension();
- med_geometry_type geoTypeReq=GetGeoTypeFromMeshDim(meshDim);
+ int meshDim(getStructuredMesh()->getMeshDimension());
+ med_geometry_type geoTypeReq(GetGeoTypeFromMeshDim(meshDim)),geoTypeReq2(GetGeoTypeFromMeshDim(meshDim-1));
//
if((const DataArrayInt *)_fam_cells)
- MEDmeshEntityFamilyNumberWr(fid,maa,_iteration,_order,MED_CELL,geoTypeReq,_fam_cells->getNumberOfTuples(),_fam_cells->getConstPointer());
+ MEDmeshEntityFamilyNumberWr(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq,_fam_cells->getNumberOfTuples(),_fam_cells->getConstPointer());
+ if((const DataArrayInt *)_fam_faces)
+ MEDmeshEntityFamilyNumberWr(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq2,_fam_faces->getNumberOfTuples(),_fam_faces->getConstPointer());
if((const DataArrayInt *)_fam_nodes)
- MEDmeshEntityFamilyNumberWr(fid,maa,_iteration,_order,MED_NODE,MED_NONE,_fam_nodes->getNumberOfTuples(),_fam_nodes->getConstPointer());
+ MEDmeshEntityFamilyNumberWr(fid,maa.c_str(),_iteration,_order,MED_NODE,MED_NONE,_fam_nodes->getNumberOfTuples(),_fam_nodes->getConstPointer());
if((const DataArrayInt *)_num_cells)
- MEDmeshEntityNumberWr(fid,maa,_iteration,_order,MED_CELL,geoTypeReq,_num_cells->getNumberOfTuples(),_num_cells->getConstPointer());
+ MEDmeshEntityNumberWr(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq,_num_cells->getNumberOfTuples(),_num_cells->getConstPointer());
+ if((const DataArrayInt *)_num_faces)
+ MEDmeshEntityNumberWr(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq2,_num_faces->getNumberOfTuples(),_num_faces->getConstPointer());
if((const DataArrayInt *)_num_nodes)
- MEDmeshEntityNumberWr(fid,maa,_iteration,_order,MED_NODE,MED_NONE,_num_nodes->getNumberOfTuples(),_num_nodes->getConstPointer());
+ MEDmeshEntityNumberWr(fid,maa.c_str(),_iteration,_order,MED_NODE,MED_NONE,_num_nodes->getNumberOfTuples(),_num_nodes->getConstPointer());
if((const DataArrayAsciiChar *)_names_cells)
{
if(_names_cells->getNumberOfComponents()!=MED_SNAME_SIZE)
oss << " ! The array has " << _names_cells->getNumberOfComponents() << " components !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- MEDmeshEntityNameWr(fid,maa,_iteration,_order,MED_CELL,geoTypeReq,_names_cells->getNumberOfTuples(),_names_cells->getConstPointer());
+ MEDmeshEntityNameWr(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq,_names_cells->getNumberOfTuples(),_names_cells->getConstPointer());
+ }
+ if((const DataArrayAsciiChar *)_names_faces)
+ {
+ if(_names_faces->getNumberOfComponents()!=MED_SNAME_SIZE)
+ {
+ std::ostringstream oss; oss << "MEDFileStructuredMesh::writeStructuredLL : expected a name field on faces with number of components set to " << MED_SNAME_SIZE;
+ oss << " ! The array has " << _names_faces->getNumberOfComponents() << " components !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ MEDmeshEntityNameWr(fid,maa.c_str(),_iteration,_order,MED_CELL,geoTypeReq2,_names_faces->getNumberOfTuples(),_names_faces->getConstPointer());
}
if((const DataArrayAsciiChar *)_names_nodes)
{
oss << " ! The array has " << _names_cells->getNumberOfComponents() << " components !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- MEDmeshEntityNameWr(fid,maa,_iteration,_order,MED_NODE,MED_NONE,_names_nodes->getNumberOfTuples(),_names_nodes->getConstPointer());
+ MEDmeshEntityNameWr(fid,maa.c_str(),_iteration,_order,MED_NODE,MED_NONE,_names_nodes->getNumberOfTuples(),_names_nodes->getConstPointer());
}
//
- MEDFileUMeshL2::WriteFamiliesAndGrps(fid,maa,_families,_groups,_too_long_str);
+ MEDFileUMeshL2::WriteFamiliesAndGrps(fid,maa.c_str(),_families,_groups,_too_long_str);
}
/*!
* \throw If there is no meshes in the file.
* \throw If the mesh in the file is not a Cartesian one.
*/
-MEDFileCMesh *MEDFileCMesh::New(const char *fileName, MEDFileMeshReadSelector *mrs)
+MEDFileCMesh *MEDFileCMesh::New(const std::string& fileName, MEDFileMeshReadSelector *mrs)
{
std::vector<std::string> ms=MEDLoader::GetMeshNames(fileName);
if(ms.empty())
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
+ MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
int dt,it;
ParaMEDMEM::MEDCouplingMeshType meshType;
std::string dummy2;
- MEDFileMeshL2::GetMeshIdFromName(fid,ms.front().c_str(),meshType,dt,it,dummy2);
- return new MEDFileCMesh(fid,ms.front().c_str(),dt,it,mrs);
+ MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dt,it,dummy2);
+ return new MEDFileCMesh(fid,ms.front(),dt,it,mrs);
}
/*!
* \throw If there is no mesh with given attributes in the file.
* \throw If the mesh in the file is not a Cartesian one.
*/
-MEDFileCMesh *MEDFileCMesh::New(const char *fileName, const char *mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+MEDFileCMesh *MEDFileCMesh::New(const std::string& fileName, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
+ MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
return new MEDFileCMesh(fid,mName,dt,it,mrs);
}
return MEDFileStructuredMesh::getHeapMemorySizeWithoutChildren();
}
-std::vector<const BigMemoryObject *> MEDFileCMesh::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileCMesh::getDirectChildrenWithNull() const
{
- std::vector<const BigMemoryObject *> ret(MEDFileStructuredMesh::getDirectChildren());
- if((const MEDCouplingCMesh *)_cmesh)
- ret.push_back((const MEDCouplingCMesh *)_cmesh);
+ std::vector<const BigMemoryObject *> ret(MEDFileStructuredMesh::getDirectChildrenWithNull());
+ ret.push_back((const MEDCouplingCMesh *)_cmesh);
return ret;
}
return _cmesh->getMeshDimension();
}
+/*!
+ * Returns the dimension on nodes in \a this mesh.
+ * \return int - the space dimension.
+ * \throw If there are no cells in this mesh.
+ */
+int MEDFileCMesh::getSpaceDimension() const
+{
+ if(!((const MEDCouplingCMesh*)_cmesh))
+ throw INTERP_KERNEL::Exception("MEDFileCMesh::getSpaceDimension : unable to get spacedimension because no mesh set !");
+ return _cmesh->getSpaceDimension();
+}
+
/*!
* Returns a string describing \a this mesh.
* \return std::string - the mesh information string.
{
}
-MEDFileCMesh::MEDFileCMesh(med_idt fid, const char *mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+MEDFileCMesh::MEDFileCMesh(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
try
- {
+{
loadCMeshFromFile(fid,mName,dt,it,mrs);
- }
+}
catch(INTERP_KERNEL::Exception& e)
- {
+{
throw e;
- }
+}
-void MEDFileCMesh::loadCMeshFromFile(med_idt fid, const char *mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+void MEDFileCMesh::loadCMeshFromFile(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
ParaMEDMEM::MEDCouplingMeshType meshType;
int dummy0,dummy1;
MEDLoaderBase::safeStrCpy(_name.c_str(),MED_NAME_SIZE,maa,_too_long_str);
MEDLoaderBase::safeStrCpy(_desc_name.c_str(),MED_COMMENT_SIZE,desc,_too_long_str);
MEDLoaderBase::safeStrCpy(_dt_unit.c_str(),MED_LNAME_SIZE,dtunit,_too_long_str);
- int spaceDim=_cmesh->getSpaceDimension();
- int meshDim=_cmesh->getMeshDimension();
+ int spaceDim(_cmesh->getSpaceDimension());
INTERP_KERNEL::AutoPtr<char> comp=MEDLoaderBase::buildEmptyString(spaceDim*MED_SNAME_SIZE);
INTERP_KERNEL::AutoPtr<char> unit=MEDLoaderBase::buildEmptyString(spaceDim*MED_SNAME_SIZE);
for(int i=0;i<spaceDim;i++)
MEDLoaderBase::safeStrCpy2(c.c_str(),MED_SNAME_SIZE-1,comp+i*MED_SNAME_SIZE,_too_long_str);//MED_TAILLE_PNOM-1 to avoid to write '\0' on next compo
MEDLoaderBase::safeStrCpy2(u.c_str(),MED_SNAME_SIZE-1,unit+i*MED_SNAME_SIZE,_too_long_str);//MED_TAILLE_PNOM-1 to avoid to write '\0' on next compo
}
- MEDmeshCr(fid,maa,spaceDim,meshDim,MED_STRUCTURED_MESH,desc,dtunit,MED_SORT_DTIT,MED_CARTESIAN,comp,unit);
+ MEDmeshCr(fid,maa,spaceDim,spaceDim,MED_STRUCTURED_MESH,desc,dtunit,MED_SORT_DTIT,MED_CARTESIAN,comp,unit);
MEDmeshUniversalNameWr(fid,maa);
MEDmeshGridTypeWr(fid,maa,MED_CARTESIAN_GRID);
for(int i=0;i<spaceDim;i++)
MEDmeshGridIndexCoordinateWr(fid,maa,_iteration,_order,_time,i+1,da->getNumberOfTuples(),da->getConstPointer());
}
//
- MEDFileStructuredMesh::writeStructuredLL(fid,maa);
+ std::string meshName(MEDLoaderBase::buildStringFromFortran(maa,MED_NAME_SIZE));
+ MEDFileStructuredMesh::writeStructuredLL(fid,meshName);
}
void MEDFileCMesh::synchronizeTinyInfoOnLeaves() const
const MEDCouplingCMesh *cmesh=_cmesh;
if(!cmesh)
return;
- (const_cast<MEDCouplingCMesh *>(cmesh))->setName(_name.c_str());
- (const_cast<MEDCouplingCMesh *>(cmesh))->setDescription(_desc_name.c_str());
+ (const_cast<MEDCouplingCMesh *>(cmesh))->setName(_name);
+ (const_cast<MEDCouplingCMesh *>(cmesh))->setDescription(_desc_name);
(const_cast<MEDCouplingCMesh *>(cmesh))->setTime(_time,_iteration,_order);
- (const_cast<MEDCouplingCMesh *>(cmesh))->setTimeUnit(_dt_unit.c_str());
+ (const_cast<MEDCouplingCMesh *>(cmesh))->setTimeUnit(_dt_unit);
}
MEDFileCurveLinearMesh *MEDFileCurveLinearMesh::New()
return new MEDFileCurveLinearMesh;
}
-MEDFileCurveLinearMesh *MEDFileCurveLinearMesh::New(const char *fileName, MEDFileMeshReadSelector *mrs)
+MEDFileCurveLinearMesh *MEDFileCurveLinearMesh::New(const std::string& fileName, MEDFileMeshReadSelector *mrs)
{
std::vector<std::string> ms=MEDLoader::GetMeshNames(fileName);
if(ms.empty())
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
+ MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
int dt,it;
ParaMEDMEM::MEDCouplingMeshType meshType;
std::string dummy2;
- MEDFileMeshL2::GetMeshIdFromName(fid,ms.front().c_str(),meshType,dt,it,dummy2);
- return new MEDFileCurveLinearMesh(fid,ms.front().c_str(),dt,it,mrs);
+ MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dt,it,dummy2);
+ return new MEDFileCurveLinearMesh(fid,ms.front(),dt,it,mrs);
}
-MEDFileCurveLinearMesh *MEDFileCurveLinearMesh::New(const char *fileName, const char *mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+MEDFileCurveLinearMesh *MEDFileCurveLinearMesh::New(const std::string& fileName, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
+ MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
return new MEDFileCurveLinearMesh(fid,mName,dt,it,mrs);
}
return MEDFileStructuredMesh::getHeapMemorySizeWithoutChildren();
}
-std::vector<const BigMemoryObject *> MEDFileCurveLinearMesh::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileCurveLinearMesh::getDirectChildrenWithNull() const
{
- std::vector<const BigMemoryObject *> ret(MEDFileStructuredMesh::getDirectChildren());
- if((const MEDCouplingCurveLinearMesh *)_clmesh)
- ret.push_back((const MEDCouplingCurveLinearMesh *)_clmesh);
+ std::vector<const BigMemoryObject *> ret(MEDFileStructuredMesh::getDirectChildrenWithNull());
+ ret.push_back((const MEDCouplingCurveLinearMesh *)_clmesh);
return ret;
}
const MEDCouplingCurveLinearMesh *clmesh=_clmesh;
if(!clmesh)
return;
- (const_cast<MEDCouplingCurveLinearMesh *>(clmesh))->setName(_name.c_str());
- (const_cast<MEDCouplingCurveLinearMesh *>(clmesh))->setDescription(_desc_name.c_str());
+ (const_cast<MEDCouplingCurveLinearMesh *>(clmesh))->setName(_name);
+ (const_cast<MEDCouplingCurveLinearMesh *>(clmesh))->setDescription(_desc_name);
(const_cast<MEDCouplingCurveLinearMesh *>(clmesh))->setTime(_time,_iteration,_order);
- (const_cast<MEDCouplingCurveLinearMesh *>(clmesh))->setTimeUnit(_dt_unit.c_str());
+ (const_cast<MEDCouplingCurveLinearMesh *>(clmesh))->setTimeUnit(_dt_unit);
}
const MEDCouplingCurveLinearMesh *MEDFileCurveLinearMesh::getMesh() const
{
}
-MEDFileCurveLinearMesh::MEDFileCurveLinearMesh(med_idt fid, const char *mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+MEDFileCurveLinearMesh::MEDFileCurveLinearMesh(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
try
- {
+{
loadCLMeshFromFile(fid,mName,dt,it,mrs);
- }
+}
catch(INTERP_KERNEL::Exception& e)
- {
+{
throw e;
- }
+}
void MEDFileCurveLinearMesh::writeLL(med_idt fid) const
{
MEDmeshGridTypeWr(fid,maa,MED_CURVILINEAR_GRID);
std::vector<int> nodeGridSt=_clmesh->getNodeGridStructure();
MEDmeshGridStructWr(fid,maa,_iteration,_order,_time,&nodeGridSt[0]);
-
+
MEDmeshNodeCoordinateWr(fid,maa,_iteration,_order,_time,MED_FULL_INTERLACE,coords->getNumberOfTuples(),coords->begin());
//
- MEDFileStructuredMesh::writeStructuredLL(fid,maa);
+ std::string meshName(MEDLoaderBase::buildStringFromFortran(maa,MED_NAME_SIZE));
+ MEDFileStructuredMesh::writeStructuredLL(fid,meshName);
}
-void MEDFileCurveLinearMesh::loadCLMeshFromFile(med_idt fid, const char *mName, int dt, int it, MEDFileMeshReadSelector *mrs)
+void MEDFileCurveLinearMesh::loadCLMeshFromFile(med_idt fid, const std::string& mName, int dt, int it, MEDFileMeshReadSelector *mrs)
{
ParaMEDMEM::MEDCouplingMeshType meshType;
int dummy0,dummy1;
return new MEDFileMeshMultiTS;
}
-MEDFileMeshMultiTS *MEDFileMeshMultiTS::New(const char *fileName)
+MEDFileMeshMultiTS *MEDFileMeshMultiTS::New(const std::string& fileName)
{
return new MEDFileMeshMultiTS(fileName);
}
-MEDFileMeshMultiTS *MEDFileMeshMultiTS::New(const char *fileName, const char *mName)
+MEDFileMeshMultiTS *MEDFileMeshMultiTS::New(const std::string& fileName, const std::string& mName)
{
return new MEDFileMeshMultiTS(fileName,mName);
}
return _mesh_one_ts.capacity()*sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileMesh>);
}
-std::vector<const BigMemoryObject *> MEDFileMeshMultiTS::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileMeshMultiTS::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileMesh> >::const_iterator it=_mesh_one_ts.begin();it!=_mesh_one_ts.end();it++)
- {
- const MEDFileMesh *cur(*it);
- if(cur)
- ret.push_back(cur);
- }
+ ret.push_back((const MEDFileMesh *)*it);
return ret;
}
return _mesh_one_ts[0]->getName();
}
-void MEDFileMeshMultiTS::setName(const char *newMeshName)
+void MEDFileMeshMultiTS::setName(const std::string& newMeshName)
{
std::string oldName(getName());
std::vector< std::pair<std::string,std::string> > v(1);
}
}
-void MEDFileMeshMultiTS::write(const char *fileName, int mode) const
+void MEDFileMeshMultiTS::write(const std::string& fileName, int mode) const
{
med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
+ MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
std::ostringstream oss; oss << "MEDFileMesh : error on attempt to write in file : \"" << fileName << "\"";
- MEDFileUtilities::CheckMEDCode(fid,fid,oss.str().c_str());
+ MEDFileUtilities::CheckMEDCode(fid,fid,oss.str());
write(fid);
}
-void MEDFileMeshMultiTS::loadFromFile(const char *fileName, const char *mName)
+void MEDFileMeshMultiTS::loadFromFile(const std::string& fileName, const std::string& mName)
{//for the moment to be improved
_mesh_one_ts.resize(1);
_mesh_one_ts[0]=MEDFileMesh::New(fileName,mName,-1,-1);
{
}
-MEDFileMeshMultiTS::MEDFileMeshMultiTS(const char *fileName)
+MEDFileMeshMultiTS::MEDFileMeshMultiTS(const std::string& fileName)
try
- {
+{
std::vector<std::string> ms=MEDLoader::GetMeshNames(fileName);
if(ms.empty())
- {
- std::ostringstream oss; oss << "MEDFileUMesh::New : no meshes in file \"" << fileName << "\" !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
+ {
+ std::ostringstream oss; oss << "MEDFileUMesh::New : no meshes in file \"" << fileName << "\" !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
MEDFileUtilities::CheckFileForRead(fileName);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,MED_ACC_RDONLY);
+ MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),MED_ACC_RDONLY);
int dt,it;
ParaMEDMEM::MEDCouplingMeshType meshType;
std::string dummy2;
- MEDFileMeshL2::GetMeshIdFromName(fid,ms.front().c_str(),meshType,dt,it,dummy2);
- loadFromFile(fileName,ms.front().c_str());
- }
+ MEDFileMeshL2::GetMeshIdFromName(fid,ms.front(),meshType,dt,it,dummy2);
+ loadFromFile(fileName,ms.front());
+}
catch(INTERP_KERNEL::Exception& e)
- {
+{
throw e;
- }
+}
-MEDFileMeshMultiTS::MEDFileMeshMultiTS(const char *fileName, const char *mName)
+MEDFileMeshMultiTS::MEDFileMeshMultiTS(const std::string& fileName, const std::string& mName)
try
- {
+{
loadFromFile(fileName,mName);
- }
+}
catch(INTERP_KERNEL::Exception& e)
- {
+{
throw e;
- }
+}
MEDFileMeshes *MEDFileMeshes::New()
{
return new MEDFileMeshes;
}
-MEDFileMeshes *MEDFileMeshes::New(const char *fileName)
+MEDFileMeshes *MEDFileMeshes::New(const std::string& fileName)
{
return new MEDFileMeshes(fileName);
}
}
}
-void MEDFileMeshes::write(const char *fileName, int mode) const
+void MEDFileMeshes::write(const std::string& fileName, int mode) const
{
med_access_mode medmod=MEDFileUtilities::TraduceWriteMode(mode);
- MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName,medmod);
+ MEDFileUtilities::AutoFid fid=MEDfileOpen(fileName.c_str(),medmod);
std::ostringstream oss; oss << "MEDFileMesh : error on attempt to write in file : \"" << fileName << "\"";
- MEDFileUtilities::CheckMEDCode(fid,fid,oss.str().c_str());
+ MEDFileUtilities::CheckMEDCode(fid,fid,oss.str());
checkCoherency();
write(fid);
}
return new MEDFileMeshesIterator(this);
}
+/** Return a borrowed reference (caller is not responsible) */
MEDFileMesh *MEDFileMeshes::getMeshAtPos(int i) const
{
if(i<0 || i>=(int)_meshes.size())
return _meshes[i]->getOneTimeStep();
}
-MEDFileMesh *MEDFileMeshes::getMeshWithName(const char *mname) const
+/** Return a borrowed reference (caller is not responsible) */
+MEDFileMesh *MEDFileMeshes::getMeshWithName(const std::string& mname) const
{
std::vector<std::string> ms=getMeshesNames();
std::vector<std::string>::iterator it=std::find(ms.begin(),ms.end(),mname);
_meshes.erase(_meshes.begin()+i);
}
-void MEDFileMeshes::loadFromFile(const char *fileName)
+void MEDFileMeshes::loadFromFile(const std::string& fileName)
{
std::vector<std::string> ms=MEDLoader::GetMeshNames(fileName);
int i=0;
_meshes.resize(ms.size());
for(std::vector<std::string>::const_iterator it=ms.begin();it!=ms.end();it++,i++)
- _meshes[i]=MEDFileMeshMultiTS::New(fileName,(*it).c_str());
+ _meshes[i]=MEDFileMeshMultiTS::New(fileName,(*it));
}
MEDFileMeshes::MEDFileMeshes()
{
}
-MEDFileMeshes::MEDFileMeshes(const char *fileName)
+MEDFileMeshes::MEDFileMeshes(const std::string& fileName)
try
- {
+{
loadFromFile(fileName);
- }
+}
catch(INTERP_KERNEL::Exception& /*e*/)
- {
- }
+{
+}
MEDFileMeshes *MEDFileMeshes::deepCpy() const
{
return _meshes.capacity()*(sizeof(MEDCouplingAutoRefCountObjectPtr<MEDFileMeshMultiTS>));
}
-std::vector<const BigMemoryObject *> MEDFileMeshes::getDirectChildren() const
+std::vector<const BigMemoryObject *> MEDFileMeshes::getDirectChildrenWithNull() const
{
std::vector<const BigMemoryObject *> ret;
for(std::vector< MEDCouplingAutoRefCountObjectPtr<MEDFileMeshMultiTS> >::const_iterator it=_meshes.begin();it!=_meshes.end();it++)
- {
- const MEDFileMeshMultiTS *cur(*it);
- if(cur)
- ret.push_back(cur);
- }
+ ret.push_back((const MEDFileMeshMultiTS *)*it);
return ret;
}
