ModelEvaluatorDefaultBaseTypes::DefaultDerivMvAdjointSupport
ModelEvaluatorDefaultBase<Scalar>::determineDefaultDerivMvAdjointSupport(
const ModelEvaluatorBase::DerivativeSupport &derivSupportImpl,
const VectorSpaceBase<Scalar> &fnc_space,
const VectorSpaceBase<Scalar> &var_space
)
{
typedef ModelEvaluatorBase MEB;
// Here we will support the adjoint copy for of a multi-vector if both
// spaces give rise to in-core vectors.
const bool implSupportsMv =
( derivSupportImpl.supports(MEB::DERIV_MV_BY_COL)
|| derivSupportImpl.supports(MEB::DERIV_TRANS_MV_BY_ROW) );
const bool bothSpacesHaveInCoreViews =
( fnc_space.hasInCoreView() && var_space.hasInCoreView() );
if ( implSupportsMv && bothSpacesHaveInCoreViews ) {
return DefaultDerivMvAdjointSupport(
derivSupportImpl.supports(MEB::DERIV_MV_BY_COL)
? MEB::DERIV_TRANS_MV_BY_ROW
: MEB::DERIV_MV_BY_COL
);
}
// We can't provide an adjoint copy or such a copy is not needed!
return DefaultDerivMvAdjointSupport();
}
bool VectorSpaceTester<Scalar>::check(
const VectorSpaceBase<Scalar> &vs
,Teuchos::FancyOStream *out_arg
) const
{
using std::endl;
using Teuchos::describe;
using Teuchos::FancyOStream;
using Teuchos::OSTab;
typedef Teuchos::ScalarTraits<Scalar> ST;
//typedef typename ST::magnitudeType ScalarMag;
Teuchos::RCP<FancyOStream> out = Teuchos::rcp(out_arg,false);
const Teuchos::EVerbosityLevel verbLevel = (dump_all()?Teuchos::VERB_EXTREME:Teuchos::VERB_MEDIUM);
OSTab tab(out,1,"THYRA");
bool result, success = true;
if(out.get()) *out <<endl<< "*** Entering Thyra::VectorSpaceTester<"<<ST::name()<<">::check(vs,...) ...\n";
if(out.get()) *out <<endl<< "Testing a vector space vs described as:\n" << describe(vs,verbLevel);
if(out.get())
*out
<<endl<< "A) Calling basic query functions ...\n"
<<endl<< "vs.dim() = " << vs.dim()
<<endl<< "vs.hasInCoreView() = " << vs.hasInCoreView() << std::endl;
if(out.get()) *out <<endl<< "B) Checking that vs is compatible with itself ...\n";
if(out.get()) *out <<endl<< "vs.isCompatible(vs)=";
result = vs.isCompatible(vs);
if(!result) success = false;
if(out.get()) *out << result << " == true : " << passfail(result) << std::endl;
if(out.get()) *out <<endl<< "C) Creating a randomized vector member v ...\n";
Teuchos::RCP<Thyra::VectorBase<Scalar> >
v = createMember(vs);
randomize(Scalar(-ST::one()),Scalar(+ST::one()),v.ptr());
if(out.get()) *out <<endl<< "D) Testing the VectorBase interface of v ...\n";
result = vectorTester_.check(*v,out.get());
if(!result) success = false;
if(out.get()) *out <<endl<< "C) Creating a randomized MultiVector member mv ...\n";
Teuchos::RCP<Thyra::MultiVectorBase<Scalar> >
mv = createMembers(vs,num_mv_cols());
randomize(Scalar(-ST::one()),Scalar(+ST::one()),mv.ptr());
if(out.get()) *out <<endl<< "D) Testing the MultiVectorBase interface of mv ...\n";
result = vectorTester_.multiVectorTester().check(*mv, out.ptr());
if(!result) success = false;
if(out.get()) {
if(success)
*out << endl <<"Congratulations, this VectorSpaceBase object seems to check out!\n";
else
*out << endl <<"Oh no, at least one of the tests performed with this VectorSpaceBase object failed (see above failures)!\n";
*out << endl << "*** Leaving VectorSpaceTester<"<<ST::name()<<">::check(vs,...)\n";
}
return success;
}
Teuchos::RCP<const Epetra_Map>
Thyra::get_Epetra_Map(const VectorSpaceBase<double>& vs_in,
const RCP<const Epetra_Comm>& comm)
{
using Teuchos::rcpFromRef;
using Teuchos::rcpFromPtr;
using Teuchos::rcp_dynamic_cast;
using Teuchos::ptrFromRef;
using Teuchos::ptr_dynamic_cast;
const Ptr<const VectorSpaceBase<double> > vs_ptr = ptrFromRef(vs_in);
const Ptr<const SpmdVectorSpaceBase<double> > spmd_vs =
ptr_dynamic_cast<const SpmdVectorSpaceBase<double> >(vs_ptr);
const Ptr<const ProductVectorSpaceBase<double> > &prod_vs =
ptr_dynamic_cast<const ProductVectorSpaceBase<double> >(vs_ptr);
TEUCHOS_TEST_FOR_EXCEPTION( is_null(spmd_vs) && is_null(prod_vs), std::logic_error,
"Error, the concrete VectorSpaceBase object of type "
+Teuchos::demangleName(typeid(vs_in).name())+" does not support the"
" SpmdVectorSpaceBase or the ProductVectorSpaceBase interfaces!" );
const int numBlocks = (nonnull(prod_vs) ? prod_vs->numBlocks() : 1);
// Get an array of SpmdVectorBase objects for the blocks
Array<RCP<const SpmdVectorSpaceBase<double> > > spmd_vs_blocks;
if (nonnull(prod_vs)) {
for (int block_i = 0; block_i < numBlocks; ++block_i) {
const RCP<const SpmdVectorSpaceBase<double> > spmd_vs_i =
rcp_dynamic_cast<const SpmdVectorSpaceBase<double> >(
prod_vs->getBlock(block_i), true);
spmd_vs_blocks.push_back(spmd_vs_i);
}
}
else {
spmd_vs_blocks.push_back(rcpFromPtr(spmd_vs));
}
// Find the number of local elements, summed over all blocks
int myLocalElements = 0;
for (int block_i = 0; block_i < numBlocks; ++block_i) {
myLocalElements += spmd_vs_blocks[block_i]->localSubDim();
}
// Find the GIDs owned by this processor, taken from all blocks
int count=0;
int blockOffset = 0;
Array<int> myGIDs(myLocalElements);
for (int block_i = 0; block_i < numBlocks; ++block_i) {
const RCP<const SpmdVectorSpaceBase<double> > spmd_vs_i = spmd_vs_blocks[block_i];
const int lowGIDInBlock = spmd_vs_i->localOffset();
const int numLocalElementsInBlock = spmd_vs_i->localSubDim();
for (int i=0; i < numLocalElementsInBlock; ++i, ++count) {
myGIDs[count] = blockOffset + lowGIDInBlock + i;
}
blockOffset += spmd_vs_i->dim();
}
const int globalDim = vs_in.dim();
return Teuchos::rcp(
new Epetra_Map(globalDim, myLocalElements, &(myGIDs[0]), 0, *comm));
}
