/** \brief Constructor.
@param[in] parlist is a parameter list specifying inputs
parlist should contain sublists "SOL"->"Risk Measure"->"Convex Combination Risk Measure" and
within the "Convex Combination Risk Measure" sublist should have the following parameters
\li "Convex Combination Parameters" (greater than 0 and sum to 1)
\li Sublists labeled 1 to n with risk measure definitions.
*/
ConvexCombinationRiskMeasure(Teuchos::ParameterList &parlist)
: RiskMeasure<Real>(), size_(0), firstReset_(true) {
Teuchos::ParameterList &list
= parlist.sublist("SOL").sublist("Risk Measure").sublist("Convex Combination Risk Measure");
// Get convex combination parameters
Teuchos::Array<Real> lambda
= Teuchos::getArrayFromStringParameter<Real>(list,"Convex Combination Parameters");
lambda_ = lambda.toVector();
size_ = lambda_.size();
// Build risk measures
risk_.clear(); risk_.resize(size_,Teuchos::null);
parlist_.clear(); parlist_.resize(size_);
for (uint i = 0; i < size_; ++i) {
std::ostringstream convert;
convert << i;
std::string si = convert.str();
Teuchos::ParameterList &ilist = list.sublist(si);
std::string name = ilist.get<std::string>("Name");
parlist_[i].sublist("SOL").sublist("Risk Measure").set("Name",name);
parlist_[i].sublist("SOL").sublist("Risk Measure").sublist(name) = ilist;
risk_[i] = RiskMeasureFactory<Real>(parlist_[i]);
}
// Check inputs
checkInputs();
}
Adapter *
Adapter::initialize(const Teuchos::RCP<Teuchos::ParameterList>& catalystParams)
{
// Validate parameters against list for this specific class
catalystParams->validateParameters(*getValidAdapterParameters(),0);
if (Adapter::instance)
delete Adapter::instance;
Adapter::instance = new Adapter();
// Register our Grid class with Catalyst so that it can be used in a pipeline.
if (vtkClientServerInterpreterInitializer *intInit =
vtkClientServerInterpreterInitializer::GetInitializer()) {
if (vtkClientServerInterpreter *interp = intInit->GetGlobalInterpreter()) {
interp->AddNewInstanceFunction("Grid", Private::MakeGrid);
}
}
// Load pipeline file
Teuchos::Array<std::string> files =
catalystParams->get<Teuchos::Array<std::string> >("Pipeline Files");
typedef Teuchos::Array<std::string>::const_iterator FileIterT;
for (FileIterT it = files.begin(), itEnd = files.end(); it != itEnd; ++it)
Adapter::instance->addPythonScriptPipeline(*it);
return Adapter::instance;
}
Teuchos::Array<int> getMyBlockLIDs(
const Teuchos::ParameterList &blockingParams,
const Albany::AbstractDiscretization &disc)
{
Teuchos::Array<int> result;
const std::string nodeSetLabel = blockingParams.get<std::string>("Node Set");
const int dofRank = blockingParams.get<int>("Dof");
const Albany::NodeSetList &nodeSets = disc.getNodeSets();
const Albany::NodeSetList::const_iterator it = nodeSets.find(nodeSetLabel);
TEUCHOS_TEST_FOR_EXCEPT(it == nodeSets.end());
{
typedef Albany::NodeSetList::mapped_type NodeSetEntryList;
const NodeSetEntryList &nodeEntries = it->second;
for (NodeSetEntryList::const_iterator jt = nodeEntries.begin(); jt != nodeEntries.end(); ++jt) {
typedef NodeSetEntryList::value_type NodeEntryList;
const NodeEntryList &entries = *jt;
result.push_back(entries[dofRank]);
}
}
return result;
}
void FunctionTests::checkFunctionsAgree(FunctionPtr f1, FunctionPtr f2, BasisCachePtr basisCache) {
ASSERT_EQ(f1->rank(), f2->rank())
<< "f1->rank() " << f1->rank() << " != f2->rank() " << f2->rank() << endl;
int rank = f1->rank();
int numCells = basisCache->getPhysicalCubaturePoints().dimension(0);
int numPoints = basisCache->getPhysicalCubaturePoints().dimension(1);
int spaceDim = basisCache->getPhysicalCubaturePoints().dimension(2);
Teuchos::Array<int> dim;
dim.append(numCells);
dim.append(numPoints);
for (int i=0; i<rank; i++) {
dim.append(spaceDim);
}
FieldContainer<double> f1Values(dim);
FieldContainer<double> f2Values(dim);
f1->values(f1Values,basisCache);
f2->values(f2Values,basisCache);
double tol = 1e-14;
double maxDiff;
EXPECT_TRUE(fcsAgree(f1Values,f2Values,tol,maxDiff))
<< "Test failed: f1 and f2 disagree; maxDiff " << maxDiff << ".\n"
<< "f1Values: \n" << f1Values
<< "f2Values: \n" << f2Values;
}
// ============================================================================
Teuchos::RCP<Recti::Domain::Abstract>
Recti::Domain::Factory::
buildPolygon() const
{
const Teuchos::ParameterList & pointsList =
pList_.sublist("Vertices");
Teuchos::Array<Point> vertices;
Teuchos::ParameterList::ConstIterator k;
for ( k=pointsList.begin(); k!=pointsList.end(); ++k )
{
Teuchos::ParameterEntry e = pointsList.entry(k);
TEUCHOS_ASSERT( e.isList() );
std::string label = pointsList.name(k);
const Teuchos::ParameterList & coordinates =
pointsList.sublist(label);
Point X = Teuchos::tuple( coordinates.get<double>("x"),
coordinates.get<double>("y"),
0.0
);
vertices.push_back( X );
}
return Teuchos::rcp( new Polygon( vertices ) );
}
Teuchos::RCP<const Tpetra::Map<LO,GO,Node> >
createMeshMap (const LO& blockSize, const Tpetra::Map<LO,GO,Node>& pointMap)
{
typedef Teuchos::OrdinalTraits<Tpetra::global_size_t> TOT;
typedef Tpetra::Map<LO,GO,Node> map_type;
//calculate mesh GIDs
Teuchos::ArrayView<const GO> pointGids = pointMap.getNodeElementList();
Teuchos::Array<GO> meshGids;
GO indexBase = pointMap.getIndexBase();
// Use hash table to track whether we've encountered this GID previously. This will happen
// when striding through the point DOFs in a block. It should not happen otherwise.
// I don't use sort/make unique because I don't want to change the ordering.
meshGids.reserve(pointGids.size());
Tpetra::Details::HashTable<GO,int> hashTable(pointGids.size());
for (int i=0; i<pointGids.size(); ++i) {
GO meshGid = (pointGids[i]-indexBase) / blockSize + indexBase;
if (hashTable.get(meshGid) == -1) {
hashTable.add(meshGid,1); //(key,value)
meshGids.push_back(meshGid);
}
}
Teuchos::RCP<const map_type> meshMap = Teuchos::rcp( new map_type(TOT::invalid(), meshGids(), 0, pointMap.getComm()) );
return meshMap;
}
Teuchos::RCP<const Tpetra_Map>
Albany::SolutionResponseFunction::
buildCulledMapT(const Tpetra_Map& x_mapT,
const Teuchos::Array<int>& keepDOF) const
{
int numKeepDOF = std::accumulate(keepDOF.begin(), keepDOF.end(), 0);
int Neqns = keepDOF.size();
int N = x_mapT.getNodeNumElements(); // x_mapT is map for solution vector
TEUCHOS_ASSERT( !(N % Neqns) ); // Assume that all the equations for
// a given node are on the assigned
// processor. I.e. need to ensure
// that N is exactly Neqns-divisible
int nnodes = N / Neqns; // number of fem nodes
int N_new = nnodes * numKeepDOF; // length of local x_new
Teuchos::ArrayView<const GO> gidsT = x_mapT.getNodeElementList();
Teuchos::Array<GO> gids_new(N_new);
int idx = 0;
for ( int inode = 0; inode < N/Neqns ; ++inode) // For every node
for ( int ieqn = 0; ieqn < Neqns; ++ieqn ) // Check every dof on the node
if ( keepDOF[ieqn] == 1 ) // then want to keep this dof
gids_new[idx++] = gidsT[(inode*Neqns)+ieqn];
// end cull
Teuchos::RCP<const Tpetra_Map> x_new_mapT = Tpetra::createNonContigMapWithNode<LO, GO, KokkosNode> (gids_new, x_mapT.getComm(), x_mapT.getNode());
return x_new_mapT;
}
//---------------------------------------------------------------------------//
// Get the parameteric center of an entity.
void MoabEntityLocalMap::parametricCenter(
const Entity& entity,
Teuchos::Array<double>& center ) const
{
moab::EntityType moab_type = d_moab_mesh->get_moab()->type_from_handle(
MoabHelpers::extractEntity(entity) );
switch( moab_type )
{
case moab::MBTRI:
center.assign( 2, 1.0 / 3.0 );
break;
case moab::MBQUAD:
center.assign( 2, 0.0 );
break;
case moab::MBTET:
center.assign( 3, 1.0 / 6.0 );
break;
case moab::MBHEX:
center.assign( 3, 0.0 );
break;
default:
center.resize( 0 );
break;
}
}
// =============================================================================
Teuchos::RCP<Tpetra::Map<ORD> >
VIO::TpetraMesh::Mesh::
getElemsToNodesMap_() const
{
// create list of elements that need to be accessible from this process
// Make sure that *all entries that belong to any of the elements in
// this core are accessible.
// First mark all the nodes that need to be accessible:
TEUCHOS_ASSERT( !elems_.is_null() );
TEUCHOS_ASSERT( !nodes_.is_null() );
int numNodes = nodes_.size();
Teuchos::Array<bool> mustBeAccessible( numNodes );
for ( int k=0; k<elems_.size(); k++ )
for ( int l=0; l<elems_[k].size(); l++ )
mustBeAccessible[ elems_[k][l] ] = true;
// now create the list
Teuchos::Array<ORD> entryList;
for ( int k=0; k<numNodes; k++ )
if ( mustBeAccessible[k] )
entryList.append( k );
Teuchos::RCP<Tpetra::Map<ORD> > map =
Teuchos::rcp( new Tpetra::Map<ORD>( Teuchos::OrdinalTraits<ORD>::invalid(), entryList(), 0, comm_ )
);
return map;
}
bool checkVecArrays(const Teuchos::Array<VecType>& x,
const Teuchos::Array<VecType>& x2,
const std::string& tag,
Teuchos::FancyOStream& out) {
// Check sizes match
bool success = (x.size() == x2.size());
out << tag << " Vec array size test";
if (success)
out << " passed";
else
out << " failed";
out << ": \n\tExpected: " << x.size() << ", \n\tGot: " << x2.size()
<< "." << std::endl;
// Check Fads match
for (int i=0; i<x.size(); i++) {
bool success2 = Sacado::IsEqual<VecType>::eval(x[i], x2[i]);
out << tag << " Vec array comparison test " << i;
if (success2)
out << " passed";
else
out << " failed";
out << ": \n\tExpected: " << x[i] << ", \n\tGot: " << x2[i] << "."
<< std::endl;
success = success && success2;
}
return success;
}
/*!
* \brief Find the set of entities a point neighbors.
*/
void CoarseLocalSearch::search( const Teuchos::ArrayView<const double>& point,
const Teuchos::ParameterList& parameters,
Teuchos::Array<Entity>& neighbors ) const
{
// Find the leaf of nearest neighbors.
int num_neighbors = 100;
if ( parameters.isParameter("Coarse Local Search kNN") )
{
num_neighbors = parameters.get<int>("Coarse Local Search kNN");
}
num_neighbors =
std::min( num_neighbors, Teuchos::as<int>(d_entity_map.size()) );
Teuchos::Array<unsigned> local_neighbors =
d_tree->nnSearch( point, num_neighbors );
// Extract the neighbors.
neighbors.resize( local_neighbors.size() );
Teuchos::Array<unsigned>::const_iterator local_it;
Teuchos::Array<Entity>::iterator entity_it;
for ( local_it = local_neighbors.begin(),
entity_it = neighbors.begin();
local_it != local_neighbors.end();
++local_it, ++entity_it )
{
DTK_CHECK( d_entity_map.count(*local_it) );
*entity_it = d_entity_map.find(*local_it)->second;
}
}
Teuchos::RCP<const Tpetra::CrsGraph<LocalOrdinal,GlobalOrdinal,Node> > create_tridiag_graph(LocalOrdinal num_rows_per_proc)
{
Teuchos::RCP<const Teuchos::Comm<int> > comm = getDefaultComm();
const global_size_t INVALID = Teuchos::OrdinalTraits<global_size_t>::invalid();
const LocalOrdinal indexBase = 0;
Teuchos::RCP<const Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> > rowmap = Teuchos::rcp(new Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node>(INVALID, num_rows_per_proc, indexBase, comm));
Teuchos::RCP<Tpetra::CrsGraph<LocalOrdinal,GlobalOrdinal,Node> > crsgraph = Teuchos::rcp(new Tpetra::CrsGraph<LocalOrdinal,GlobalOrdinal,Node>(rowmap, 0));
Teuchos::Array<GlobalOrdinal> cols;
for(LocalOrdinal l_row = 0; (size_t) l_row<rowmap->getNodeNumElements(); l_row++) {
GlobalOrdinal g_row = rowmap->getGlobalElement(l_row);
if (g_row == rowmap->getMinAllGlobalIndex() ||
g_row == rowmap->getMaxAllGlobalIndex()) cols.resize(2);
else cols.resize(3);
size_t coloffset = 0;
if (g_row > rowmap->getMinAllGlobalIndex()) cols[coloffset++] = g_row-1;
cols[coloffset++] = g_row;
if (g_row < rowmap->getMaxAllGlobalIndex()) cols[coloffset++] = g_row+1;
crsgraph->insertGlobalIndices(g_row, cols());
}
crsgraph->fillComplete();
return crsgraph;
}
Teuchos::RCP<Tpetra::CrsGraph<LocalOrdinal,GlobalOrdinal,Node> > create_test_graph(LocalOrdinal num_rows_per_proc)
{
Teuchos::RCP<const Teuchos::Comm<int> > comm = getDefaultComm();
const global_size_t INVALID = Teuchos::OrdinalTraits<global_size_t>::invalid();
const LocalOrdinal indexBase = 0;
Teuchos::RCP<const Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> > rowmap = Teuchos::rcp(new Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node>(INVALID, num_rows_per_proc, indexBase, comm));
Teuchos::RCP<Tpetra::CrsGraph<LocalOrdinal,GlobalOrdinal,Node> > crsgraph = Teuchos::rcp(new Tpetra::CrsGraph<LocalOrdinal,GlobalOrdinal,Node>(rowmap, 0));
size_t global_size = rowmap->getGlobalNumElements();
Teuchos::Array<GlobalOrdinal> cols;
for(LocalOrdinal l_row = 0; (size_t) l_row<rowmap->getNodeNumElements(); l_row++) {
GlobalOrdinal g_row = rowmap->getGlobalElement(l_row);
if (g_row == rowmap->getMinAllGlobalIndex()) {
cols.resize(global_size);
for(size_t i=0; i<global_size; ++i) {
GlobalOrdinal gcol = g_row + i;
cols[i] = gcol;
}
}
else {
cols.resize(2);
cols[0] = rowmap->getMinAllGlobalIndex();
cols[1] = g_row;
}
crsgraph->insertGlobalIndices(g_row, cols());
}
crsgraph->fillComplete();
return crsgraph;
}
std::ostream&
Stokhos::VectorOrthogPoly<coeff_type>::
print(std::ostream& os) const
{
Teuchos::Array<ordinal_type> trm;
ordinal_type sz = this->coeff_.size();
os << "Stokhos::VectorOrthogPoly of global size "
<< this->map_->NumGlobalElements() << ", local size " << sz << " in basis "
<< "\n" << basis_->getName() << ":" << std::endl;
Teuchos::RCP< const Stokhos::ProductBasis<ordinal_type, value_type> >
product_basis = Teuchos::rcp_dynamic_cast< const Stokhos::ProductBasis<ordinal_type, value_type> >(basis_);
if (product_basis != Teuchos::null) {
for (ordinal_type i=0; i<sz; i++) {
trm = product_basis->getTerm(i);
os << "Term " << i << " (";
for (ordinal_type j=0; j<static_cast<ordinal_type>(trm.size())-1; j++)
os << trm[j] << ", ";
os << trm[trm.size()-1] << "):" << std::endl;
traits_type::print(os, *(this->coeff_[this->map_->LID(i)]));
}
}
else {
for (ordinal_type i=0; i<sz; i++) {
os << "Term " << this->map_->GID(i) << ":" << std::endl;
traits_type::print(os, *(this->coeff_[i]));
}
}
return os;
}
void FELIX::Hydrology::constructNeumannEvaluators (const Teuchos::RCP<Albany::MeshSpecsStruct>& meshSpecs)
{
// Note: we only enter this function if sidesets are defined in the mesh file
// i.e. meshSpecs.ssNames.size() > 0
Albany::BCUtils<Albany::NeumannTraits> nbcUtils;
// Check to make sure that Neumann BCs are given in the input file
if (!nbcUtils.haveBCSpecified(this->params))
{
return;
}
// Construct BC evaluators for all side sets and names
// Note that the string index sets up the equation offset, so ordering is important
std::vector<std::string> neumannNames(neq + 1);
Teuchos::Array<Teuchos::Array<int> > offsets;
offsets.resize(1);
neumannNames[0] = "Hydraulic Potential";
neumannNames[1] = "all";
offsets[0].resize(1);
offsets[0][0] = 0;
// Construct BC evaluators for all possible names of conditions
std::vector<std::string> condNames(1);
condNames[0] = "neumann";
nfm.resize(1); // FELIX problem only has one element block
nfm[0] = nbcUtils.constructBCEvaluators(meshSpecs, neumannNames, dof_names, false, 0,
condNames, offsets, dl,
this->params, this->paramLib);
}
void values(FieldContainer<double> &values, BasisCachePtr sliceBasisCache) {
vector<GlobalIndexType> sliceCellIDs = sliceBasisCache->cellIDs();
Teuchos::Array<int> dim;
values.dimensions(dim);
dim[0] = 1; // one cell
Teuchos::Array<int> offset(dim.size());
for (int cellOrdinal = 0; cellOrdinal < sliceCellIDs.size(); cellOrdinal++) {
offset[0] = cellOrdinal;
int enumeration = values.getEnumeration(offset);
FieldContainer<double>valuesForCell(dim,&values[enumeration]);
GlobalIndexType sliceCellID = sliceCellIDs[cellOrdinal];
int numPoints = sliceBasisCache->getPhysicalCubaturePoints().dimension(1);
int spaceDim = sliceBasisCache->getPhysicalCubaturePoints().dimension(2);
FieldContainer<double> spaceTimePhysicalPoints(1,numPoints,spaceDim+1);
for (int ptOrdinal=0; ptOrdinal<numPoints; ptOrdinal++) {
for (int d=0; d<spaceDim; d++) {
spaceTimePhysicalPoints(0,ptOrdinal,d) = sliceBasisCache->getPhysicalCubaturePoints()(cellOrdinal,ptOrdinal,d);
}
spaceTimePhysicalPoints(0,ptOrdinal,spaceDim) = _t;
}
GlobalIndexType cellID = _cellIDMap[sliceCellID];
BasisCachePtr spaceTimeBasisCache = BasisCache::basisCacheForCell(_spaceTimeMesh, cellID);
FieldContainer<double> spaceTimeRefPoints(1,numPoints,spaceDim+1);
CamelliaCellTools::mapToReferenceFrame(spaceTimeRefPoints, spaceTimePhysicalPoints, _spaceTimeMesh, cellID);
spaceTimeRefPoints.resize(numPoints,spaceDim+1);
spaceTimeBasisCache->setRefCellPoints(spaceTimeRefPoints);
_spaceTimeFunction->values(valuesForCell, spaceTimeBasisCache);
}
}
void BilinearFormUtility::weightCellBasisValues(FieldContainer<double> &basisValues, const FieldContainer<double> &weights, int offset) {
// weights are (numCells, offset+numFields)
// basisValues are (numCells, numFields, ...)
int numCells = basisValues.dimension(0);
int numFields = basisValues.dimension(1);
Teuchos::Array<int> dimensions;
basisValues.dimensions(dimensions);
int numAffectedValues = 1;
for (int dimIndex=2; dimIndex<dimensions.size(); dimIndex++) {
numAffectedValues *= dimensions[dimIndex];
}
Teuchos::Array<int> index(dimensions.size(),0);
for (int cellIndex=0; cellIndex < numCells; cellIndex++) {
index[0] = cellIndex;
for (int fieldIndex=0; fieldIndex < numFields; fieldIndex++) {
index[1] = fieldIndex;
int enumIndex = basisValues.getEnumeration(index);
for (int valIndex=enumIndex; valIndex < numAffectedValues + enumIndex; valIndex++) {
basisValues[valIndex] *= weights(cellIndex,fieldIndex+offset);
}
}
}
}
void
Stokhos::PecosOneDOrthogPolyBasis<ordinal_type,value_type>::
getQuadPoints(ordinal_type quad_order,
Teuchos::Array<value_type>& quad_points,
Teuchos::Array<value_type>& quad_weights,
Teuchos::Array< Teuchos::Array<value_type> >& quad_values) const
{
// This assumes Gaussian quadrature
ordinal_type num_points =
static_cast<ordinal_type>(std::ceil((quad_order+1)/2.0));
const Pecos::RealArray& gp = pecosPoly->collocation_points(num_points);
const Pecos::RealArray& gw = pecosPoly->type1_collocation_weights(num_points);
quad_points.resize(num_points);
quad_weights.resize(num_points);
for (ordinal_type i=0; i<num_points; i++) {
quad_points[i] = gp[i];
quad_weights[i] = gw[i];
}
// Evalute basis at gauss points
quad_values.resize(num_points);
for (ordinal_type i=0; i<num_points; i++) {
quad_values[i].resize(p+1);
evaluateBases(quad_points[i], quad_values[i]);
}
}
Teuchos::RCP<Epetra_Map>
Albany::SolutionResponseFunction::
buildCulledMap(const Epetra_Map& x_map,
const Teuchos::Array<int>& keepDOF) const
{
int numKeepDOF = std::accumulate(keepDOF.begin(), keepDOF.end(), 0);
int Neqns = keepDOF.size();
int N = x_map.NumMyElements(); // x_map is map for solution vector
TEUCHOS_ASSERT( !(N % Neqns) ); // Assume that all the equations for
// a given node are on the assigned
// processor. I.e. need to ensure
// that N is exactly Neqns-divisible
int nnodes = N / Neqns; // number of fem nodes
int N_new = nnodes * numKeepDOF; // length of local x_new
int *gids = x_map.MyGlobalElements(); // Fill local x_map into gids array
Teuchos::Array<int> gids_new(N_new);
int idx = 0;
for ( int inode = 0; inode < N/Neqns ; ++inode) // For every node
for ( int ieqn = 0; ieqn < Neqns; ++ieqn ) // Check every dof on the node
if ( keepDOF[ieqn] == 1 ) // then want to keep this dof
gids_new[idx++] = gids[(inode*Neqns)+ieqn];
// end cull
Teuchos::RCP<Epetra_Map> x_new_map =
Teuchos::rcp( new Epetra_Map( -1, N_new, &gids_new[0], 0, x_map.Comm() ) );
return x_new_map;
}
RiskVector( Teuchos::ParameterList &parlist,
const Teuchos::RCP<Vector<Real> > &vec,
const Real stat = 1. )
: vec_(vec), augmented_(false), nStat_(0) {
stat_.clear();
dual_vec1_ = vec->dual().clone();
std::string type = parlist.sublist("SOL").sublist("Risk Measure").get("Name","CVaR");
if ( type == "CVaR" ||
type == "HMCR" ||
type == "KL Divergence" ||
type == "Moreau-Yosida CVaR" ||
type == "Log-Exponential Quadrangle" ||
type == "Log-Quantile Quadrangle" ||
type == "Quantile-Based Quadrangle" ||
type == "Truncated Mean Quadrangle" ) {
augmented_ = true;
nStat_ = 1;
stat_.resize(nStat_,stat);
}
else if ( type == "Mixed-Quantile Quadrangle" ) {
Teuchos::ParameterList &list
= parlist.sublist("SOL").sublist("Risk Measure").sublist("Mixed-Quantile Quadrangle");
Teuchos::Array<Real> prob
= Teuchos::getArrayFromStringParameter<Real>(list,"Probability Array");
augmented_ = true;
nStat_ = prob.size();
stat_.resize(nStat_,stat);
}
else if ( type == "Quantile-Radius Quadrangle" ) {
augmented_ = true;
nStat_ = 2;
stat_.resize(nStat_,stat);
}
}
void BCManager::modifyPrimalSystem(
std::string const& val, int offset, std::string const& set)
{
// should we fill in BC info?
bool fillRes = (res != Teuchos::null);
bool fillJac = (jac != Teuchos::null);
if ((!fillRes) && (!fillJac)) return;
// get views of the solution and residual vectors
ArrayRCP<const ST> x_const_view;
ArrayRCP<ST> f_nonconst_view;
if (fillRes) {
x_const_view = sol->get1dView();
f_nonconst_view = res->get1dViewNonConst();
}
// set up some data for replacing jacobian values
Teuchos::Array<LO> index(1);
Teuchos::Array<ST> value(1);
value[0] = 1.0;
size_t numEntries;
Teuchos::Array<ST> matrixEntries;
Teuchos::Array<LO> matrixIndices;
// loop over all of the nodes in this node set
std::vector<Albany::GOALNode> nodes = ns[set];
for (int i=0; i < nodes.size(); ++i)
{
Albany::GOALNode node = nodes[i];
int lunk = disc->getDOF(node.lid, offset);
// if the node is higher order, we set the value of the DBC to be 0
// if it is not, we parse the expression from the input file to get the value
// note: this assumes that bcs are either constant or linear in space
// anything else would require a linear solve to find coefficients v
double v = 0.0;
if (!node.higherOrder)
v = parseExpression(val, node.coord[0], node.coord[1], node.coord[2], t);
// modify the residual if necessary
if (fillRes)
f_nonconst_view[lunk] = x_const_view[lunk] - v;
// modify the jacobian if necessary
if (fillJac)
{
index[0] = lunk;
numEntries = jac->getNumEntriesInLocalRow(lunk);
matrixEntries.resize(numEntries);
matrixIndices.resize(numEntries);
jac->getLocalRowCopy(lunk, matrixIndices(), matrixEntries(), numEntries);
for (int i=0; i < numEntries; ++i)
matrixEntries[i] = 0.0;
jac->replaceLocalValues(lunk, matrixIndices(), matrixEntries());
jac->replaceLocalValues(lunk, index(), value());
}
}
}
TEUCHOS_UNIT_TEST( Stokhos_ProductBasisUtils, TotalOrderBasis ) {
success = true;
// Build index set of dimension d and order p
typedef Stokhos::TotalOrderIndexSet<ordinal_type> index_set_type;
typedef index_set_type::multiindex_type multiindex_type;
typedef index_set_type::iterator iterator;
index_set_type indexSet(setup.d, 0, setup.p);
// Build total-order basis from index set
typedef Stokhos::TensorProductElement<ordinal_type,ordinal_type> coeff_type;
typedef Stokhos::TotalOrderLess<coeff_type> less_type;
typedef std::map<coeff_type, ordinal_type, less_type> basis_set_type;
typedef basis_set_type::iterator basis_set_iterator;
typedef Teuchos::Array<coeff_type> basis_map_type;
basis_set_type basis_set;
basis_map_type basis_map;
Stokhos::ProductBasisUtils::buildProductBasis(
indexSet, basis_set, basis_map);
// Build total-order basis directly
ordinal_type sz;
Teuchos::Array< Stokhos::MultiIndex<ordinal_type> > terms;
Teuchos::Array<ordinal_type> num_terms;
Stokhos::CompletePolynomialBasisUtils<ordinal_type,value_type>::
compute_terms(setup.p, setup.d, sz, terms, num_terms);
// Check sizes
TEUCHOS_TEST_EQUALITY(static_cast<ordinal_type>(basis_set.size()),
static_cast<ordinal_type>(basis_map.size()),
out, success);
TEUCHOS_TEST_EQUALITY(static_cast<ordinal_type>(basis_set.size()),
static_cast<ordinal_type>(terms.size()),
out, success);
TEUCHOS_TEST_EQUALITY(sz, static_cast<ordinal_type>(terms.size()),
out, success);
std::ostream_iterator<ordinal_type> out_iterator(out, " ");
for (ordinal_type i=0; i<sz; i++) {
// Verify terms match
out << "term " << basis_map[i] << " == " << terms[i] << " : ";
bool is_equal = true;
for (ordinal_type j=0; j<setup.d; j++)
is_equal = is_equal && terms[i][j] == basis_map[i][j];
if (is_equal)
out << "passed" << std::endl;
else {
out << "failed" << std::endl;
success = false;
}
// Verify global index mapping matches
TEUCHOS_TEST_EQUALITY(basis_set[basis_map[i]], i, out, success);
}
}
FELIX::StokesFO::
StokesFO( const Teuchos::RCP<Teuchos::ParameterList>& params_,
const Teuchos::RCP<ParamLib>& paramLib_,
const int numDim_) :
Albany::AbstractProblem(params_, paramLib_, numDim_),
numDim(numDim_)
{
//Set # of PDEs per node based on the Equation Set.
//Equation Set is FELIX by default (2 dofs / node -- usual FELIX Stokes FO).
std::string eqnSet = params_->sublist("Equation Set").get<std::string>("Type", "FELIX");
if (eqnSet == "FELIX")
neq = 2; //FELIX FO Stokes system is a system of 2 PDEs
else if (eqnSet == "Poisson" || eqnSet == "FELIX X-Z")
neq = 1; //1 PDE/node for Poisson or FELIX X-Z physics
// Set the num PDEs for the null space object to pass to ML
this->rigidBodyModes->setNumPDEs(neq);
// the following function returns the problem information required for setting the rigid body modes (RBMs) for elasticity problems
//written by IK, Feb. 2012
//Check if we want to give ML RBMs (from parameterlist)
int numRBMs = params_->get<int>("Number RBMs for ML", 0);
bool setRBMs = false;
if (numRBMs > 0) {
setRBMs = true;
int numScalar = 0;
if (numRBMs == 2 || numRBMs == 3)
rigidBodyModes->setParameters(neq, numDim, numScalar, numRBMs, setRBMs);
else
TEUCHOS_TEST_FOR_EXCEPTION(true,std::logic_error,"The specified number of RBMs "
<< numRBMs << " is not valid! Valid values are 0, 2 and 3.");
}
// Need to allocate a fields in mesh database
if (params->isParameter("RequiredFields"))
{
// Need to allocate a fields in mesh database
Teuchos::Array<std::string> req = params->get<Teuchos::Array<std::string> > ("Required Fields");
for (int i(0); i<req.size(); ++i)
this->requirements.push_back(req[i]);
}
else
{
this->requirements.push_back("surface_height");
#ifdef CISM_HAS_FELIX
this->requirements.push_back("xgrad_surface_height"); //ds/dx which can be passed from CISM
this->requirements.push_back("ygrad_surface_height"); //ds/dy which can be passed from CISM
#endif
this->requirements.push_back("temperature");
this->requirements.push_back("basal_friction");
this->requirements.push_back("thickness");
this->requirements.push_back("flow_factor");
this->requirements.push_back("surface_velocity");
this->requirements.push_back("surface_velocity_rms");
}
}
void interpolate(const std::vector<double>& positions,
std::vector<double>& results) const
{
Teuchos::Array<double> in(positions.size());
for (int i=0; i<in.size(); i++) in[i] = positions[i];
Teuchos::Array<double> out;
interpolate(in, out);
for (int i=0; i<out.size(); i++) results[i] = out[i];
}
//Neumann BCs
void
Albany::PNPProblem::constructNeumannEvaluators(const Teuchos::RCP<Albany::MeshSpecsStruct>& meshSpecs)
{
// Note: we only enter this function if sidesets are defined in the mesh file
// i.e. meshSpecs.ssNames.size() > 0
Albany::BCUtils<Albany::NeumannTraits> nbcUtils;
// Check to make sure that Neumann BCs are given in the input file
if(!nbcUtils.haveBCSpecified(this->params)) {
return;
}
// Construct BC evaluators for all side sets and names
// Note that the string index sets up the equation offset, so ordering is important
//
// Currently we aren't exactly doing this right. I think to do this
// correctly we need different neumann evaluators for each DOF (velocity,
// pressure, temperature, flux) since velocity is a vector and the
// others are scalars. The dof_names stuff is only used
// for robin conditions, so at this point, as long as we don't enable
// robin conditions, this should work.
std::vector<std::string> nbcNames;
Teuchos::RCP< Teuchos::Array<std::string> > dof_names =
Teuchos::rcp(new Teuchos::Array<std::string>);
// TODO: arbitraty numSpecies
Teuchos::Array<Teuchos::Array<int> > offsets;
int idx = 0;
nbcNames.push_back("C1");
offsets.push_back(Teuchos::Array<int>(1,idx++));
if (numSpecies>=2) {
nbcNames.push_back("C2");
offsets.push_back(Teuchos::Array<int>(1,idx++));
}
if (numSpecies==3) {
nbcNames.push_back("C3");
offsets.push_back(Teuchos::Array<int>(1,idx++));
}
nbcNames.push_back("Phi");
offsets.push_back(Teuchos::Array<int>(1,idx++));
dof_names->push_back("Concentration");
dof_names->push_back("Potential");
// Construct BC evaluators for all possible names of conditions
// Should only specify flux vector components (dudx, dudy, dudz), or dudn, not both
std::vector<std::string> condNames; //dudx, dudy, dudz, dudn, basal
nfm[0] = nbcUtils.constructBCEvaluators(meshSpecs, nbcNames,
Teuchos::arcp(dof_names),
true, 0, condNames, offsets, dl,
this->params, this->paramLib);
}
Teuchos::ArrayView<Integral> getList(Teuchos::Array<Integral> &irl)
{
Teuchos::ArrayView<Integral> av; // av.size() == 0
if (!Zoltan2::allValuesAreInRangeList(irl) &&
!Zoltan2::noValuesAreInRangeList(irl))
av = irl.view(0, irl.size()-1); // skip last value, it's a flag
return av;
}
// Get a Kokkos::View of a Teuchos::ArrayView, and make sure that
// it points to the same data. Thanks to Christian Trott for
// implementing the necessary functionality (View constructor for
// certain View specializations, that takes a raw pointer and
// dimensions) in Kokkos Array.
//
// This example will be useful for implementing the
// Tpetra::MultiVector methods get1dCopy and get2dCopy.
TEUCHOS_UNIT_TEST( LinkTeuchosAndKokkos, ViewOfArrayView ) {
typedef Teuchos::Array<double>::size_type size_type;
typedef Kokkos::View<double*, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::MemoryUnmanaged> ka_view_type;
typedef Kokkos::View<const double*, Kokkos::LayoutLeft, Kokkos::Threads, Kokkos::MemoryUnmanaged> ka_const_view_type;
const size_type numElts = 10;
Teuchos::Array<double> x (numElts);
for (size_type k = 0; k < numElts; ++k) {
x[k] = 42.0 + static_cast<double> (k);
}
// You can make an (unmanaged) View of a raw array with left or
// right (Fortran or C) layout on the HostSpace device, just by passing
// the array and stride(s) into the constructor. If you want the
// dimensions to differ from the strides, you'll have to create a
// subview with the desired dimensions.
ka_view_type x_view (x.getRawPtr (), x.size ());
TEST_EQUALITY( x.size(), static_cast<size_type>(x_view.dimension_0()) );
for (size_type k = 0; k < x.size (); ++k) {
TEST_EQUALITY( x_view[k], x[k] );
}
// This ensures that conversions from double* to const double* work correctly.
// x.getRawPtr() returns double*.
ka_const_view_type x_view_const ( (const double*) x.getRawPtr (), x.size ());
TEST_EQUALITY( x.size(), static_cast<size_type>(x_view_const.dimension_0()) );
for (size_type k = 0; k < x.size (); ++k) {
TEST_EQUALITY( x_view_const[k], x[k] );
}
}
void
Albany::SolutionAverageResponseFunction::
evaluateTangent(const double alpha,
const double beta,
const double /*omega*/,
const double /*current_time*/,
bool /*sum_derivs*/,
const Teuchos::RCP<const Thyra_Vector>& x,
const Teuchos::RCP<const Thyra_Vector>& /*xdot*/,
const Teuchos::RCP<const Thyra_Vector>& /*xdotdot*/,
const Teuchos::Array<ParamVec>& /*p*/,
ParamVec* /*deriv_p*/,
const Teuchos::RCP<const Thyra_MultiVector>& Vx,
const Teuchos::RCP<const Thyra_MultiVector>& /*Vxdot*/,
const Teuchos::RCP<const Thyra_MultiVector>& /*Vxdotdot*/,
const Teuchos::RCP<const Thyra_MultiVector>& /*Vp*/,
const Teuchos::RCP<Thyra_Vector>& g,
const Teuchos::RCP<Thyra_MultiVector>& gx,
const Teuchos::RCP<Thyra_MultiVector>& gp)
{
// Evaluate response g
if (!g.is_null()) {
evaluateResponseImpl(*x,*g);
}
// Evaluate tangent of g: dg/dx*Vx + dg/dxdot*Vxdot + dg/dp*Vp
// = gx + 0 + gp
// If Vx is null, Vx is the identity
if (!gx.is_null()) {
if (!Vx.is_null()) {
if (ones.is_null() || ones->domain()->dim()!=Vx->domain()->dim()) {
ones = Thyra::createMembers(Vx->range(), Vx->domain()->dim());
ones->assign(1.0);
}
Teuchos::Array<ST> means;
means.resize(Vx->domain()->dim());
Vx->dots(*ones,means());
for (auto& mean : means) {
mean /= Vx->domain()->dim();
}
for (int j=0; j<Vx->domain()->dim(); j++) {
gx->col(j)->assign(means[j]);
}
}
else {
gx->assign(1.0/x->space()->dim());
}
gx->scale(alpha);
}
if (!gp.is_null()) {
gp->assign(0.0);
}
}
//! Print eigenpair
void print(std::ostream& os) const {
os << eig_val << ", ";
for (std::size_t i=0; i<eig_pairs.size()-1; i++) {
os << "(";
eig_pairs[i].eig_func->print(os);
os << ") * ";
}
os << "(";
eig_pairs[eig_pairs.size()-1].eig_func->print(os);
os << ")";
}
//! Print all of the views associated with the Matrix.
void PrintViews(Teuchos::FancyOStream &out) const {
int last = out.getOutputToRootOnly();
Teuchos::OSTab tab(out);
out.setOutputToRootOnly(0);
Teuchos::Array<viewLabel_t> viewLabels;
Teuchos::Array<RCP<MatrixView> > viewList;
operatorViewTable_.arrayify(viewLabels,viewList);
out << "views associated with this operator" << std::endl;
for (int i=0; i<viewLabels.size(); ++i)
out << viewLabels[i] << std::endl;
out.setOutputToRootOnly(last);
}