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);
}
//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);
}
// Neumann BCs
void
Albany::HeatProblem::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> bcUtils;
// Check to make sure that Neumann BCs are given in the input file
if(!bcUtils.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> bcNames(neq);
Teuchos::ArrayRCP<std::string> dof_names(neq);
Teuchos::Array<Teuchos::Array<int> > offsets;
offsets.resize(neq);
bcNames[0] = "T";
dof_names[0] = "Temperature";
offsets[0].resize(1);
offsets[0][0] = 0;
// 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(5);
//dudx, dudy, dudz, dudn, scaled jump (internal surface), or robin (like DBC plus scaled jump)
// Note that sidesets are only supported for two and 3D currently
if(numDim == 2)
condNames[0] = "(dudx, dudy)";
else if(numDim == 3)
condNames[0] = "(dudx, dudy, dudz)";
else
TEUCHOS_TEST_FOR_EXCEPTION(true, Teuchos::Exceptions::InvalidParameter,
std::endl << "Error: Sidesets only supported in 2 and 3D." << std::endl);
condNames[1] = "dudn";
condNames[2] = "scaled jump";
condNames[3] = "robin";
condNames[4] = "radiate";
nfm.resize(1); // Heat problem only has one physics set
nfm[0] = bcUtils.constructBCEvaluators(meshSpecs, bcNames, dof_names, false, 0,
condNames, offsets, dl, this->params, this->paramLib, materialDB);
}
// Neumann BCs
void
Albany::PoissonsEquationProblem::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> neuUtils;
// Check to make sure that Neumann BCs are given in the input file
if(!neuUtils.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);
Teuchos::Array<Teuchos::Array<int> > offsets;
offsets.resize(neq);
neumannNames[0] = "P";
offsets[0].resize(1);
offsets[0][0] = 0;
// 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(2); //dudx, dudy, dudz, dudn, P
Teuchos::ArrayRCP<std::string> dof_names(1);
dof_names[0] = "Phi";
// Note that sidesets are only supported for two and 3D currently
if(numDim == 2)
condNames[0] = "(dudx, dudy)";
else if(numDim == 3)
condNames[0] = "(dudx, dudy, dudz)";
else
TEUCHOS_TEST_FOR_EXCEPTION(true, Teuchos::Exceptions::InvalidParameter,
std::endl << "Error: Sidesets only supported in 2 and 3D." << std::endl);
condNames[1] = "dudn";
nfm.resize(1);
nfm[0] = neuUtils.constructBCEvaluators(meshSpecs, neumannNames, dof_names, true, 0,
condNames, offsets, dl,
this->params, this->paramLib);
}
//Neumann BCs
void
Tsunami::Boussinesq::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>);
Teuchos::Array<Teuchos::Array<int> > offsets;
int idx = 0;
nbcNames.push_back("eta");
offsets.push_back(Teuchos::Array<int>(1,idx++));
nbcNames.push_back("ualpha");
offsets.push_back(Teuchos::Array<int>(1,idx++));
if (numDim > 1) {
nbcNames.push_back("valpha");
offsets.push_back(Teuchos::Array<int>(1,idx++));
}
nbcNames.push_back("E1");
offsets.push_back(Teuchos::Array<int>(1,idx++));
if (numDim > 1) {
nbcNames.push_back("E2");
offsets.push_back(Teuchos::Array<int>(1,idx++));
}
// 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(3); //dudx, dudy, dudz, dudn, basal
// Note that sidesets are only supported for two and 3D currently
//
//IKT, FIXME: the following needs to be changed for Tsunami problem!
if(numDim == 2)
condNames[0] = "(dudx, dudy)";
else
TEUCHOS_TEST_FOR_EXCEPTION(true, Teuchos::Exceptions::InvalidParameter,
std::endl << "Error: Sidesets only supported in 2 and 3D." << std::endl);
condNames[1] = "dudn";
condNames[2] = "basal";
nfm.resize(1);
nfm[0] = nbcUtils.constructBCEvaluators(meshSpecs, nbcNames,
Teuchos::arcp(dof_names),
true, 0, condNames, offsets, dl,
this->params, this->paramLib);
}
// Neumann BCs
void
QCAD::PoissonProblem::constructNeumannEvaluators(const Teuchos::RCP<Albany::MeshSpecsStruct>& meshSpecs)
{
using std::string;
// Note: we only enter this function if sidesets are defined in the mesh file
// i.e. meshSpecs.ssNames.size() > 0
Albany::BCUtils<Albany::NeumannTraits> bcUtils;
// Check to make sure that Neumann BCs are given in the input file
if(!bcUtils.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<string> bcNames(neq);
Teuchos::ArrayRCP<string> dof_names(neq);
Teuchos::Array<Teuchos::Array<int> > offsets;
offsets.resize(neq);
bcNames[0] = "Phi";
dof_names[0] = "Potential";
offsets[0].resize(1);
offsets[0][0] = 0;
// Construct BC evaluators for all possible names of conditions
// Should only specify flux vector components (dudx, dudy, dudz), or dudn, not both
std::vector<string> condNames(4);
//dudx, dudy, dudz, dudn, scaled jump (internal surface), or robin (like DBC plus scaled jump)
// Note that sidesets are only supported for two and 3D currently
if(numDim == 2)
condNames[0] = "(dudx, dudy)";
else if(numDim == 3)
condNames[0] = "(dudx, dudy, dudz)";
else
TEUCHOS_TEST_FOR_EXCEPTION(true, Teuchos::Exceptions::InvalidParameter,
std::endl << "Error: Sidesets only supported in 2 and 3D." << std::endl);
condNames[1] = "dudn";
condNames[2] = "scaled jump";
condNames[3] = "robin";
nfm.resize(1); // Poisson problem only has one physics set
//nfm[0] = bcUtils.constructBCEvaluators(meshSpecs, bcNames, dof_names, false, 0,
// condNames, offsets, dl, this->params, this->paramLib, materialDB);
bool isVectorField = false;
int offsetToFirstDOF = 0;
// From here down, this code was copied from constructBCEvaluators call commented out
// above and modified to create QCAD::PoissonNeumann evaluators.
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::ParameterList;
using PHX::DataLayout;
using PHX::MDALayout;
using std::vector;
using PHAL::NeumannFactoryTraits;
using PHAL::AlbanyTraits;
// Drop into the "Neumann BCs" sublist
Teuchos::ParameterList BCparams = this->params->sublist(Albany::NeumannTraits::bcParamsPl);
BCparams.validateParameters(*(Albany::NeumannTraits::getValidBCParameters(meshSpecs->ssNames, bcNames, condNames)),0);
std::map<string, RCP<ParameterList> > evaluators_to_build;
vector<string> bcs;
// Check for all possible standard BCs (every dof on every sideset) to see which is set
for (std::size_t i=0; i<meshSpecs->ssNames.size(); i++) {
for (std::size_t j=0; j<bcNames.size(); j++) {
for (std::size_t k=0; k<condNames.size(); k++) {
// construct input.xml string like:
// "NBC on SS sidelist_12 for DOF T set dudn"
// or
// "NBC on SS sidelist_12 for DOF T set (dudx, dudy)"
// or
// "NBC on SS surface_1 for DOF all set P"
std::string ss = Albany::NeumannTraits::constructBCName(meshSpecs->ssNames[i], bcNames[j], condNames[k]);
// Have a match of the line in input.xml
if (BCparams.isParameter(ss)) {
// std::cout << "Constructing NBC: " << ss << std::endl;
TEUCHOS_TEST_FOR_EXCEPTION(BCparams.isType<string>(ss), std::logic_error,
"NBC array information in XML file must be of type Array(double)\n");
// These are read in the Albany::Neumann constructor (PHAL_Neumann_Def.hpp)
RCP<ParameterList> p = rcp(new ParameterList);
int type = NeumannFactoryTraits<AlbanyTraits>::id_qcad_poisson_neumann;
p->set<int> ("Type", type);
p->set<RCP<ParamLib> > ("Parameter Library", this->paramLib);
//! Additional parameters needed for Poisson Dirichlet BCs
Teuchos::ParameterList& paramList = params->sublist("Poisson Source");
p->set<Teuchos::ParameterList*>("Poisson Source Parameter List", ¶mList);
p->set<double>("Temperature", temperature);
p->set< RCP<QCAD::MaterialDatabase> >("MaterialDB", materialDB);
p->set<double>("Energy unit in eV", energy_unit_in_eV);
p->set<string> ("Side Set ID", meshSpecs->ssNames[i]);
p->set<Teuchos::Array< int > > ("Equation Offset", offsets[j]);
p->set< RCP<Albany::Layouts> > ("Layouts Struct", dl);
p->set< RCP<Albany::MeshSpecsStruct> > ("Mesh Specs Struct", meshSpecs);
p->set<string> ("Coordinate Vector Name", "Coord Vec");
if(condNames[k] == "robin") {
p->set<string> ("DOF Name", dof_names[j]);
p->set<bool> ("Vector Field", isVectorField);
if (isVectorField) {p->set< RCP<DataLayout> >("DOF Data Layout", dl->node_vector);}
else p->set< RCP<DataLayout> >("DOF Data Layout", dl->node_scalar);
}
else if(condNames[k] == "basal") {
std::string betaName = BCparams.get("BetaXY", "Constant");
double L = BCparams.get("L", 1.0);
p->set<string> ("BetaXY", betaName);
p->set<double> ("L", L);
p->set<string> ("DOF Name", dof_names[0]);
p->set<bool> ("Vector Field", isVectorField);
if (isVectorField) {p->set< RCP<DataLayout> >("DOF Data Layout", dl->node_vector);}
else p->set< RCP<DataLayout> >("DOF Data Layout", dl->node_scalar);
}
// Pass the input file line
p->set< string > ("Neumann Input String", ss);
p->set< Teuchos::Array<double> > ("Neumann Input Value", BCparams.get<Teuchos::Array<double> >(ss));
p->set< string > ("Neumann Input Conditions", condNames[k]);
// If we are doing a Neumann internal boundary with a "scaled jump" (includes "robin" too)
// The material DB database needs to be passed to the BC object
if(condNames[k] == "scaled jump" || condNames[k] == "robin"){
TEUCHOS_TEST_FOR_EXCEPTION(materialDB == Teuchos::null,
Teuchos::Exceptions::InvalidParameter,
"This BC needs a material database specified");
p->set< RCP<QCAD::MaterialDatabase> >("MaterialDB", materialDB);
}
// Inputs: X, Y at nodes, Cubature, and Basis
//p->set<string>("Node Variable Name", "Neumann");
std::stringstream ess; ess << "Evaluator for " << ss;
evaluators_to_build[ess.str()] = p;
bcs.push_back(ss);
}
}
}
}
// Build evaluator for Gather Coordinate Vector
string NeuGCV="Evaluator for Gather Coordinate Vector";
{
RCP<ParameterList> p = rcp(new ParameterList);
p->set<int>("Type", Albany::NeumannTraits::typeGCV);
// Input: Periodic BC flag
p->set<bool>("Periodic BC", false);
// Output:: Coordindate Vector at vertices
p->set< RCP<DataLayout> > ("Coordinate Data Layout", dl->vertices_vector);
p->set< string >("Coordinate Vector Name", "Coord Vec");
evaluators_to_build[NeuGCV] = p;
}
// Build evaluator for Gather Solution
string NeuGS="Evaluator for Gather Solution";
{
RCP<ParameterList> p = rcp(new ParameterList());
p->set<int>("Type", Albany::NeumannTraits::typeGS);
// for new way
p->set< RCP<Albany::Layouts> >("Layouts Struct", dl);
p->set< Teuchos::ArrayRCP<std::string> >("Solution Names", dof_names);
p->set<bool>("Vector Field", isVectorField);
if (isVectorField) p->set< RCP<DataLayout> >("Data Layout", dl->node_vector);
else p->set< RCP<DataLayout> >("Data Layout", dl->node_scalar);
p->set<int>("Offset of First DOF", offsetToFirstDOF);
p->set<bool>("Disable Transient", true);
evaluators_to_build[NeuGS] = p;
}
// Build evaluator that causes the evaluation of all the NBCs
string allBC="Evaluator for all Neumann BCs";
{
RCP<ParameterList> p = rcp(new ParameterList);
p->set<int>("Type", Albany::NeumannTraits::typeNa);
p->set<vector<string>* >("NBC Names", &bcs);
p->set< RCP<DataLayout> >("Data Layout", dl->dummy);
p->set<string>("NBC Aggregator Name", allBC);
evaluators_to_build[allBC] = p;
}
// Inlined call to:
// nfm[0] = bcUtils.buildFieldManager(evaluators_to_build, allBC, dl->dummy);
// since function is private -- consider making this public?
// Build Field Evaluators for each evaluation type
PHX::EvaluatorFactory<AlbanyTraits,PHAL::NeumannFactoryTraits<AlbanyTraits> > factory;
RCP< vector< RCP<PHX::Evaluator_TemplateManager<AlbanyTraits> > > > evaluators;
evaluators = factory.buildEvaluators(evaluators_to_build);
// Create a FieldManager
Teuchos::RCP<PHX::FieldManager<AlbanyTraits> > fm
= Teuchos::rcp(new PHX::FieldManager<AlbanyTraits>);
// Register all Evaluators
PHX::registerEvaluators(evaluators, *fm);
PHX::Tag<AlbanyTraits::Residual::ScalarT> res_tag0(allBC, dl->dummy);
fm->requireField<AlbanyTraits::Residual>(res_tag0);
PHX::Tag<AlbanyTraits::Jacobian::ScalarT> jac_tag0(allBC, dl->dummy);
fm->requireField<AlbanyTraits::Jacobian>(jac_tag0);
PHX::Tag<AlbanyTraits::Tangent::ScalarT> tan_tag0(allBC, dl->dummy);
fm->requireField<AlbanyTraits::Tangent>(tan_tag0);
#ifdef ALBANY_SG_MP
PHX::Tag<AlbanyTraits::SGResidual::ScalarT> sgres_tag0(allBC, dl->dummy);
fm->requireField<AlbanyTraits::SGResidual>(sgres_tag0);
PHX::Tag<AlbanyTraits::SGJacobian::ScalarT> sgjac_tag0(allBC, dl->dummy);
fm->requireField<AlbanyTraits::SGJacobian>(sgjac_tag0);
PHX::Tag<AlbanyTraits::SGTangent::ScalarT> sgtan_tag0(allBC, dl->dummy);
fm->requireField<AlbanyTraits::SGTangent>(sgtan_tag0);
PHX::Tag<AlbanyTraits::MPResidual::ScalarT> mpres_tag0(allBC, dl->dummy);
fm->requireField<AlbanyTraits::MPResidual>(mpres_tag0);
PHX::Tag<AlbanyTraits::MPJacobian::ScalarT> mpjac_tag0(allBC, dl->dummy);
fm->requireField<AlbanyTraits::MPJacobian>(mpjac_tag0);
PHX::Tag<AlbanyTraits::MPTangent::ScalarT> mptan_tag0(allBC, dl->dummy);
fm->requireField<AlbanyTraits::MPTangent>(mptan_tag0);
#endif //ALBANY_SG_MP
nfm[0] = fm;
}
//------------------------------------------------------------------------------
// Traction BCs
void
Albany::MechanicsProblem::
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> neuUtils;
// Check to make sure that Neumann BCs are given in the input file
if (!neuUtils.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(neq + 1);
neumannNames[0] = "sig_x";
offsets[0].resize(1);
offsets[0][0] = 0;
// The Neumann BC code uses offsets[neq].size() as num dim, so use num_dims_
// here rather than neq.
offsets[neq].resize(num_dims_);
offsets[neq][0] = 0;
if (num_dims_ > 1) {
neumannNames[1] = "sig_y";
offsets[1].resize(1);
offsets[1][0] = 1;
offsets[neq][1] = 1;
}
if (num_dims_ > 2) {
neumannNames[2] = "sig_z";
offsets[2].resize(1);
offsets[2][0] = 2;
offsets[neq][2] = 2;
}
neumannNames[neq] = "all";
// 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(3); //dudx, dudy, dudz, dudn, P
Teuchos::ArrayRCP<std::string> dof_names(1);
dof_names[0] = "Displacement";
// Note that sidesets are only supported for two and 3D currently
if (num_dims_ == 2)
condNames[0] = "(t_x, t_y)";
else if (num_dims_ == 3)
condNames[0] = "(t_x, t_y, t_z)";
else
TEUCHOS_TEST_FOR_EXCEPTION(true, Teuchos::Exceptions::InvalidParameter,
'\n' << "Error: Sidesets only supported in 2 and 3D." << '\n');
condNames[1] = "dudn";
condNames[2] = "P";
nfm.resize(1); // Elasticity problem only has one element block
nfm[0] = neuUtils.constructBCEvaluators(
meshSpecs,
neumannNames,
dof_names,
true,
0,
condNames,
offsets,
dl_,
this->params,
this->paramLib);
}
// Neumann BCs
void
Aeras::HydrostaticProblem::
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(1 + 1);
Teuchos::Array<Teuchos::Array<int> > offsets;
offsets.resize(1 + 1);
neumannNames[0] = "rho";
offsets[0].resize(1);
offsets[0][0] = 0;
offsets[1].resize(1);
offsets[1][0] = 0;
neumannNames[1] = "all";
// Construct BC evaluators for all possible names of conditions
// Should only specify flux vector components (dUdx, dUdy, dUdz)
std::vector<std::string> condNames(1); //(dUdx, dUdy, dUdz)
Teuchos::ArrayRCP<std::string> dof_names(1);
dof_names[0] = "rho";
// Note that sidesets are only supported for two and 3D currently
if(numDim == 1)
condNames[0] = "(dFluxdx)";
else if(numDim == 2)
condNames[0] = "(dFluxdx, dFluxdy)";
else if(numDim == 3)
condNames[0] = "(dFluxdx, dFluxdy, dFluxdz)";
else
TEUCHOS_TEST_FOR_EXCEPTION(true, Teuchos::Exceptions::InvalidParameter,
std::endl << "Error: Sidesets only supported in 2 and 3D." << std::endl);
// condNames[1] = "dFluxdn";
// condNames[2] = "basal";
// condNames[3] = "P";
// condNames[4] = "lateral";
nfm.resize(1); // Aeras X scalar advection problem only has one
// element block
nfm[0] = nbcUtils.constructBCEvaluators(meshSpecs,
neumannNames,
dof_names,
true,
0,
condNames,
offsets,
dl,
this->params,
this->paramLib);
}
// Neumann BCs
void
FELIX::StokesFOThickness::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(neq + 1);
neumannNames[0] = "U0";
offsets[0].resize(1);
offsets[0][0] = 0;
offsets[neq].resize(neq-1);
offsets[neq][0] = 0;
if (neq-1>1){
neumannNames[1] = "U1";
offsets[1].resize(1);
offsets[1][0] = 1;
offsets[neq][1] = 1;
}
if (neq-1>2){
neumannNames[2] = "U2";
offsets[2].resize(1);
offsets[2][0] = 2;
offsets[neq][2] = 2;
}
neumannNames[neq-1] = "H";
offsets[neq-1].resize(1);
offsets[neq-1][0] = neq-1;
neumannNames[neq] = "all";
// Construct BC evaluators for all possible names of conditions
// Should only specify flux vector components (dCdx, dCdy, dCdz), or dCdn, not both
std::vector<std::string> condNames(6); //(dCdx, dCdy, dCdz), dCdn, basal, P, lateral, basal_scalar_field
Teuchos::ArrayRCP<std::string> dof_names(2);
dof_names[0] = "Velocity";
dof_names[1] = "Thickness";
// Note that sidesets are only supported for two and 3D currently
if(numDim == 2)
condNames[0] = "(dFluxdx, dFluxdy)";
else if(numDim == 3)
condNames[0] = "(dFluxdx, dFluxdy, dFluxdz)";
else
TEUCHOS_TEST_FOR_EXCEPTION(true, Teuchos::Exceptions::InvalidParameter,
std::endl << "Error: Sidesets only supported in 2 and 3D." << std::endl);
condNames[1] = "dFluxdn";
condNames[2] = "basal";
condNames[3] = "P";
condNames[4] = "lateral";
condNames[5] = "basal_scalar_field";
nfm.resize(1); // FELIX problem only has one element block
nfm[0] = nbcUtils.constructBCEvaluators(meshSpecs, neumannNames, dof_names, true, 0,
condNames, offsets, dl,
this->params, this->paramLib);
}