void CSRMatrix::create(CSRMatrix::ValueType type, unsigned m, const CSRMap & elms)
{
m_valType = type;
m_dimension = m;
unsigned nnz = elms.size();
m_numNonZero = nnz;
if(type > tIndexOnly) m_value->create(nnz * type);
m_rowPtr->create((m+1) * 4);
m_colInd->create(nnz * 4);
unsigned * I = rowPtr();
unsigned * J = colInd();
unsigned lastRow = m+2;
unsigned row, col;
unsigned ielm = 0;
CSRMap::const_iterator it = elms.begin();
for(; it !=elms.end(); ++it) {
row = it->first/m;
col = it->first%m;
if(row != lastRow) {
I[row] = ielm;
lastRow = row;
}
J[it->second] = col;
ielm++;
}
I[m] = ielm;
}
Matrix<T>& Matrix<T>::operator*=( const qreal& Value )
{
Q_ASSERT(constData() && size());
int srcStride1(bytesPerLine());
int srcStride2(bytesPerElement());
if (type() == CV_64F)
{
Ipp64f* pSrc(reinterpret_cast<Ipp64f*>(data()));
const Ipp64f val(static_cast<const Ipp64f>(Value));
IppStatus status(ippmMul_mc_64f(pSrc, srcStride1, srcStride2,
val,
pSrc, srcStride1, srcStride2, cols(), rows()));
Q_ASSERT(status == ippStsNoErr);
}
else
{
Q_ASSERT(!"CHECK");
const T mulValue(static_cast<const T>(Value));
for (int rowIndex(0); rowIndex < rows(); rowIndex++)
{
T* rowPtr(row(rowIndex));
for (int colIndex(0); colIndex < cols(); colIndex++, rowPtr++)
{
*rowPtr *= mulValue;
}
}
}
return *this;
}
void CudaCSRMatrix::initOnDevice()
{
m_deviceValue->create(numNonZero() * valueType());
m_deviceRowPtr->create((dimension() + 1) * 4);
m_deviceColInd->create(numNonZero() * 4);
m_deviceRowPtr->hostToDevice(rowPtr());
m_deviceColInd->hostToDevice(colInd());
}
GraphType* FinleyDomain::createTrilinosGraph(bool reducedOrder) const
{
index_t myNumTargets;
index_t numTargets;
const index_t* target;
const_TrilinosMap_ptr rowMap;
const_TrilinosMap_ptr colMap;
if (reducedOrder) {
myNumTargets = m_nodes->getNumReducedDegreesOfFreedom();
numTargets = m_nodes->getNumReducedDegreesOfFreedomTargets();
target = m_nodes->borrowTargetReducedDegreesOfFreedom();
rowMap = m_nodes->trilinosReducedRowMap;
colMap = m_nodes->trilinosReducedColMap;
} else {
myNumTargets = m_nodes->getNumDegreesOfFreedom();
numTargets = m_nodes->getNumDegreesOfFreedomTargets();
target = m_nodes->borrowTargetDegreesOfFreedom();
rowMap = m_nodes->trilinosRowMap;
colMap = m_nodes->trilinosColMap;
}
boost::scoped_array<IndexList> indexList(new IndexList[numTargets]);
#pragma omp parallel
{
// insert contributions from element matrices into columns in
// index list
IndexList_insertElements(indexList.get(), m_elements, reducedOrder,
target, reducedOrder, target);
IndexList_insertElements(indexList.get(), m_faceElements,
reducedOrder, target, reducedOrder, target);
IndexList_insertElements(indexList.get(), m_contactElements,
reducedOrder, target, reducedOrder, target);
IndexList_insertElements(indexList.get(), m_points, reducedOrder,
target, reducedOrder, target);
}
Teuchos::ArrayRCP<size_t> rowPtr(myNumTargets + 1);
for (size_t i = 0; i < myNumTargets; i++) {
rowPtr[i+1] = rowPtr[i] + indexList[i].count(0, numTargets);
}
Teuchos::ArrayRCP<LO> colInd(rowPtr[myNumTargets]);
#pragma omp parallel for
for (index_t i = 0; i < myNumTargets; i++) {
indexList[i].toArray(&colInd[rowPtr[i]], 0, numTargets, 0);
std::sort(&colInd[rowPtr[i]], &colInd[rowPtr[i+1]]);
}
GraphType* graph = new GraphType(rowMap, colMap, rowPtr, colInd);
Teuchos::RCP<Teuchos::ParameterList> params = Teuchos::parameterList();
params->set("Optimize Storage", true);
graph->fillComplete(rowMap, rowMap, params);
return graph;
}
unsigned CSRMatrix::maxNNZRow()
{
unsigned i;
unsigned * row = rowPtr();
unsigned mnnzpr = 0;
for(i = 1; i<=m_dimension; i++) {
if(row[i]-row[i-1] > mnnzpr)
mnnzpr = row[i]-row[i-1];
}
return mnnzpr;
}
void CSRMatrix::verbose()
{
unsigned lastRow = m_dimension + 2;
unsigned i, j;
unsigned * row = rowPtr();
j = 0;
for(i=0; i< m_numNonZero; i++) {
if(i == *row) {
std::cout<<"\n row"<<j<<" ("<<*row<<") ";
j++;
row++;
}
std::cout<<" "<<colInd()[i];
}
std::cout<<"\nn non-zero "<<*row<<"\n";
std::cout<<"dimension "<<m_dimension<<"\n";
std::cout<<"value size "<<m_valType<<"\n";
}
void * CSRMatrix::rowValue(unsigned i)
{
char * d = (char *)m_value->data();
return &d[rowPtr()[i] * m_valType];
}
