return new MEDCouplingCMesh;
}
-MEDCouplingCMesh *MEDCouplingCMesh::New(const char *meshName)
+MEDCouplingCMesh *MEDCouplingCMesh::New(const std::string& meshName)
{
MEDCouplingCMesh *ret=new MEDCouplingCMesh;
ret->setName(meshName);
updateTimeWith(*_z_array);
}
-std::size_t MEDCouplingCMesh::getHeapMemorySize() const
+std::size_t MEDCouplingCMesh::getHeapMemorySizeWithoutChildren() const
{
- std::size_t ret=0;
- std::set<DataArrayDouble *> s;
- s.insert(_x_array); s.insert(_y_array); s.insert(_z_array);
- s.erase(NULL);
- for(std::set<DataArrayDouble *>::const_iterator it=s.begin();it!=s.end();it++)
- if(*it)
- ret+=(*it)->getHeapMemorySize();
- return MEDCouplingStructuredMesh::getHeapMemorySize()+ret;
+ return MEDCouplingStructuredMesh::getHeapMemorySizeWithoutChildren();
+}
+
+std::vector<const BigMemoryObject *> MEDCouplingCMesh::getDirectChildren() const
+{
+ std::vector<const BigMemoryObject *> ret;
+ if(_x_array)
+ ret.push_back(_x_array);
+ if(_y_array)
+ ret.push_back(_y_array);
+ if(_z_array)
+ ret.push_back(_z_array);
+ return ret;
}
/*!
* This method copyies all tiny strings from other (name and components name).
* @throw if other and this have not same mesh type.
*/
-void MEDCouplingCMesh::copyTinyStringsFrom(const MEDCouplingMesh *other) throw(INTERP_KERNEL::Exception)
+void MEDCouplingCMesh::copyTinyStringsFrom(const MEDCouplingMesh *other)
{
const MEDCouplingCMesh *otherC=dynamic_cast<const MEDCouplingCMesh *>(other);
if(!otherC)
_z_array->copyStringInfoFrom(*otherC->_z_array);
}
-bool MEDCouplingCMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const throw(INTERP_KERNEL::Exception)
+bool MEDCouplingCMesh::isEqualIfNotWhy(const MEDCouplingMesh *other, double prec, std::string& reason) const
{
if(!other)
throw INTERP_KERNEL::Exception("MEDCouplingCMesh::isEqualIfNotWhy : input other pointer is null !");
throw INTERP_KERNEL::Exception("MEDCouplingCMesh::checkDeepEquivalOnSameNodesWith : other is NOT a cartesian mesh ! Impossible to check equivalence !");
}
-void MEDCouplingCMesh::checkCoherency() const throw(INTERP_KERNEL::Exception)
+void MEDCouplingCMesh::checkCoherency() const
{
const char msg0[]="Invalid ";
const char msg1[]=" array ! Must contain more than 1 element.";
const char msg2[]=" array ! Must be with only one component.";
+ getSpaceDimension();// here to check that no holes in arrays !
if(_x_array)
{
if(_x_array->getNbOfElems()<2)
}
}
-void MEDCouplingCMesh::checkCoherency1(double eps) const throw(INTERP_KERNEL::Exception)
+void MEDCouplingCMesh::checkCoherency1(double eps) const
{
checkCoherency();
if(_x_array)
_z_array->checkMonotonic(true, eps);
}
-void MEDCouplingCMesh::checkCoherency2(double eps) const throw(INTERP_KERNEL::Exception)
+void MEDCouplingCMesh::checkCoherency2(double eps) const
{
checkCoherency1(eps);
}
void MEDCouplingCMesh::getSplitCellValues(int *res) const
{
- int spaceDim=getSpaceDimension();
- for(int l=0;l<spaceDim;l++)
+ int meshDim(getMeshDimension());
+ for(int l=0;l<meshDim;l++)
{
int val=1;
- for(int p=0;p<spaceDim-l-1;p++)
+ for(int p=0;p<meshDim-l-1;p++)
val*=getCoordsAt(p)->getNbOfElems()-1;
- res[spaceDim-l-1]=val;
+ res[meshDim-l-1]=val;
}
}
void MEDCouplingCMesh::getSplitNodeValues(int *res) const
{
- int spaceDim=getSpaceDimension();
+ int spaceDim(getSpaceDimension());
for(int l=0;l<spaceDim;l++)
{
int val=1;
void MEDCouplingCMesh::getNodeGridStructure(int *res) const
{
- int meshDim=getMeshDimension();
- for(int i=0;i<meshDim;i++)
+ int spaceDim(getSpaceDimension());
+ for(int i=0;i<spaceDim;i++)
res[i]=getCoordsAt(i)->getNbOfElems();
}
-std::vector<int> MEDCouplingCMesh::getNodeGridStructure() const throw(INTERP_KERNEL::Exception)
+std::vector<int> MEDCouplingCMesh::getNodeGridStructure() const
{
- std::vector<int> ret(getMeshDimension());
+ std::vector<int> ret(getSpaceDimension());
getNodeGridStructure(&ret[0]);
return ret;
}
-MEDCouplingStructuredMesh *MEDCouplingCMesh::buildStructuredSubPart(const std::vector< std::pair<int,int> >& cellPart) const throw(INTERP_KERNEL::Exception)
+MEDCouplingStructuredMesh *MEDCouplingCMesh::buildStructuredSubPart(const std::vector< std::pair<int,int> >& cellPart) const
{
checkCoherency();
int dim(getMeshDimension());
return ret.retn();
}
+/*!
+ * Return the space dimension of \a this. It only considers the arrays along X, Y and Z to deduce that.
+ * This method throws exceptions if the not null arrays defining this are not contiguouly at the end. For example X!=0,Y==0,Z!=0 will throw.
+ */
int MEDCouplingCMesh::getSpaceDimension() const
{
- int ret=0;
+ static const char MSG[]="MEDCouplingCMesh::getSpaceDimension : mesh is invalid ! null vectors (X, Y or Z) must be put contiguously at the end !";
+ int ret(0);
+ bool isOK(true);
if(_x_array)
ret++;
+ else
+ isOK=false;
if(_y_array)
- ret++;
+ {
+ if(!isOK)
+ throw INTERP_KERNEL::Exception(MSG);
+ ret++;
+ }
+ else
+ isOK=false;
if(_z_array)
- ret++;
+ {
+ if(!isOK)
+ throw INTERP_KERNEL::Exception(MSG);
+ ret++;
+ }
return ret;
}
+/*!
+ * This method returns the mesh dimension of \a this. It can be different from space dimension in case of a not null dimension contains only one node.
+ */
int MEDCouplingCMesh::getMeshDimension() const
{
- return getSpaceDimension();
+ int ret(getSpaceDimension());
+ if(_x_array)
+ {
+ if(_x_array->isAllocated())
+ if(_x_array->getNumberOfTuples()==1)
+ ret--;
+ }
+ if(_y_array)
+ {
+ if(_y_array->isAllocated())
+ if(_y_array->getNumberOfTuples()==1)
+ ret--;
+ }
+ if(_z_array)
+ {
+ if(_z_array->isAllocated())
+ if(_z_array->getNumberOfTuples()==1)
+ ret--;
+ }
+ return ret;
}
-void MEDCouplingCMesh::getCoordinatesOfNode(int nodeId, std::vector<double>& coo) const throw(INTERP_KERNEL::Exception)
+void MEDCouplingCMesh::getCoordinatesOfNode(int nodeId, std::vector<double>& coo) const
{
int tmp[3];
int spaceDim=getSpaceDimension();
* \ref cpp_mccmesh_getCoordsAt "Here is a C++ example".<br>
* \ref py_mccmesh_getCoordsAt "Here is a Python example".
*/
-const DataArrayDouble *MEDCouplingCMesh::getCoordsAt(int i) const throw(INTERP_KERNEL::Exception)
+const DataArrayDouble *MEDCouplingCMesh::getCoordsAt(int i) const
{
switch(i)
{
* \ref cpp_mccmesh_getCoordsAt "Here is a C++ example".<br>
* \ref py_mccmesh_getCoordsAt "Here is a Python example".
*/
-DataArrayDouble *MEDCouplingCMesh::getCoordsAt(int i) throw(INTERP_KERNEL::Exception)
+DataArrayDouble *MEDCouplingCMesh::getCoordsAt(int i)
{
switch(i)
{
* \ref medcouplingcppexamplesCmeshStdBuild1 "Here is a C++ example".<br>
* \ref medcouplingpyexamplesCmeshStdBuild1 "Here is a Python example".
*/
-void MEDCouplingCMesh::setCoordsAt(int i, const DataArrayDouble *arr) throw(INTERP_KERNEL::Exception)
+void MEDCouplingCMesh::setCoordsAt(int i, const DataArrayDouble *arr)
{
if(arr)
arr->checkNbOfComps(1,"MEDCouplingCMesh::setCoordsAt");
name+=getName();
int nbelem=getNumberOfCells();
MEDCouplingFieldDouble *field=MEDCouplingFieldDouble::New(ON_CELLS,ONE_TIME);
- field->setName(name.c_str());
+ field->setName(name);
DataArrayDouble* array=DataArrayDouble::New();
array->alloc(nbelem,1);
double *area_vol=array->getPointer();
for(int j=0;j<spaceDim;j++)
{
tabsPtr[j]=tabs[j]->getConstPointer();
- ret->setInfoOnComponent(j,tabs[j]->getInfoOnComponent(0).c_str());
+ ret->setInfoOnComponent(j,tabs[j]->getInfoOnComponent(0));
}
int tmp2[3];
for(int i=0;i<nbNodes;i++)
for(int j=0;j<spaceDim;j++)
{
int sz=tabs[j]->getNbOfElems()-1;
- ret->setInfoOnComponent(j,tabs[j]->getInfoOnComponent(0).c_str());
+ ret->setInfoOnComponent(j,tabs[j]->getInfoOnComponent(0));
const double *srcPtr=tabs[j]->getConstPointer();
tabsPtr[j].insert(tabsPtr[j].end(),srcPtr,srcPtr+sz);
std::transform(tabsPtr[j].begin(),tabsPtr[j].end(),srcPtr+1,tabsPtr[j].begin(),std::plus<double>());
return ret;
}
-DataArrayDouble *MEDCouplingCMesh::computeIsoBarycenterOfNodesPerCell() const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *MEDCouplingCMesh::computeIsoBarycenterOfNodesPerCell() const
{
return MEDCouplingCMesh::getBarycenterAndOwner();
}
-void MEDCouplingCMesh::renumberCells(const int *old2NewBg, bool check) throw(INTERP_KERNEL::Exception)
+void MEDCouplingCMesh::renumberCells(const int *old2NewBg, bool check)
{
throw INTERP_KERNEL::Exception("Functionnality of renumbering cell not available for CMesh !");
}
void MEDCouplingCMesh::unserialization(const std::vector<double>& tinyInfoD, const std::vector<int>& tinyInfo, const DataArrayInt *a1, DataArrayDouble *a2,
const std::vector<std::string>& littleStrings)
{
- setName(littleStrings[0].c_str());
- setDescription(littleStrings[1].c_str());
- setTimeUnit(littleStrings[2].c_str());
+ setName(littleStrings[0]);
+ setDescription(littleStrings[1]);
+ setTimeUnit(littleStrings[2]);
DataArrayDouble **thisArr[3]={&_x_array,&_y_array,&_z_array};
const double *data=a2->getConstPointer();
for(int i=0;i<3;i++)
{
(*(thisArr[i]))=DataArrayDouble::New();
(*(thisArr[i]))->alloc(tinyInfo[i],1);
- (*(thisArr[i]))->setInfoOnComponent(0,littleStrings[i+3].c_str());
+ (*(thisArr[i]))->setInfoOnComponent(0,littleStrings[i+3]);
std::copy(data,data+tinyInfo[i],(*(thisArr[i]))->getPointer());
data+=tinyInfo[i];
}
setTime(tinyInfoD[0],tinyInfo[3],tinyInfo[4]);
}
-void MEDCouplingCMesh::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData) const throw(INTERP_KERNEL::Exception)
+void MEDCouplingCMesh::writeVTKLL(std::ostream& ofs, const std::string& cellData, const std::string& pointData, DataArrayByte *byteData) const
{
std::ostringstream extent;
DataArrayDouble *thisArr[3]={_x_array,_y_array,_z_array};
for(int i=0;i<3;i++)
{
if(thisArr[i])
- thisArr[i]->writeVTK(ofs,8,"Array");
+ thisArr[i]->writeVTK(ofs,8,"Array",byteData);
else
{
MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coo=DataArrayDouble::New(); coo->alloc(1,1);
coo->setIJ(0,0,0.);
- coo->writeVTK(ofs,8,"Array");
+ coo->writeVTK(ofs,8,"Array",byteData);
}
}
ofs << " </Coordinates>\n";
ofs << " </" << getVTKDataSetType() << ">\n";
}
-void MEDCouplingCMesh::reprQuickOverview(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+void MEDCouplingCMesh::reprQuickOverview(std::ostream& stream) const
{
stream << "MEDCouplingCMesh C++ instance at " << this << ". Name : \"" << getName() << "\".";
const DataArrayDouble *thisArr[3]={_x_array,_y_array,_z_array};
}
-std::string MEDCouplingCMesh::getVTKDataSetType() const throw(INTERP_KERNEL::Exception)
+std::string MEDCouplingCMesh::getVTKDataSetType() const
{
return std::string("RectilinearGrid");
}