INTERP_KERNEL::NormalizedCellType MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension(int meshDim)
{
switch(meshDim)
- {
+ {
case 3:
return INTERP_KERNEL::NORM_HEXA8;
case 2:
return INTERP_KERNEL::NORM_POINT1;
default:
throw INTERP_KERNEL::Exception("Unexpected dimension for MEDCouplingStructuredMesh::GetGeoTypeGivenMeshDimension !");
- }
+ }
}
std::set<INTERP_KERNEL::NormalizedCellType> MEDCouplingStructuredMesh::getAllGeoTypes() const
int tmp2[3];
GetPosFromId(cellId,meshDim,tmpCell,tmp2);
switch(meshDim)
- {
+ {
case 1:
conn.push_back(tmp2[0]); conn.push_back(tmp2[0]+1);
break;
break;
default:
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::getNodeIdsOfCell : big problem spacedim must be in 1,2 or 3 !");
- };
+ };
+}
+
+/*!
+ * 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 MEDCouplingStructuredMesh::getMeshDimension() const
+{
+ std::vector<int> ngs(getNodeGridStructure());
+ int ret(0),pos(0);
+ for(std::vector<int>::const_iterator it=ngs.begin();it!=ngs.end();it++,pos++)
+ {
+ if(*it<=0)
+ {
+ std::ostringstream oss; oss << "MEDCouplingStructuredMesh::getMeshDimension : At pos #" << pos << " number of nodes is " << *it << " ! Must be > 0 !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ if(*it>1)
+ ret++;
+ }
+ return ret;
+}
+
+/*!
+ * This method returns the space dimension by only considering the node grid structure.
+ * For cartesian mesh the returned value is equal to those returned by getSpaceDimension.
+ * But for curvelinear is could be different !
+ */
+int MEDCouplingStructuredMesh::getSpaceDimensionOnNodeStruct() const
+{
+ std::vector<int> nodeStr(getNodeGridStructure());
+ int spd1(0),pos(0);
+ for(std::vector<int>::const_iterator it=nodeStr.begin();it!=nodeStr.end();it++,pos++)
+ {
+ int elt(*it);
+ if(elt<=0)
+ {
+ std::ostringstream oss; oss << "MEDCouplingStructuredMesh::getSpaceDimensionOnNodeStruct : At pos #" << pos << " value of node grid structure is " << *it << " ! must be >=1 !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ spd1++;
+ }
+ return spd1;
}
/*!
*/
MEDCoupling1SGTUMesh *MEDCouplingStructuredMesh::build1SGTUnstructured() const
{
- int meshDim(getMeshDimension());
- if(meshDim<0 || meshDim>3)
- throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::build1SGTUnstructured : meshdim must be in [1,2,3] !");
+ int meshDim(getMeshDimension()),spaceDim(getSpaceDimensionOnNodeStruct());
+ if((meshDim<0 || meshDim>3) || (spaceDim<0 || spaceDim>3))
+ throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::build1SGTUnstructured : meshdim and spacedim must be in [1,2,3] !");
MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coords(getCoordinatesAndOwner());
int ns[3];
getNodeGridStructure(ns);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> conn(Build1GTNodalConnectivity(ns,ns+meshDim));
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> conn(Build1GTNodalConnectivity(ns,ns+spaceDim));
MEDCouplingAutoRefCountObjectPtr<MEDCoupling1SGTUMesh> ret(MEDCoupling1SGTUMesh::New(getName(),GetGeoTypeGivenMeshDimension(meshDim)));
ret->setNodalConnectivity(conn); ret->setCoords(coords);
return ret.retn();
*/
DataArrayInt *MEDCouplingStructuredMesh::Build1GTNodalConnectivity(const int *nodeStBg, const int *nodeStEnd)
{
- std::size_t dim(std::distance(nodeStBg,nodeStEnd));
+ int zippedNodeSt[3];
+ int dim(ZipNodeStructure(nodeStBg,nodeStEnd,zippedNodeSt));
switch(dim)
- {
+ {
case 0:
{
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> conn(DataArrayInt::New());
return conn.retn();
}
case 1:
- return Build1GTNodalConnectivity1D(nodeStBg);
+ return Build1GTNodalConnectivity1D(zippedNodeSt);
case 2:
- return Build1GTNodalConnectivity2D(nodeStBg);
+ return Build1GTNodalConnectivity2D(zippedNodeSt);
case 3:
- return Build1GTNodalConnectivity3D(nodeStBg);
+ return Build1GTNodalConnectivity3D(zippedNodeSt);
default:
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::Build1GTNodalConnectivity : only dimension in [0,1,2,3] supported !");
- }
+ }
}
DataArrayInt *MEDCouplingStructuredMesh::Build1GTNodalConnectivityOfSubLevelMesh(const int *nodeStBg, const int *nodeStEnd)
{
std::size_t dim(std::distance(nodeStBg,nodeStEnd));
switch(dim)
- {
+ {
case 3:
return Build1GTNodalConnectivityOfSubLevelMesh3D(nodeStBg);
case 2:
return Build1GTNodalConnectivityOfSubLevelMesh2D(nodeStBg);
default:
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::Build1GTNodalConnectivityOfSubLevelMesh: only dimension in [2,3] supported !");
- }
+ }
}
DataArrayInt *MEDCouplingStructuredMesh::Build1GTNodalConnectivity1D(const int *nodeStBg)
cp[4*pos+1]=i+j*(n1+1);
cp[4*pos+2]=i+(j+1)*(n1+1);
cp[4*pos+3]=i+1+(j+1)*(n1+1);
- }
+ }
return conn.retn();
}
return conn.retn();
}
+/*!
+ * This method computes given the nodal structure defined by [ \a nodeStBg , \a nodeStEnd ) the zipped form.
+ * std::distance( \a nodeStBg, \a nodeStEnd ) is equal to the space dimension. The returned value is equal to
+ * the meshDimension (or the zipped spaceDimension).
+ *
+ * \param [out] zipNodeSt - The zipped node strucutre
+ * \return int - the
+ */
+int MEDCouplingStructuredMesh::ZipNodeStructure(const int *nodeStBg, const int *nodeStEnd, int zipNodeSt[3])
+{
+ int spaceDim((int)std::distance(nodeStBg,nodeStEnd));
+ if(spaceDim>3 || spaceDim<1)
+ throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::ZipNodeStructure : spaceDim must in [1,2,3] !");
+ zipNodeSt[0]=0; zipNodeSt[1]=0; zipNodeSt[2]=0;
+ int zippedI(0);
+ for(int i=0;i<spaceDim;i++)
+ {
+ int elt(nodeStBg[i]);
+ if(elt<1)
+ {
+ std::ostringstream oss; oss << "MEDCouplingStructuredMesh::ZipNodeStructure : the input nodal structure at pos#" << i << "(" << nodeStBg[i] << ") is invalid !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ if(elt>=2)
+ zipNodeSt[zippedI++]=elt;
+ }
+ return zippedI;
+}
+
DataArrayInt *MEDCouplingStructuredMesh::Build1GTNodalConnectivityOfSubLevelMesh2D(const int *nodeStBg)
{
std::vector<int> ngs(2);
return std::accumulate(tmp,tmp+spaceDim,0);
}
+
+int MEDCouplingStructuredMesh::getNumberOfCells() const
+{
+ std::vector<int> ngs(getNodeGridStructure());
+ int ret(1);
+ bool isCatched(false);
+ std::size_t ii(0);
+ for(std::vector<int>::const_iterator it=ngs.begin();it!=ngs.end();it++,ii++)
+ {
+ int elt(*it);
+ if(elt<=0)
+ {
+ std::ostringstream oss; oss << "MEDCouplingStructuredMesh::getNumberOfCells : at pos #" << ii << " the number of nodes in nodeStructure is " << *it << " ! Must be > 0 !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ if(elt>1)
+ {
+ ret*=elt-1;
+ isCatched=true;
+ }
+ }
+ return isCatched?ret:0;
+}
+
+int MEDCouplingStructuredMesh::getNumberOfNodes() const
+{
+ std::vector<int> ngs(getNodeGridStructure());
+ int ret(1);
+ for(std::vector<int>::const_iterator it=ngs.begin();it!=ngs.end();it++)
+ ret*=*it;
+ return ret;
+}
+
void MEDCouplingStructuredMesh::GetPosFromId(int nodeId, int meshDim, const int *split, int *res)
{
int work=nodeId;
return false;
const int *w(startIds);
switch(dim)
- {
+ {
case 3:
{
for(int i=0;i<tmp4[2];i++)
}
default:
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::IsPartStructured : internal error !");
- }
+ }
}
/*!
ret->alloc(nbOfItems,1);
int *pt(ret->getPointer());
switch(st.size())
- {
+ {
case 3:
{
for(int i=0;i<dims[2];i++)
}
default:
throw INTERP_KERNEL::Exception("MEDCouplingStructuredMesh::BuildExplicitIdsFrom : Dimension supported are 1,2 or 3 !");
- }
+ }
return ret.retn();
}
