-// Copyright (C) 2007-2014 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2021 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
// Author : Anthony Geay (CEA/DEN)
#include "MEDCouplingGaussLocalization.hxx"
+#include "InterpKernelGaussCoords.hxx"
+#include "MEDCoupling1GTUMesh.hxx"
+#include "MEDCouplingUMesh.hxx"
#include "CellModel.hxx"
#include <cmath>
#include <iterator>
#include <algorithm>
-ParaMEDMEM::MEDCouplingGaussLocalization::MEDCouplingGaussLocalization(INTERP_KERNEL::NormalizedCellType type, const std::vector<double>& refCoo,
- const std::vector<double>& gsCoo, const std::vector<double>& w) throw(INTERP_KERNEL::Exception)
-try:_type(type),_ref_coord(refCoo),_gauss_coord(gsCoo),_weight(w)
- {
- checkCoherency();
- }
-catch(INTERP_KERNEL::Exception& e)
- {
- _type=INTERP_KERNEL::NORM_ERROR;
- _ref_coord.clear();
- _gauss_coord.clear();
- _weight.clear();
- throw e;
- }
+using namespace MEDCoupling;
-ParaMEDMEM::MEDCouplingGaussLocalization::MEDCouplingGaussLocalization(INTERP_KERNEL::NormalizedCellType typ)
-try:_type(typ)
+MEDCouplingGaussLocalization::MEDCouplingGaussLocalization(INTERP_KERNEL::NormalizedCellType type, const std::vector<double>& refCoo,
+ const std::vector<double>& gsCoo, const std::vector<double>& w)
+:_type(type),_ref_coord(refCoo),_gauss_coord(gsCoo),_weight(w)
{
+ // Will potentially throw (and then release memory for above objects _ref_coord etc ...)
+ checkConsistencyLight();
+}
+
+MEDCouplingGaussLocalization::MEDCouplingGaussLocalization(INTERP_KERNEL::NormalizedCellType typ)
+:_type(typ)
+{
+ // Will potentially throw
INTERP_KERNEL::CellModel::GetCellModel(_type);
}
-catch(INTERP_KERNEL::Exception& e)
- {
- _type=INTERP_KERNEL::NORM_ERROR;
- throw e;
- }
-void ParaMEDMEM::MEDCouplingGaussLocalization::setType(INTERP_KERNEL::NormalizedCellType typ)
+void MEDCouplingGaussLocalization::setType(INTERP_KERNEL::NormalizedCellType typ)
{
INTERP_KERNEL::CellModel::GetCellModel(typ);//throws if not found. This is a check
_type=typ;
}
-void ParaMEDMEM::MEDCouplingGaussLocalization::checkCoherency() const
+void MEDCouplingGaussLocalization::checkConsistencyLight() const
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_type);
int nbNodes=cm.getNumberOfNodes();
int dim=cm.getDimension();
if(!cm.isDynamic())
{
- if((int)_ref_coord.size()!=nbNodes*dim)
+ if(ToIdType(_ref_coord.size())!=nbNodes*dim)
{
std::ostringstream oss; oss << "Invalid size of refCoo : expecting to be : " << nbNodes << " (nbNodePerCell) * " << dim << " (dim) !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
if(_gauss_coord.size()!=dim*_weight.size())
{
- std::ostringstream oss; oss << "Invalid gsCoo size and weight size : gsCoo.size() must be equal to _weight.size() * " << dim << " (dim) !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
+ std::ostringstream oss; oss << "Invalid gsCoo size and weight size : gsCoo.size() must be equal to _weight.size() * " << dim << " (dim) !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
}
}
-int ParaMEDMEM::MEDCouplingGaussLocalization::getDimension() const
+int MEDCouplingGaussLocalization::getDimension() const
{
if(_weight.empty())
return -1;
return (int)_gauss_coord.size()/(int)_weight.size();
}
-int ParaMEDMEM::MEDCouplingGaussLocalization::getNumberOfPtsInRefCell() const
+int MEDCouplingGaussLocalization::getNumberOfPtsInRefCell() const
{
int dim=getDimension();
if(dim==0)
return (int)_ref_coord.size()/dim;
}
-std::string ParaMEDMEM::MEDCouplingGaussLocalization::getStringRepr() const
+std::string MEDCouplingGaussLocalization::getStringRepr() const
{
std::ostringstream oss;
oss << "CellType : " << INTERP_KERNEL::CellModel::GetCellModel(_type).getRepr() << std::endl;
return oss.str();
}
-std::size_t ParaMEDMEM::MEDCouplingGaussLocalization::getMemorySize() const
+std::size_t MEDCouplingGaussLocalization::getMemorySize() const
{
std::size_t ret=0;
ret+=_ref_coord.capacity()*sizeof(double);
return ret;
}
-bool ParaMEDMEM::MEDCouplingGaussLocalization::isEqual(const MEDCouplingGaussLocalization& other, double eps) const
+bool MEDCouplingGaussLocalization::isEqual(const MEDCouplingGaussLocalization& other, double eps) const
{
if(_type!=other._type)
return false;
return true;
}
-double ParaMEDMEM::MEDCouplingGaussLocalization::getRefCoord(int ptIdInCell, int comp) const
+double MEDCouplingGaussLocalization::getRefCoord(int ptIdInCell, int comp) const
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_type);
int nbNodes=cm.getNumberOfNodes();
return _ref_coord[ptIdInCell*dim+comp];
}
-double ParaMEDMEM::MEDCouplingGaussLocalization::getGaussCoord(int gaussPtIdInCell, int comp) const
+double MEDCouplingGaussLocalization::getGaussCoord(int gaussPtIdInCell, int comp) const
{
int dim=checkCoherencyOfRequest(gaussPtIdInCell,comp);
return _gauss_coord[gaussPtIdInCell*dim+comp];
}
-double ParaMEDMEM::MEDCouplingGaussLocalization::getWeight(int gaussPtIdInCell, double newVal) const
+double MEDCouplingGaussLocalization::getWeight(int gaussPtIdInCell, double newVal) const
{
checkCoherencyOfRequest(gaussPtIdInCell,0);
return _weight[gaussPtIdInCell];
* push at the end of tinyInfo its basic serialization info. The size of pushed data is always the same.
* @param tinyInfo inout parameter.
*/
-void ParaMEDMEM::MEDCouplingGaussLocalization::pushTinySerializationIntInfo(std::vector<int>& tinyInfo) const
+void MEDCouplingGaussLocalization::pushTinySerializationIntInfo(std::vector<mcIdType>& tinyInfo) const
{
- tinyInfo.push_back((int)_type);
+ tinyInfo.push_back(ToIdType(_type));
tinyInfo.push_back(getNumberOfPtsInRefCell());
tinyInfo.push_back(getNumberOfGaussPt());
}
* push at the end of tinyInfo its basic serialization info. The size of pushed data is \b NOT always the same contrary to pushTinySerializationIntInfo.
* @param tinyInfo inout parameter.
*/
-void ParaMEDMEM::MEDCouplingGaussLocalization::pushTinySerializationDblInfo(std::vector<double>& tinyInfo) const
+void MEDCouplingGaussLocalization::pushTinySerializationDblInfo(std::vector<double>& tinyInfo) const
{
tinyInfo.insert(tinyInfo.end(),_ref_coord.begin(),_ref_coord.end());
tinyInfo.insert(tinyInfo.end(),_gauss_coord.begin(),_gauss_coord.end());
}
/*!
- * This method operates the exact inverse operation than ParaMEDMEM::MEDCouplingGaussLocalization::pushTinySerializationDblInfo method. This is one of the last step of unserialization process.
+ * This method operates the exact inverse operation than MEDCouplingGaussLocalization::pushTinySerializationDblInfo method. This is one of the last step of unserialization process.
* This method should be called on an object resized by buildNewInstanceFromTinyInfo static method.
* This method takes in argument a pointer 'vals' that point to the begin of double data pushed remotely by pushTinySerializationDblInfo method.
* This method returns the pointer 'vals' with an offset of size what it has been read in this method.
*/
-const double *ParaMEDMEM::MEDCouplingGaussLocalization::fillWithValues(const double *vals)
+const double *MEDCouplingGaussLocalization::fillWithValues(const double *vals)
{
const double *work=vals;
std::copy(work,work+_ref_coord.size(),_ref_coord.begin());
return work;
}
+/*!
+ * Given points in \a ptsInRefCoo in the reference coordinates of \a this (in _ref_coord attribute)
+ * this method computes their coordinates in real world for each cells in \a mesh.
+ * So the returned array will contain nbCells* \a ptsInRefCoo->getNumberOfTuples() tuples and the number of component
+ * will be equal to the dimension of \a this.
+ *
+ * This method ignores Gauss points in \a this and only those in \a ptsInRefCoo are considered here.
+ */
+MCAuto<DataArrayDouble> MEDCouplingGaussLocalization::localizePtsInRefCooForEachCell(const DataArrayDouble *ptsInRefCoo, const MEDCouplingUMesh *mesh) const
+{
+ if(!ptsInRefCoo || !mesh)
+ throw INTERP_KERNEL::Exception("MEDCouplingGaussLocalization::localizePtsInRefCooForEachCell : null pointer !");
+ ptsInRefCoo->checkAllocated();
+ mesh->checkConsistencyLight();
+ //
+ mcIdType nbCells=mesh->getNumberOfCells();
+ const double *coords(mesh->getCoords()->begin());
+ const mcIdType *connI(mesh->getNodalConnectivityIndex()->begin()),*conn(mesh->getNodalConnectivity()->begin());
+ //
+ mcIdType nbPts(ptsInRefCoo->getNumberOfTuples());
+ INTERP_KERNEL::NormalizedCellType typ(getType());
+ int dim(INTERP_KERNEL::CellModel::GetCellModel(typ).getDimension()),outDim(mesh->getSpaceDimension());
+ MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
+ ret->alloc(nbPts*nbCells,outDim);
+ double *retPtr(ret->getPointer());
+ if(dim!=ToIdType(ptsInRefCoo->getNumberOfComponents()))
+ throw INTERP_KERNEL::Exception("MEDCouplingGaussLocalization::localizePtsInRefCooForEachCell : number of components of input coo is not equal to dim of element !");
+ INTERP_KERNEL::GaussCoords calculator;
+ calculator.addGaussInfo(typ,dim, ptsInRefCoo->begin(),nbPts,&_ref_coord[0],getNumberOfPtsInRefCell());
+ //
+ for(mcIdType i=0;i<nbCells;i++,retPtr+=nbPts*outDim)
+ calculator.calculateCoords(getType(),coords,outDim,conn+connI[i]+1,retPtr);
+ return ret;
+}
+
+/*!
+ * This method returns an unstructured mesh that represents the reference cell.
+ */
+MCAuto<MEDCouplingUMesh> MEDCouplingGaussLocalization::buildRefCell() const
+{
+ MCAuto<DataArrayDouble> coo(DataArrayDouble::New());
+ const INTERP_KERNEL::CellModel& cm(INTERP_KERNEL::CellModel::GetCellModel(getType()));
+ if(getDimension()!=ToIdType(cm.getDimension()))
+ throw INTERP_KERNEL::Exception("BuildRefCell : dimension mistmatch !");
+ coo->alloc(cm.getNumberOfNodes(),getDimension());
+ std::copy(_ref_coord.begin(),_ref_coord.end(),coo->getPointer());
+ MCAuto<MEDCoupling1SGTUMesh> ret(MEDCoupling1SGTUMesh::New("",getType()));
+ ret->setCoords(coo);
+ MCAuto<DataArrayIdType> conn(DataArrayIdType::New());
+ conn->alloc(cm.getNumberOfNodes(),1);
+ conn->iota();
+ ret->setNodalConnectivity(conn);
+ return MCAuto<MEDCouplingUMesh>(ret->buildUnstructured());
+}
+
/*!
* This method sets the comp_th component of ptIdInCell_th point coordinate of reference element of type this->_type.
* @throw if not 0<=ptIdInCell<nbOfNodePerCell or if not 0<=comp<dim
*/
-void ParaMEDMEM::MEDCouplingGaussLocalization::setRefCoord(int ptIdInCell, int comp, double newVal)
+void MEDCouplingGaussLocalization::setRefCoord(int ptIdInCell, int comp, double newVal)
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_type);
int nbNodes=cm.getNumberOfNodes();
_ref_coord[ptIdInCell*dim+comp]=newVal;
}
-void ParaMEDMEM::MEDCouplingGaussLocalization::setGaussCoord(int gaussPtIdInCell, int comp, double newVal)
+void MEDCouplingGaussLocalization::setGaussCoord(int gaussPtIdInCell, int comp, double newVal)
{
int dim=checkCoherencyOfRequest(gaussPtIdInCell,comp);
_gauss_coord[gaussPtIdInCell*dim+comp]=newVal;
}
-void ParaMEDMEM::MEDCouplingGaussLocalization::setWeight(int gaussPtIdInCell, double newVal)
+void MEDCouplingGaussLocalization::setWeight(int gaussPtIdInCell, double newVal)
{
checkCoherencyOfRequest(gaussPtIdInCell,0);
_weight[gaussPtIdInCell]=newVal;
}
-void ParaMEDMEM::MEDCouplingGaussLocalization::setRefCoords(const std::vector<double>& refCoo)
+void MEDCouplingGaussLocalization::setRefCoords(const std::vector<double>& refCoo)
{
_ref_coord=refCoo;
}
-void ParaMEDMEM::MEDCouplingGaussLocalization::setGaussCoords(const std::vector<double>& gsCoo)
+void MEDCouplingGaussLocalization::setGaussCoords(const std::vector<double>& gsCoo)
{
_gauss_coord=gsCoo;
}
-void ParaMEDMEM::MEDCouplingGaussLocalization::setWeights(const std::vector<double>& w)
+void MEDCouplingGaussLocalization::setWeights(const std::vector<double>& w)
{
_weight=w;
}
/*!
- * The format of 'tinyData' parameter is the same than pushed in method ParaMEDMEM::MEDCouplingGaussLocalization::pushTinySerializationIntInfo.
+ * The format of 'tinyData' parameter is the same than pushed in method MEDCouplingGaussLocalization::pushTinySerializationIntInfo.
*/
-ParaMEDMEM::MEDCouplingGaussLocalization ParaMEDMEM::MEDCouplingGaussLocalization::BuildNewInstanceFromTinyInfo(int dim, const std::vector<int>& tinyData)
+MEDCouplingGaussLocalization MEDCouplingGaussLocalization::BuildNewInstanceFromTinyInfo(mcIdType dim, const std::vector<mcIdType>& tinyData)
{
std::vector<double> v1(dim*tinyData[1]),v2(dim*tinyData[2]),v3(tinyData[2]);
- return ParaMEDMEM::MEDCouplingGaussLocalization((INTERP_KERNEL::NormalizedCellType)tinyData[0],v1,v2,v3);
+ return MEDCouplingGaussLocalization((INTERP_KERNEL::NormalizedCellType)tinyData[0],v1,v2,v3);
}
-int ParaMEDMEM::MEDCouplingGaussLocalization::checkCoherencyOfRequest(int gaussPtIdInCell, int comp) const
+int MEDCouplingGaussLocalization::checkCoherencyOfRequest(mcIdType gaussPtIdInCell, int comp) const
{
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(_type);
int dim=cm.getDimension();
- int nbGsPts=getNumberOfGaussPt();
+ mcIdType nbGsPts=getNumberOfGaussPt();
if(gaussPtIdInCell<0 || gaussPtIdInCell>=nbGsPts)
throw INTERP_KERNEL::Exception("gaussPtIdInCell specified is invalid : must be in [0:nbGsPts) !");
if(comp<0 || comp>=dim)
return dim;
}
-bool ParaMEDMEM::MEDCouplingGaussLocalization::AreAlmostEqual(const std::vector<double>& v1, const std::vector<double>& v2, double eps)
+bool MEDCouplingGaussLocalization::AreAlmostEqual(const std::vector<double>& v1, const std::vector<double>& v2, double eps)
{
std::size_t sz=v1.size();
if(sz!=v2.size())
return false;
std::vector<double> tmp(sz);
std::transform(v1.begin(),v1.end(),v2.begin(),tmp.begin(),std::minus<double>());
- std::transform(tmp.begin(),tmp.end(),tmp.begin(),std::ptr_fun<double,double>(fabs));
+ std::transform(tmp.begin(),tmp.end(),tmp.begin(),[](double c){return fabs(c);});
return *std::max_element(tmp.begin(),tmp.end())<eps;
}
