void Ifpack2Smoother<Scalar, LocalOrdinal, GlobalOrdinal, Node>::SetupLineSmoothing(Level& currentLevel) {
if (this->IsSetup() == true)
this->GetOStream(Warnings0) << "MueLu::Ifpack2Smoother::Setup(): Setup() has already been called" << std::endl;
ParameterList& myparamList = const_cast<ParameterList&>(this->GetParameterList());
LO CoarseNumZLayers = Factory::Get<LO>(currentLevel,"CoarseNumZLayers");
if (CoarseNumZLayers > 0) {
Teuchos::ArrayRCP<LO> TVertLineIdSmoo = Factory::Get< Teuchos::ArrayRCP<LO> >(currentLevel, "LineDetection_VertLineIds");
// determine number of local parts
LO maxPart = 0;
for(size_t k = 0; k < Teuchos::as<size_t>(TVertLineIdSmoo.size()); k++) {
if(maxPart < TVertLineIdSmoo[k]) maxPart = TVertLineIdSmoo[k];
}
size_t numLocalRows = A_->getNodeNumRows();
TEUCHOS_TEST_FOR_EXCEPTION(numLocalRows % TVertLineIdSmoo.size() != 0, Exceptions::RuntimeError,
"MueLu::Ifpack2Smoother::Setup(): the number of local nodes is incompatible with the TVertLineIdsSmoo.");
if (numLocalRows == Teuchos::as<size_t>(TVertLineIdSmoo.size())) {
myparamList.set("partitioner: type","user");
myparamList.set("partitioner: map",TVertLineIdSmoo);
myparamList.set("partitioner: local parts",maxPart+1);
} else {
// we assume a constant number of DOFs per node
size_t numDofsPerNode = numLocalRows / TVertLineIdSmoo.size();
// Create a new Teuchos::ArrayRCP<LO> of size numLocalRows and fill it with the corresponding information
Teuchos::ArrayRCP<LO> partitionerMap(numLocalRows, Teuchos::OrdinalTraits<LocalOrdinal>::invalid());
for (size_t blockRow = 0; blockRow < Teuchos::as<size_t>(TVertLineIdSmoo.size()); ++blockRow)
for (size_t dof = 0; dof < numDofsPerNode; dof++)
partitionerMap[blockRow * numDofsPerNode + dof] = TVertLineIdSmoo[blockRow];
myparamList.set("partitioner: type","user");
myparamList.set("partitioner: map",partitionerMap);
myparamList.set("partitioner: local parts",maxPart + 1);
}
if (type_ == "LINESMOOTHING_BANDED_RELAXATION" ||
type_ == "LINESMOOTHING_BANDED RELAXATION" ||
type_ == "LINESMOOTHING_BANDEDRELAXATION")
type_ = "BANDEDRELAXATION";
else
type_ = "BLOCKRELAXATION";
} else {
// line detection failed -> fallback to point-wise relaxation
this->GetOStream(Runtime0) << "Line detection failed: fall back to point-wise relaxation" << std::endl;
myparamList.remove("partitioner: type",false);
myparamList.remove("partitioner: map", false);
myparamList.remove("partitioner: local parts",false);
type_ = "RELAXATION";
}
RCP<const Tpetra::RowMatrix<SC, LO, GO, NO> > tpA = Utilities::Op2NonConstTpetraRow(A_);
prec_ = Ifpack2::Factory::create(type_, tpA, overlap_);
SetPrecParameters();
prec_->initialize();
prec_->compute();
}
bool Tpetra::Utils::parseRfmt(Teuchos::ArrayRCP<char> fmt, int &perline, int &width, int &prec, char &valformat) {
TEUCHOS_TEST_FOR_EXCEPT(fmt.size() != 0 && fmt[fmt.size()-1] != '\0');
std::transform(fmt.begin(), fmt.end(), fmt, static_cast < int(*)(int) > (std::toupper));
// find the first left paren '(' and the last right paren ')'
Teuchos::ArrayRCP<char>::iterator firstLeftParen = std::find( fmt.begin(), fmt.end(), '(');
Teuchos::ArrayRCP<char>::iterator lastRightParen = std::find(std::reverse_iterator<Teuchos::ArrayRCP<char>::iterator>(fmt.end()),
std::reverse_iterator<Teuchos::ArrayRCP<char>::iterator>(fmt.begin()),
')').base()-1;
// select the substring between the parens, including them
// if neither was found, set the string to empty
if (firstLeftParen == fmt.end() || lastRightParen == fmt.begin()) {
fmt.resize(0 + 1);
fmt[0] = '\0';
}
else {
fmt += (firstLeftParen - fmt.begin());
size_t newLen = lastRightParen - firstLeftParen + 1;
fmt.resize(newLen + 1);
fmt[newLen] = '\0';
}
if (std::find(fmt.begin(),fmt.end(),'P') != fmt.end()) {
// not supported
return true;
}
bool error = true;
if (std::sscanf(fmt.getRawPtr(),"(%d%c%d.%d)",&perline,&valformat,&width,&prec) == 4) {
if (valformat == 'E' || valformat == 'D' || valformat == 'F') {
error = false;
}
}
return error;
}
bool Tpetra::Utils::parseIfmt(Teuchos::ArrayRCP<char> fmt, int &perline, int &width) {
TEUCHOS_TEST_FOR_EXCEPT(fmt.size() != 0 && fmt[fmt.size()-1] != '\0');
// parses integers n and d out of (nId)
bool error = true;
std::transform(fmt.begin(), fmt.end(), fmt, static_cast < int(*)(int) > (std::toupper));
if (std::sscanf(fmt.getRawPtr(),"(%dI%d)",&perline,&width) == 2) {
error = false;
}
return error;
}
void writeToScreen(std::ostream & os,const Thyra::VectorBase<double> & src)
{
const Thyra::SpmdVectorBase<double> & spmdSrc =
Teuchos::dyn_cast<const Thyra::SpmdVectorBase<double> >(src);
// get access to data
Teuchos::ArrayRCP<const double> srcData;
spmdSrc.getLocalData(Teuchos::ptrFromRef(srcData));
os << "Local Size = " << srcData.size() << std::endl;
for (int i=0; i < srcData.size(); ++i) {
os << " " << srcData[i] << std::endl;
}
}
void
Albany::HMCProblem::
buildProblem(
Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct>> meshSpecs,
Albany::StateManager& stateMgr)
{
/* Construct All Phalanx Evaluators */
TEUCHOS_TEST_FOR_EXCEPTION(meshSpecs.size()!=1,std::logic_error,"Problem supports one Material Block");
fm.resize(1);
fm[0] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>);
buildEvaluators(*fm[0], *meshSpecs[0], stateMgr, BUILD_RESID_FM,
Teuchos::null);
if(meshSpecs[0]->nsNames.size() > 0) // Build a nodeset evaluator if nodesets are present
constructDirichletEvaluators(*meshSpecs[0]);
if(meshSpecs[0]->ssNames.size() > 0) // Build a sideset evaluator if sidesets are present
constructNeumannEvaluators(meshSpecs[0]);
#ifdef ALBANY_ATO
if( params->isType<Teuchos::RCP<ATO::Topology>>("Topology") )
setupTopOpt(meshSpecs,stateMgr);
#endif
}
DataTransferKit::FieldContainer<double>
MultiAppDTKUserObjectEvaluator::evaluate(const Teuchos::ArrayRCP<GlobalOrdinal>& bids, const Teuchos::ArrayRCP<double>& coords)
{
Teuchos::RCP<const Teuchos::Comm<int> > comm = Teuchos::rcp(new Teuchos::MpiComm<int>(Teuchos::rcp(new Teuchos::OpaqueWrapper<MPI_Comm>(libMesh::COMM_WORLD))));
int num_values = bids.size();
Teuchos::ArrayRCP<double> evaluated_data(num_values);
unsigned int dim = 3; // TODO: REPLACE ME!!!!!!!!!
for (GlobalOrdinal i=0; i<num_values; i++)
{
// See if this app is on this processor
if (std::binary_search(_box_ids.begin(), _box_ids.end(), bids[i]))
{
GlobalOrdinal app = bids[i];
Point p;
for(unsigned int j=0; j<dim; j++)
p(j) = coords[(j*num_values)+i];
evaluated_data[i] = _multi_app.appUserObjectBase(app, _user_object_name).spatialValue(p);
}
else
evaluated_data[i] = 0.0;
}
return DataTransferKit::FieldContainer<double>(evaluated_data, 1);
}
void Hydrology::buildProblem (Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs,
Albany::StateManager& stateMgr)
{
// Building cell basis and cubature
const CellTopologyData * const cell_top = &meshSpecs[0]->ctd;
intrepidBasis = Albany::getIntrepid2Basis(*cell_top);
cellType = Teuchos::rcp(new shards::CellTopology (cell_top));
Intrepid2::DefaultCubatureFactory cubFactory;
cubature = cubFactory.create<PHX::Device, RealType, RealType>(*cellType, meshSpecs[0]->cubatureDegree);
elementBlockName = meshSpecs[0]->ebName;
const int worksetSize = meshSpecs[0]->worksetSize;
const int numCellVertices = cellType->getNodeCount();
const int numCellNodes = intrepidBasis->getCardinality();
const int numCellQPs = cubature->getNumPoints();
dl = Teuchos::rcp(new Albany::Layouts(worksetSize,numCellVertices,numCellNodes,numCellQPs,numDim));
/* Construct All Phalanx Evaluators */
TEUCHOS_TEST_FOR_EXCEPTION(meshSpecs.size()!=1,std::logic_error,"Problem supports one Material Block");
fm.resize(1);
fm[0] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>);
buildEvaluators(*fm[0], *meshSpecs[0], stateMgr, Albany::BUILD_RESID_FM,Teuchos::null);
if(meshSpecs[0]->nsNames.size() > 0) {
// Build a nodeset evaluator if nodesets are present
constructDirichletEvaluators(*meshSpecs[0]);
}
if(meshSpecs[0]->ssNames.size() > 0) {
// Build a sideset evaluator if sidesets are present
constructNeumannEvaluators(meshSpecs[0]);
}
}
void IntrepidKernel<Scalar>::evaluate(
Teuchos::ArrayRCP<Scalar> &function_values,
const Teuchos::ArrayRCP<Scalar> &coeffs,
const Teuchos::ArrayRCP<Scalar> &dfunc_values )
{
int dim1 = this->b_cardinality;
testPrecondition( dim1 == (int) coeffs.size(),
"Function coefficients size does not match basis cardinality" );
MDArray function_coeffs( 1, dim1 );
for ( int m = 0; m < dim1; ++m )
{
function_coeffs(0,m) = coeffs[m];
}
MDArray basis_eval( 1, dim1, 1 );
for ( int i = 0; i < dim1; ++i )
{
basis_eval( 0, i, 0 ) = dfunc_values[i];
}
Teuchos::Tuple<int,2> function_dimensions;
function_dimensions[0] = 1;
function_dimensions[1] = 1;
MDArray function_eval( function_dimensions, function_values );
Intrepid::FunctionSpaceTools::evaluate<Scalar>( function_eval,
function_coeffs,
basis_eval );
}
// =============================================================================
Teuchos::RCP<Epetra_Map>
VIO::EpetraMesh::Reader::
createComplexValuesMap_ ( const Epetra_Map & nodesMap
) const
{
// get view for the global indices of the global elements
int numMyElements = nodesMap.NumMyElements();
Teuchos::ArrayRCP<int> myGlobalElements( numMyElements );
nodesMap.MyGlobalElements( myGlobalElements.getRawPtr() );
// Construct the map in such a way that all complex entries on processor K
// are split up into real and imaginary part, which will both reside on
// processor K again.
int numMyComplexElements = 2*numMyElements;
Teuchos::ArrayRCP<int> myComplexGlobalElements ( numMyComplexElements );
for ( int k = 0; k < numMyElements; k++ )
{
myComplexGlobalElements[2*k ] = 2 * myGlobalElements[k];
myComplexGlobalElements[2*k+1] = 2 * myGlobalElements[k] + 1;
}
return Teuchos::rcp ( new Epetra_Map ( -1,
myComplexGlobalElements.size(),
myComplexGlobalElements.getRawPtr(),
nodesMap.IndexBase(),
nodesMap.Comm()
)
);
}
void
Albany::PoissonsEquationProblem::
buildProblem(
Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs,
Albany::StateManager& stateMgr)
{
int physSets = meshSpecs.size();
*out << "Num MeshSpecs: " << physSets << '\n';
fm.resize(physSets);
bool haveSidesets = false;
*out << "Calling PoissonsEquationProblem::buildEvaluators" << '\n';
for (int ps = 0; ps < physSets; ++ps) {
fm[ps] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>);
buildEvaluators(*fm[ps], *meshSpecs[ps], stateMgr, BUILD_RESID_FM,
Teuchos::null);
if (meshSpecs[ps]->ssNames.size() > 0) haveSidesets = true;
}
constructDirichletEvaluators(*meshSpecs[0]);
if( haveSidesets )
constructNeumannEvaluators(meshSpecs[0]);
if( params->isType<Teuchos::RCP<ATO::Topology> >("Topology") )
setupTopOpt(meshSpecs,stateMgr);
}
//------------------------------------------------------------------------------
void
Albany::MechanicsProblem::
buildProblem(
Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct>> meshSpecs,
Albany::StateManager& stateMgr)
{
// Construct All Phalanx Evaluators
int physSets = meshSpecs.size();
*out << "Num MeshSpecs: " << physSets << '\n';
fm.resize(physSets);
bool haveSidesets = false;
*out << "Calling MechanicsProblem::buildEvaluators" << '\n';
for (int ps = 0; ps < physSets; ++ps) {
fm[ps] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>);
buildEvaluators(*fm[ps], *meshSpecs[ps], stateMgr, BUILD_RESID_FM,
Teuchos::null);
if (meshSpecs[ps]->ssNames.size() > 0) haveSidesets = true;
}
constructDirichletEvaluators(*meshSpecs[0]);
if (haveSidesets)
constructNeumannEvaluators(meshSpecs[0]);
}
MyField evaluate(
const Teuchos::ArrayRCP<MyMesh::global_ordinal_type>& elements,
const Teuchos::ArrayRCP<double>& coords )
{
int num_elements = elements.size();
MyField evaluated_data( num_elements, 3 );
for ( int n = 0; n < num_elements; ++n )
{
if ( std::find( d_mesh.elementsBegin(),
d_mesh.elementsEnd(),
elements[n] ) != d_mesh.elementsEnd() )
{
*(evaluated_data.begin() + n ) = d_comm->getRank() + 1.0;
*(evaluated_data.begin() + num_elements + n ) =
d_comm->getRank() + 1.0;
*(evaluated_data.begin() + 2*num_elements + n ) =
d_comm->getRank() + 1.0;
}
else
{
*(evaluated_data.begin() + n ) = 0.0;
*(evaluated_data.begin() + num_elements + n ) = 0.0;
*(evaluated_data.begin() + 2*num_elements + n ) = 0.0;
}
}
return evaluated_data;
}
void LocalAggregationAlgorithm<LocalOrdinal, GlobalOrdinal, Node, LocalMatOps>::RandomReorder(Teuchos::ArrayRCP<LO> list) const {
//TODO: replace int
int n = list.size();
for(int i=0; i<n-1; i++) {
std::swap(list[i], list[RandomOrdinal(i,n-1)]);
}
}
void
Albany::NavierStokes::
buildProblem(
Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs,
Albany::StateManager& stateMgr)
{
using Teuchos::rcp;
/* Construct All Phalanx Evaluators */
TEUCHOS_TEST_FOR_EXCEPTION(meshSpecs.size()!=1,std::logic_error,"Problem supports one Material Block");
fm.resize(1);
fm[0] = rcp(new PHX::FieldManager<PHAL::AlbanyTraits>);
buildEvaluators(*fm[0], *meshSpecs[0], stateMgr, BUILD_RESID_FM,
Teuchos::null);
if(meshSpecs[0]->nsNames.size() > 0) // Build a nodeset evaluator if nodesets are present
constructDirichletEvaluators(meshSpecs[0]->nsNames);
if(meshSpecs[0]->ssNames.size() > 0) // Build a sideset evaluator if sidesets are present
constructNeumannEvaluators(meshSpecs[0]);
}
void
Albany::PNPProblem::
buildProblem(
Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs,
Albany::StateManager& stateMgr)
{
using Teuchos::rcp;
/* Construct All Phalanx Evaluators */
int physSets = meshSpecs.size();
std::cout << "PNP Problem Num MeshSpecs: " << physSets << std::endl;
fm.resize(physSets);
for (int ps=0; ps<physSets; ps++) {
fm[ps] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>);
buildEvaluators(*fm[ps], *meshSpecs[ps], stateMgr, BUILD_RESID_FM,
Teuchos::null);
}
if(meshSpecs[0]->nsNames.size() > 0) // Build a nodeset evaluator if nodesets are present
constructDirichletEvaluators(*meshSpecs[0]);
if(meshSpecs[0]->ssNames.size() > 0) // Build a sideset evaluator if sidesets are present
constructNeumannEvaluators(meshSpecs[0]);
}
Teuchos::ArrayRCP<LocalOrdinal> Aggregates<LocalOrdinal, GlobalOrdinal, Node, LocalMatOps>::ComputeAggregateSizes(bool forceRecompute, bool cacheSizes) const {
if (aggregateSizes_ != Teuchos::null && !forceRecompute) {
return aggregateSizes_;
} else {
//invalidate previous sizes.
aggregateSizes_ = Teuchos::null;
Teuchos::ArrayRCP<LO> aggregateSizes;
aggregateSizes = Teuchos::ArrayRCP<LO>(nAggregates_,0);
int myPid = vertex2AggId_->getMap()->getComm()->getRank();
Teuchos::ArrayRCP<LO> procWinner = procWinner_->getDataNonConst(0);
Teuchos::ArrayRCP<LO> vertex2AggId = vertex2AggId_->getDataNonConst(0);
LO size = procWinner.size();
//for (LO i = 0; i < nAggregates_; ++i) aggregateSizes[i] = 0;
for (LO k = 0; k < size; ++k ) {
if (procWinner[k] == myPid) aggregateSizes[vertex2AggId[k]]++;
}
if (cacheSizes)
aggregateSizes_ = aggregateSizes;
return aggregateSizes;
}
} //ComputeAggSizesNodes
//-----------------------------------------------------------------------------
double TpetraVector::max() const
{
dolfin_assert(!_x.is_null());
Teuchos::ArrayRCP<const double> arr = _x->getData(0);
double max_local = *std::max_element(arr.get(), arr.get() + arr.size());
return MPI::max(mpi_comm(), max_local);
}
DataTransferKit::FieldContainer<double> evaluate(
const Teuchos::ArrayRCP<int>& gids,
const Teuchos::ArrayRCP<double>& coords )
{
Teuchos::ArrayRCP<double> evaluated_data( gids.size() );
for ( int n = 0; n < gids.size(); ++n )
{
if ( std::find( d_geom_gids.begin(),
d_geom_gids.end(),
gids[n] ) != d_geom_gids.end() )
{
evaluated_data[n] = 1.0 + gids[n];
}
else
{
evaluated_data[n] = 0.0;
}
}
return DataTransferKit::FieldContainer<double>( evaluated_data, 1 );
}
MyField evaluate(
const Teuchos::ArrayRCP<int>& gids,
const Teuchos::ArrayRCP<double>& coords )
{
MyField evaluated_data( gids.size(), 1 );
for ( int n = 0; n < gids.size(); ++n )
{
if ( std::find( d_geom_gids.begin(),
d_geom_gids.end(),
gids[n] ) != d_geom_gids.end() )
{
*(evaluated_data.begin() + n ) = 1.0;
}
else
{
*(evaluated_data.begin() + n ) = 0.0;
}
}
return evaluated_data;
}
MyField evaluate(
const Teuchos::ArrayRCP<
DataTransferKit::MeshContainer<int>::global_ordinal_type>& elements,
const Teuchos::ArrayRCP<double>& coords )
{
MyField evaluated_data( elements.size(), 1 );
for ( int n = 0; n < elements.size(); ++n )
{
if ( std::find( d_mesh.elementsBegin(),
d_mesh.elementsEnd(),
elements[n] ) != d_mesh.elementsEnd() )
{
*(evaluated_data.begin() + n ) = d_comm->getRank() + 1.0;
}
else
{
*(evaluated_data.begin() + n ) = 0.0;
}
}
return evaluated_data;
}
LCM::
Schwarz_BoundaryJacobian::
Schwarz_BoundaryJacobian(
Teuchos::RCP<Teuchos_Comm const> const & comm,
Teuchos::ArrayRCP<Teuchos::RCP<Albany::Application>> const & ca,
Teuchos::Array<Teuchos::RCP<Tpetra_CrsMatrix>> jacs,
int const this_app_index,
int const coupled_app_index) :
commT_(comm),
coupled_apps_(ca),
jacs_(jacs),
this_app_index_(this_app_index),
coupled_app_index_(coupled_app_index),
b_use_transpose_(false),
b_initialized_(false),
n_models_(0)
{
assert(0 <= this_app_index && this_app_index < ca.size());
assert(0 <= coupled_app_index && coupled_app_index < ca.size());
domain_map_ = ca[coupled_app_index]->getMapT();
range_map_ = ca[this_app_index]->getMapT();
}
void
Albany::Helmholtz2DProblem::
buildProblem(
Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs,
Albany::StateManager& stateMgr)
{
/* Construct All Phalanx Evaluators */
TEUCHOS_TEST_FOR_EXCEPTION(meshSpecs.size()!=1,std::logic_error,"Problem supports one Material Block");
fm.resize(1);
fm[0] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>);
buildEvaluators(*fm[0], *meshSpecs[0], stateMgr, BUILD_RESID_FM,
Teuchos::null);
constructDirichletEvaluators(*meshSpecs[0]);
}
void DiscreteBoundaryOperator<ValueType>::applyImpl(
const Thyra::EOpTransp M_trans,
const Thyra::MultiVectorBase<ValueType> &X_in,
const Teuchos::Ptr<Thyra::MultiVectorBase<ValueType>> &Y_inout,
const ValueType alpha, const ValueType beta) const {
typedef Thyra::Ordinal Ordinal;
// Note: the name is VERY misleading: these asserts don't disappear in
// release runs, and in case of failure throw exceptions rather than
// abort.
TEUCHOS_ASSERT(this->opSupported(M_trans));
TEUCHOS_ASSERT(X_in.range()->isCompatible(*this->domain()));
TEUCHOS_ASSERT(Y_inout->range()->isCompatible(*this->range()));
TEUCHOS_ASSERT(Y_inout->domain()->isCompatible(*X_in.domain()));
const Ordinal colCount = X_in.domain()->dim();
// Loop over the input columns
for (Ordinal col = 0; col < colCount; ++col) {
// Get access the the elements of X_in's and Y_inout's column #col
Thyra::ConstDetachedSpmdVectorView<ValueType> xVec(X_in.col(col));
Thyra::DetachedSpmdVectorView<ValueType> yVec(Y_inout->col(col));
const Teuchos::ArrayRCP<const ValueType> xArray(xVec.sv().values());
const Teuchos::ArrayRCP<ValueType> yArray(yVec.sv().values());
// Wrap the Trilinos array in an Armadillo vector. const_cast is used
// because it's more natural to have a const arma::Col<ValueType> array
// than an arma::Col<const ValueType> one.
const arma::Col<ValueType> xCol(const_cast<ValueType *>(xArray.get()),
xArray.size(), false /* copy_aux_mem */);
arma::Col<ValueType> yCol(yArray.get(), yArray.size(), false);
applyBuiltInImpl(static_cast<TranspositionMode>(M_trans), xCol, yCol, alpha,
beta);
}
}
//! Copy a flat vector into a product vector
void copyFlatThyraIntoBlockedThyra(const Thyra::VectorBase<double>& src,
const Teuchos::Ptr<Thyra::VectorBase<double> > & dest) const
{
using Teuchos::RCP;
using Teuchos::ArrayView;
using Teuchos::rcpFromPtr;
using Teuchos::rcp_dynamic_cast;
const RCP<Thyra::ProductVectorBase<double> > prodDest =
Thyra::castOrCreateNonconstProductVectorBase(rcpFromPtr(dest));
const Thyra::SpmdVectorBase<double> & spmdSrc =
Teuchos::dyn_cast<const Thyra::SpmdVectorBase<double> >(src);
// get access to flat data
Teuchos::ArrayRCP<const double> srcData;
spmdSrc.getLocalData(Teuchos::ptrFromRef(srcData));
std::size_t offset = 0;
const int numBlocks = prodDest->productSpace()->numBlocks();
for (int b = 0; b < numBlocks; ++b) {
const RCP<Thyra::VectorBase<double> > destBlk = prodDest->getNonconstVectorBlock(b);
// get access to blocked data
const RCP<Thyra::SpmdVectorBase<double> > spmdBlk =
rcp_dynamic_cast<Thyra::SpmdVectorBase<double> >(destBlk, true);
Teuchos::ArrayRCP<double> destData;
spmdBlk->getNonconstLocalData(Teuchos::ptrFromRef(destData));
// perform copy
for (int i=0; i < destData.size(); ++i) {
destData[i] = srcData[i+offset];
}
offset += destData.size();
}
}
void
Aeras::ShallowWaterProblemNoAD::
buildProblem(
Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs,
Albany::StateManager& stateMgr)
{
using Teuchos::rcp;
/* Construct All Phalanx Evaluators */
TEUCHOS_TEST_FOR_EXCEPTION(meshSpecs.size()!=1,std::logic_error,"Problem supports one Material Block");
fm.resize(1);
fm[0] = rcp(new PHX::FieldManager<PHAL::AlbanyTraits>);
buildEvaluators(*fm[0], *meshSpecs[0], stateMgr, Albany::BUILD_RESID_FM,
Teuchos::null);
}
void
Albany::PeridigmProblem::
buildProblem(
Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct>> meshSpecs,
Albany::StateManager& stateMgr)
{
/* Construct All Phalanx Evaluators */
int physSets = meshSpecs.size();
fm.resize(physSets);
for (int ps=0; ps<physSets; ps++) {
fm[ps] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>);
buildEvaluators(*fm[ps], *meshSpecs[ps], stateMgr, BUILD_RESID_FM, Teuchos::null);
}
constructDirichletEvaluators(*meshSpecs[0]);
}
void
FELIX::StokesL1L2::
buildProblem(
Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs,
Albany::StateManager& stateMgr)
{
using Teuchos::rcp;
std::cout << "In StokesL1L2 Problem!" << std::endl;
/* Construct All Phalanx Evaluators */
TEUCHOS_TEST_FOR_EXCEPTION(meshSpecs.size()!=1,std::logic_error,"Problem supports one Material Block");
fm.resize(1);
fm[0] = rcp(new PHX::FieldManager<PHAL::AlbanyTraits>);
buildEvaluators(*fm[0], *meshSpecs[0], stateMgr, Albany::BUILD_RESID_FM,
Teuchos::null);
constructDirichletEvaluators(*meshSpecs[0]);
}
void
Tsunami::Boussinesq::
buildProblem(
Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs,
Albany::StateManager& stateMgr)
{
using Teuchos::rcp;
/* Construct All Phalanx Evaluators */
TEUCHOS_TEST_FOR_EXCEPTION(meshSpecs.size()!=1,std::logic_error,"Problem supports one Material Block");
fm.resize(1);
fm[0] = rcp(new PHX::FieldManager<PHAL::AlbanyTraits>);
elementBlockName = meshSpecs[0]->ebName;
buildEvaluators(*fm[0], *meshSpecs[0], stateMgr, Albany::BUILD_RESID_FM,
Teuchos::null);
constructDirichletEvaluators(*meshSpecs[0]);
//construct Neumann evaluators
constructNeumannEvaluators(meshSpecs[0]);
}
Teuchos::RCP<const Teuchos::ParameterList>
getValidInitialConditionParameters(const Teuchos::ArrayRCP<std::string>& wsEBNames) {
Teuchos::RCP<Teuchos::ParameterList> validPL =
rcp(new Teuchos::ParameterList("ValidInitialConditionParams"));;
validPL->set<std::string>("Function", "", "");
Teuchos::Array<double> defaultData;
validPL->set<Teuchos::Array<double> >("Function Data", defaultData, "");
// Validate element block constant data
for(int i = 0; i < wsEBNames.size(); i++)
validPL->set<Teuchos::Array<double> >(wsEBNames[i], defaultData, "");
// For EBConstant data, we can optionally randomly perturb the IC on each variable some amount
validPL->set<Teuchos::Array<double> >("Perturb IC", defaultData, "");
return validPL;
}
//------------------------------------------------------------------------------
void
Albany::ConcurrentMultiscaleProblem::
buildProblem(Teuchos::ArrayRCP<Teuchos::RCP<Albany::MeshSpecsStruct> > meshSpecs,
Albany::StateManager& stateMgr)
{
// Construct All Phalanx Evaluators
int physSets = meshSpecs.size();
std::cout << "Num MeshSpecs: " << physSets << std::endl;
fm.resize(physSets);
std::cout << "Calling ConcurrentMultiscaleProblem::buildEvaluators" << std::endl;
for (int ps=0; ps < physSets; ++ps) {
std::string eb_name = meshSpecs[ps]->ebName;
if ( material_db_->isElementBlockParam(eb_name,"Lagrange Multiplier Block") ) {
lm_overlap_map_.insert(std::make_pair(eb_name,
material_db_->getElementBlockParam<bool>(eb_name,"Lagrange Multiplier Block") ) );
}
if ( material_db_->isElementBlockParam(eb_name,"Coarse Overlap Block") ) {
coarse_overlap_map_.insert(std::make_pair(eb_name,
material_db_->getElementBlockParam<bool>(eb_name,"Coarse Overlap Block") ) );
}
if ( material_db_->isElementBlockParam(eb_name,"Fine Overlap Block") ) {
fine_overlap_map_.insert(std::make_pair(eb_name,
material_db_->getElementBlockParam<bool>(eb_name,"Fine Overlap Block") ) );
}
fm[ps] = Teuchos::rcp(new PHX::FieldManager<PHAL::AlbanyTraits>);
buildEvaluators(*fm[ps], *meshSpecs[ps], stateMgr, BUILD_RESID_FM,
Teuchos::null);
}
constructDirichletEvaluators(*meshSpecs[0]);
}