/// \brief Compute the explicit Q factor.
///
/// Compute the explicit (multivector) "thin" (same number of
/// columns as the input) representation of the Q factor
/// computed by factor(), using the implicit representation
/// returned by factor().
///
/// \param Q_in [in] Same as the "A" input of factor()
/// \param factorOutput [in] Return value of factor()
/// corresponding to Q_in
/// \param Q_out [out] Explicit "thin" representation of the Q
/// factor. "Explicit" means as a regular matrix (in the same
/// multivector storage format as the "A" input of factor()).
/// "Thin" (terminology used by Golub and Van Loan) means that
/// the dimensions of Q_out are the same as the dimensions of
/// the "A" input of factor().
/// \param contiguousCacheBlocks [in] See the epinonymous
/// argument of factor(). In this case, it applies to both
/// Q_in and Q_out, which must have the same data layout.
///
/// \note Virtual but implemented, because this default
/// implementation is correct for all multivector_type types,
/// but not necessarily efficient. It should be efficient if
/// fetchNonConstView(Q_out) and fetchConstView(Q_in) do not
/// require copying (e.g., from GPU memory to CPU memory) the
/// contents of their respective multivector inputs.
virtual void
explicitQ (const multivector_type& Q_in,
const factor_output_type& factorOutput,
multivector_type& Q_out,
const bool contiguousCacheBlocks = false)
{
using Teuchos::ArrayRCP;
// Lazily init the intranode part of TSQR if necessary.
initNodeTsqr (Q_in);
local_ordinal_type nrowsLocal, ncols_in, LDQ_in;
fetchDims (Q_in, nrowsLocal, ncols_in, LDQ_in);
local_ordinal_type nrowsLocal_out, ncols_out, LDQ_out;
fetchDims (Q_out, nrowsLocal_out, ncols_out, LDQ_out);
if (nrowsLocal_out != nrowsLocal)
{
std::ostringstream os;
os << "TSQR explicit Q: input Q factor\'s node-local part has a di"
"fferent number of rows (" << nrowsLocal << ") than output Q fac"
"tor\'s node-local part (" << nrowsLocal_out << ").";
throw std::runtime_error (os.str());
}
ArrayRCP< const scalar_type > pQin = fetchConstView (Q_in);
ArrayRCP< scalar_type > pQout = fetchNonConstView (Q_out);
pTsqr_->explicit_Q (nrowsLocal,
ncols_in, pQin.get(), LDQ_in,
factorOutput,
ncols_out, pQout.get(), LDQ_out,
contiguousCacheBlocks);
}
// ********************************************************
int main(int argc, char *argv[])
{
using namespace std;
using namespace Teuchos;
using namespace PHX;
GlobalMPISession mpi_session(&argc, &argv);
try {
RCP<Time> total_time = TimeMonitor::getNewTimer("Total Run Time");
TimeMonitor tm(*total_time);
// *********************************************************************
// Start of MDField Testing
// *********************************************************************
{
typedef MDField<double,Cell,Node>::size_type size_type;
std::vector<size_type> dims(3);
dims[0] = 10;
dims[1] = 4;
dims[2] = 3;
RCP<DataLayout> quad_vector =
rcp(new MDALayout<Cell,Quadrature,Dim>(dims[0],dims[1],dims[2]));
int size = quad_vector->size();
TEUCHOS_TEST_FOR_EXCEPTION(size != dims[0]*dims[1]*dims[2], std::runtime_error,
"Size mismatch on MDField!");
ArrayRCP<double> a_mem = arcp<double>(size);
ArrayRCP<double> b_mem = arcp<double>(size);
for (int i=0; i < a_mem.size(); ++i)
a_mem[i] = static_cast<double>(i);
for (int i=0; i < b_mem.size(); ++i)
b_mem[i] = static_cast<double>(i);
MDField<double,Cell,Point,Dim> a("density",quad_vector);
MDField<double> b("density",quad_vector);
a.setFieldData(a_mem);
b.setFieldData(b_mem);
simulated_intrepid_integrate(a);
simulated_intrepid_integrate(b);
// ***********************
// Shards tests
// ***********************
ArrayRCP<double> c_mem = arcp<double>(size);
ArrayRCP<double> d_mem = arcp<double>(size);
for (int i=0; i < c_mem.size(); ++i)
c_mem[i] = static_cast<double>(i);
for (int i=0; i < d_mem.size(); ++i)
d_mem[i] = static_cast<double>(i);
shards::Array<double,shards::NaturalOrder,Cell,Node,Dim> c(c_mem.get(),
dims[0],
dims[1],
dims[2]);
size_type rank = dims.size();
const ArrayRCP<const shards::ArrayDimTag*> tags =
arcp<const shards::ArrayDimTag*>(rank);
tags[0] = &Cell::tag();
tags[1] = &Point::tag();
tags[2] = &Dim::tag();
shards::Array<double,shards::NaturalOrder> d(d_mem.get(),rank,
&dims[0],tags.get());
simulated_intrepid_integrate(d);
simulated_intrepid_integrate((const shards::Array<double,shards::NaturalOrder>&)(c));
}
// *********************************************************************
// *********************************************************************
std::cout << "\nTest passed!\n" << std::endl;
// *********************************************************************
// *********************************************************************
}
catch (const std::exception& e) {
std::cout << "************************************************" << endl;
std::cout << "************************************************" << endl;
std::cout << "Exception Caught!" << endl;
std::cout << "Error message is below\n " << e.what() << endl;
std::cout << "************************************************" << endl;
}
catch (...) {
std::cout << "************************************************" << endl;
std::cout << "************************************************" << endl;
std::cout << "Unknown Exception Caught!" << endl;
std::cout << "************************************************" << endl;
}
TimeMonitor::summarize();
return 0;
}
