/*!
Find position of element in a grid as well as its type (domain, axis, scalar) and position in its own element list
\return element position: map<int,<int,int> > corresponds to <element position in grid, <element type, element position in element list> >
*/
std::map<int,std::pair<int,int> > CGridTransformation::getElementPosition(CGrid* grid)
{
std::vector<CScalar*> scalarListP = grid->getScalars();
std::vector<CAxis*> axisListP = grid->getAxis();
std::vector<CDomain*> domListP = grid->getDomains();
CArray<int,1> axisDomainOrder = grid->axis_domain_order;
int scalarIndex = 0, axisIndex = 0, domainIndex = 0;
int nbElement = axisDomainOrder.numElements(), elementDim;
std::map<int,std::pair<int,int> > elementPosition;
for (int idx = 0; idx < nbElement; ++idx)
{
elementDim = axisDomainOrder(idx);
switch (elementDim)
{
case 2:
elementPosition[idx] = std::make_pair(elementDim, domainIndex);
++domainIndex;
break;
case 1:
elementPosition[idx] = std::make_pair(elementDim, axisIndex);
++axisIndex;
break;
case 0:
elementPosition[idx] = std::make_pair(elementDim, scalarIndex);
++scalarIndex;
break;
default:
break;
}
}
return elementPosition;
}
void CMinimum::apply(const CArray<double,1>& _dinput,
CArray<double,1>& _doutput)
{
const double * it1 = _dinput.dataFirst(),
*end1 = _dinput.dataFirst() + _dinput.numElements();
double * it = _doutput.dataFirst();
if (this->nbcall == 1) for (; it1 != end1; it1++, it++) *it = *it1;
else
{
if (hasMissingValue)
{
for (; it1 != end1; it1++, it++)
if (!NumTraits<double>::isnan(*it1))
{
if (!NumTraits<double>::isnan(*it)) *it = std::min(*it1, *it);
else *it=*it1 ;
}
}
else for (; it1 != end1; it1++, it++) *it = std::min(*it1, *it);
}
}
/*!
Assign the current grid destination to the grid source in the new transformation.
The current grid destination plays the role of grid source in next transformation (if any).
Only element on which the transformation is performed is modified
\param [in] elementPositionInGrid position of element in grid
\param [in] transType transformation type
*/
void CGridTransformation::setUpGridSource(int elementPositionInGrid)
{
if (!tempGridSrcs_.empty() && (getNbAlgo()-1) == tempGridSrcs_.size())
{
tempGridSrcs_.resize(0);
}
std::vector<CScalar*> scalarListDestP = tmpGridDestination_->getScalars();
std::vector<CScalar*> scalarListSrcP = gridSource_->getScalars(), scalarSrc;
std::vector<CAxis*> axisListDestP = tmpGridDestination_->getAxis();
std::vector<CAxis*> axisListSrcP = gridSource_->getAxis(), axisSrc;
std::vector<CDomain*> domListDestP = tmpGridDestination_->getDomains();
std::vector<CDomain*> domListSrcP = gridSource_->getDomains(), domainSrc;
CArray<int,1> axisDomainOrderSrc = gridSource_->axis_domain_order;
CArray<int,1> axisDomainOrderDst = tmpGridDestination_->axis_domain_order;
std::map<int,std::pair<int,int> > elementPositionSrc = getElementPosition(gridSource_);
std::map<int,std::pair<int,int> > elementPositionDst = getElementPosition(tmpGridDestination_);
for (int idx = 0; idx < axisDomainOrderDst.numElements(); ++idx)
{
if (elementPositionInGrid == idx)
{
int dimElementDst = elementPositionDst[idx].first;
int elementIndex = elementPositionDst[idx].second;
if (2 == dimElementDst)
{
CDomain* domain = CDomain::createDomain();
domain->domain_ref.setValue(domListDestP[elementIndex]->getId());
domain->solveRefInheritance(true);
domain->checkAttributesOnClient();
domainSrc.push_back(domain);
}
else if (1 == dimElementDst)
{
CAxis* axis = CAxis::createAxis();
axis->axis_ref.setValue(axisListDestP[elementIndex]->getId());
axis->solveRefInheritance(true);
axis->checkAttributesOnClient();
axisSrc.push_back(axis);
}
else
{
CScalar* scalar = CScalar::createScalar();
scalar->scalar_ref.setValue(scalarListDestP[elementIndex]->getId());
scalar->solveRefInheritance(true);
scalar->checkAttributesOnClient();
scalarSrc.push_back(scalar);
}
}
else
{
int dimElementDst = elementPositionDst[idx].first;
int elementIndex = elementPositionDst[idx].second;
switch (dimElementDst)
{
case 2:
domainSrc.push_back(domListDestP[elementIndex]);
break;
case 1:
axisSrc.push_back(axisListDestP[elementIndex]);
break;
case 0:
scalarSrc.push_back(scalarListDestP[elementIndex]);
break;
default:
break;
}
}
}
gridSource_ = CGrid::createGrid(domainSrc, axisSrc, scalarSrc, tmpGridDestination_->axis_domain_order);
tempGridSrcs_.push_back(gridSource_);
}
/*!
If there are more than one transformation, a new temporary grid will be created and it will play the role of grid destination.
This new created one keeps a pointer to the real transformed element of grid destination and generate new copies of other elements from grid source.
\param [in] elementPositionInGrid position of element in grid
\param [in] transType transformation type
*/
void CGridTransformation::setUpGridDestination(int elementPositionInGrid, ETranformationType transType)
{
if (isSpecialTransformation(transType)) return;
if (!tempGridDests_.empty() && (getNbAlgo() == tempGridDests_.size()))
{
tempGridDests_.resize(0);
}
if (1 == getNbAlgo())
{
tmpGridDestination_ = gridDestination_;
return;
}
std::vector<CScalar*> scalarListDestP = gridDestination_->getScalars();
std::vector<CScalar*> scalarListSrcP = gridSource_->getScalars(), scalarDst;
std::vector<CAxis*> axisListDestP = gridDestination_->getAxis();
std::vector<CAxis*> axisListSrcP = gridSource_->getAxis(), axisDst;
std::vector<CDomain*> domListDestP = gridDestination_->getDomains();
std::vector<CDomain*> domListSrcP = gridSource_->getDomains(), domainDst;
CArray<int,1> axisDomainOrderSrc = gridSource_->axis_domain_order;
CArray<int,1> axisDomainOrderDst = gridDestination_->axis_domain_order;
std::map<int,std::pair<int,int> > elementPositionSrc = getElementPosition(gridSource_);
std::map<int,std::pair<int,int> > elementPositionDst = getElementPosition(gridDestination_);
CArray<int,1> elementOrder(axisDomainOrderDst.numElements());
for (int idx = 0; idx < axisDomainOrderDst.numElements(); ++idx)
{
if (elementPositionInGrid == idx)
{
int dimElementDst = elementPositionDst[idx].first;
int elementIndex = elementPositionDst[idx].second;
switch (dimElementDst)
{
case 2:
domainDst.push_back(domListDestP[elementIndex]);
break;
case 1:
axisDst.push_back(axisListDestP[elementIndex]);
break;
case 0:
scalarDst.push_back(scalarListDestP[elementIndex]);
break;
default:
break;
}
elementOrder(idx) = dimElementDst;
}
else
{
int dimElementSrc = elementPositionSrc[idx].first;
int elementIndex = elementPositionSrc[idx].second;
switch (dimElementSrc)
{
case 2:
domainDst.push_back(domListSrcP[elementIndex]);
break;
case 1:
axisDst.push_back(axisListSrcP[elementIndex]);
break;
case 0:
scalarDst.push_back(scalarListSrcP[elementIndex]);
break;
default:
break;
}
elementOrder(idx) = dimElementSrc;
}
}
tmpGridDestination_ = CGrid::createGrid(domainDst, axisDst, scalarDst, elementOrder);
tempGridDests_.push_back(tmpGridDestination_);
}
CDistribution::CDistribution(int rank, int dims, const CArray<size_t,1>& globalIndex)
: rank_(rank), dims_(dims), globalIndex_(globalIndex.shape())
{
if (0 != globalIndex.numElements())
globalIndex_ = globalIndex;
}
