//----------------------------------------------------------------------------
int VectorReducer::sumInFieldData(int fieldID,
int idType,
int numIDs,
const int* IDs,
const double* data,
int vectorIndex)
{
fei::SharedPtr<fei::VectorSpace> vspace = target_->getVectorSpace();
int fieldSize = vspace->getFieldSize(fieldID);
int numIndices = numIDs*fieldSize;
std::vector<int> indices(numIndices);
int err = vspace->getGlobalIndices(numIDs, IDs, idType, fieldID, &indices[0]);
if (err != 0) {
throw std::runtime_error("fei::VectorReducer::sumInFieldData ERROR in vspace->getGlobalIndices.");
}
return(sumIn(numIndices, &indices[0], data, vectorIndex));
}
int
MatrixReducer::sumIn(int blockID, int connectivityID,
const double* const* values,
int format)
{
fei::SharedPtr<fei::MatrixGraph> matGraph = getMatrixGraph();
int numRowIndices, numColIndices, dummy;
matGraph->getConnectivityNumIndices(blockID, numRowIndices, numColIndices);
std::vector<int> indices(numRowIndices+numColIndices);
int* rowIndices = &indices[0];
int* colIndices = rowIndices+numRowIndices;
matGraph->getConnectivityIndices(blockID, connectivityID,
numRowIndices, rowIndices, dummy,
numColIndices, colIndices, dummy);
return(sumIn(numRowIndices, rowIndices, numColIndices, colIndices,
values, format));
}
fei::Vector_Impl<T>::Vector_Impl(fei::SharedPtr<fei::VectorSpace> vecSpace,
T* vector, int numLocalEqns,
bool isSolutionVector,
bool deleteVector)
: Vector_core(vecSpace, numLocalEqns),
vector_(vector),
isSolution_(isSolutionVector),
deleteVector_(deleteVector),
localProc_(0),
numProcs_(1),
dbgprefix_("VecImpl: ")
{
if (strcmp(snl_fei::FEVectorTraits<T>::typeName(), "unsupported")) {
setFEVector(true);
}
else {
setFEVector(false);
}
localProc_ = fei::localProc(vecSpace->getCommunicator());
numProcs_ = fei::numProcs(vecSpace->getCommunicator());
if (output_level_ >= fei::BRIEF_LOGS && output_stream_ != NULL) {
FEI_OSTREAM& os = *output_stream_;
os << dbgprefix_<<" ctor, numLocalEqns="<<numLocalEqns
<<", typeName: "<<typeName()<<FEI_ENDL;
}
std::vector<int> idTypes;
vecSpace->getIDTypes(idTypes);
std::vector<int> eqns;
std::vector<double> zeros;
for(size_t i=0; i<idTypes.size(); ++i) {
int idType = idTypes[i];
fei::SharedIDs<int>& sharedIDs = vecSpace->getSharedIDs(idType);
const fei::SharedIDs<int>::map_type& idMap = sharedIDs.getSharedIDs();
fei::SharedIDs<int>::map_type::const_iterator
iter = idMap.begin(), iterEnd = idMap.end();
for(; iter!=iterEnd; ++iter) {
int ID = iter->first;
int eqn;
vecSpace->getGlobalIndex(idType, ID, eqn);
int ndof = vecSpace->getNumDegreesOfFreedom(idType, ID);
eqns.resize(ndof);
zeros.resize(ndof, 0.0);
for(int j=0; j<ndof; ++j) eqns[j] = eqn+j;
if (!isSolutionVector) {
sumIn(ndof, &eqns[0], &zeros[0]);
}
else {
copyIn(ndof, &eqns[0], &zeros[0]);
}
}
}
setCommSizes();
std::vector<CSVec*>& remoteVecs = remotelyOwned();
for(size_t i=0; i<remoteVecs.size(); ++i) {
remoteVecs[i]->clear();
}
}
