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
Albany::MechanicsProblem::
constructDirichletEvaluators(const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
int index = 0;
if (have_mech_eq_) {
dirichletNames[index++] = "X";
if (num_dims_ > 1) dirichletNames[index++] = "Y";
if (num_dims_ > 2) dirichletNames[index++] = "Z";
}
if (have_temperature_eq_) dirichletNames[index++] = "T";
if (have_pore_pressure_eq_) dirichletNames[index++] = "P";
if (have_transport_eq_) dirichletNames[index++] = "C";
if (have_hydrostress_eq_) dirichletNames[index++] = "TAU";
if (have_damage_eq_) dirichletNames[index++] = "D";
if (have_stab_pressure_eq_) dirichletNames[index++] = "SP";
// Pass on the Application as well that is needed for
// the coupled Schwarz BC. It is just ignored otherwise.
Teuchos::RCP<Albany::Application> const &
application = getApplication();
this->params->set<Teuchos::RCP<Albany::Application>>(
"Application", application);
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames,
this->params, this->paramLib);
}
//------------------------------------------------------------------------------
void
Albany::MechanicsProblem::
constructDirichletEvaluators(const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
int index = 0;
if (have_mech_eq_) {
dirichletNames[index++] = "X";
if (neq > 1) dirichletNames[index++] = "Y";
if (neq > 2) dirichletNames[index++] = "Z";
}
if (have_temperature_eq_) dirichletNames[index++] = "T";
if (have_pore_pressure_eq_) dirichletNames[index++] = "P";
if (have_transport_eq_) dirichletNames[index++] = "C";
if (have_hydrostress_eq_) dirichletNames[index++] = "TAU";
if (have_damage_eq_) dirichletNames[index++] = "D";
if (have_stab_pressure_eq_) dirichletNames[index++] = "SP";
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames,
this->params, this->paramLib);
}
void FELIX::Hydrology::constructDirichletEvaluators (const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
dirichletNames[0] = dof_names[0];
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames, 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);
}
// Dirichlet BCs
void
Albany::CahnHillProblem::constructDirichletEvaluators(const std::vector<std::string>& nodeSetIDs)
{
// Construct BC evaluators for all node sets and names
std::vector<std::string> bcNames(neq);
bcNames[0] = "rho";
Albany::BCUtils<Albany::DirichletTraits> bcUtils;
dfm = bcUtils.constructBCEvaluators(nodeSetIDs, bcNames,
this->params, this->paramLib);
}
// Dirichlet BCs
void
Albany::PoissonsEquationProblem::constructDirichletEvaluators(
const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
dirichletNames[0] = "P";
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames,
this->params, this->paramLib);
}
void
Albany::PeridigmProblem::constructDirichletEvaluators(
const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
dirichletNames[0] = "X";
if (neq>1) dirichletNames[1] = "Y";
if (neq>2) dirichletNames[2] = "Z";
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames, this->params, this->paramLib);
}
void
Albany::Helmholtz2DProblem::constructDirichletEvaluators(
const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
dirichletNames[0] = "U";
dirichletNames[1] = "V";
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames,
this->params, this->paramLib);
offsets_ = dirUtils.getOffsets();
}
// Dirichlet BCs
void
Albany::HeatProblem::constructDirichletEvaluators(const std::vector<std::string>& nodeSetIDs)
{
// Construct BC evaluators for all node sets and names
std::vector<std::string> bcNames(neq);
bcNames[0] = "T";
Albany::BCUtils<Albany::DirichletTraits> bcUtils;
dfm = bcUtils.constructBCEvaluators(nodeSetIDs, bcNames,
this->params, this->paramLib);
use_sdbcs_ = bcUtils.useSDBCs();
offsets_ = bcUtils.getOffsets();
nodeSetIDs_ = bcUtils.getNodeSetIDs();
}
// 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);
}
void
FELIX::StokesFO::constructDirichletEvaluators(
const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
for (int i=0; i<neq; i++) {
std::stringstream s; s << "U" << i;
dirichletNames[i] = s.str();
}
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames,
this->params, this->paramLib);
}
void
Albany::GradientDamageProblem::constructDirichletEvaluators(
const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
dirichletNames[X_offset] = "X";
if (numDim>1) dirichletNames[X_offset+1] = "Y";
if (numDim>2) dirichletNames[X_offset+2] = "Z";
dirichletNames[D_offset] = "D";
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames,
this->params, this->paramLib);
}
void Hydrology::constructDirichletEvaluators (const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
dirichletNames[0] = dofs_names[0];
if (!eliminate_h) {
dirichletNames[1] = dofs_names[1];
}
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames, this->params, this->paramLib);
offsets_ = dirUtils.getOffsets();
nodeSetIDs_ = dirUtils.getNodeSetIDs();
}
void
Albany::ComprNSProblem::constructDirichletEvaluators(
const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
for (int i=0; i<neq; i++) {
std::stringstream s; s << "qFluct" << i;
dirichletNames[i] = s.str();
}
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames,
this->params, this->paramLib);
offsets_ = dirUtils.getOffsets();
}
// 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);
}
// Dirichlet BCs
void
Albany::HMCProblem::constructDirichletEvaluators(
const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
dirichletNames[0] = "X";
if (neq>1) dirichletNames[1] = "Y";
if (neq>2) dirichletNames[2] = "Z";
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames,
this->params, this->paramLib);
use_sdbcs_ = dirUtils.useSDBCs();
offsets_ = dirUtils.getOffsets();
nodeSetIDs_ = dirUtils.getNodeSetIDs();
}
// Dirichlet BCs
void
Albany::HydrideProblem::constructDirichletEvaluators(const std::vector<std::string>& nodeSetIDs)
{
// Construct BC evaluators for all node sets and names
std::vector<std::string> bcNames(neq);
bcNames[0] = "X";
if (numDim>1) bcNames[1] = "Y";
if (numDim>2) bcNames[2] = "Z";
bcNames[numDim] = "c";
bcNames[numDim+1] = "w";
Albany::BCUtils<Albany::DirichletTraits> bcUtils;
dfm = bcUtils.constructBCEvaluators(nodeSetIDs, bcNames,
this->params, this->paramLib);
offsets_ = bcUtils.getOffsets();
}
void
Albany::PNPProblem::constructDirichletEvaluators(
const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
int index = 0;
dirichletNames[index++] = "C1";
// TODO: arbitraty numSpecies
if (numSpecies>=2) dirichletNames[index++] = "C2";
if (numSpecies==3) dirichletNames[index++] = "C3";
dirichletNames[index++] = "Phi";
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames,
this->params, this->paramLib);
}
//------------------------------------------------------------------------------
void
Albany::ConcurrentMultiscaleProblem::
constructDirichletEvaluators(const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
int index = 0;
dirichletNames[index++] = "X";
if (neq>1) dirichletNames[index++] = "Y";
if (neq>2) dirichletNames[index++] = "Z";
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames,
this->params, this->paramLib);
}
void
FELIX::Stokes::constructDirichletEvaluators(
const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
int index = 0;
if (haveFlowEq) {
dirichletNames[index++] = "ux";
if (numDim>=2) dirichletNames[index++] = "uy";
if (numDim==3) dirichletNames[index++] = "uz";
dirichletNames[index++] = "p";
}
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames,
this->params, this->paramLib);
offsets_ = dirUtils.getOffsets();
}
//------------------------------------------------------------------------------
void
Albany::ElectroMechanicsProblem::
constructDirichletEvaluators(const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
int index = 0;
dirichletNames[index++] = "X";
if (num_dims_ > 1) dirichletNames[index++] = "Y";
if (num_dims_ > 2) dirichletNames[index++] = "Z";
dirichletNames[index++] = "Potential";
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames,
this->params, this->paramLib);
offsets_ = dirUtils.getOffsets();
}
void
Albany::NavierStokes::constructDirichletEvaluators(
const std::vector<std::string>& nodeSetIDs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
int index = 0;
if (haveFlowEq) {
dirichletNames[index++] = "ux";
if (numDim>=2) dirichletNames[index++] = "uy";
if (numDim==3) dirichletNames[index++] = "uz";
dirichletNames[index++] = "p";
}
if (haveHeatEq) dirichletNames[index++] = "T";
if (haveNeutEq) dirichletNames[index++] = "phi";
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(nodeSetIDs, dirichletNames,
this->params, this->paramLib);
}
void
Albany::PNPProblem::constructDirichletEvaluators(
const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
int idx = 0;
for(idx = 0; idx<numSpecies; idx++) {
std::stringstream s; s << "C" << (idx+1);
dirichletNames[idx] = s.str();
}
dirichletNames[idx++] = "Phi";
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames,
this->params, this->paramLib);
use_sdbcs_ = dirUtils.useSDBCs();
offsets_ = dirUtils.getOffsets();
nodeSetIDs_ = dirUtils.getNodeSetIDs();
}
void
Tsunami::Boussinesq::constructDirichletEvaluators(
const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(neq);
int index = 0;
dirichletNames[index++] = "eta";
dirichletNames[index++] = "ualpha";
if (numDim > 1)
dirichletNames[index++] = "valpha";
dirichletNames[index++] = "E1";
if (numDim > 1)
dirichletNames[index++] = "E2";
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames, dirichletNames,
this->params, this->paramLib);
use_sdbcs_ = dirUtils.useSDBCs();
offsets_ = dirUtils.getOffsets();
nodeSetIDs_ = dirUtils.getNodeSetIDs();
}
void
Aeras::HydrostaticProblem::constructDirichletEvaluators(
const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(1 + 2*numLevels + numTracers*numLevels);
int dbc=0;
std::ostringstream s;
s << "SPressure";
dirichletNames[dbc++] = s.str();
for (int i=0; i<numLevels; ++i) {
s.str(std::string());
s << "Velx_"<<i;
dirichletNames[dbc++] = s.str();
}
for (int i=0; i<numLevels; ++i) {
s.str(std::string());
s << "Temperature_"<<i;
dirichletNames[dbc++] = s.str();
}
for (int t=0; t<numTracers; ++t) {
for (int i=0; i<numLevels; ++i) {
s.str(std::string());
s << dof_names_tracers[t]<<"_"<<i;
dirichletNames[dbc++] = s.str();
}
}
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames,
dirichletNames,
this->params,
this->paramLib);
}
void
Aeras::XScalarAdvectionProblem::constructDirichletEvaluators(
const Albany::MeshSpecsStruct& meshSpecs)
{
// Construct Dirichlet evaluators for all nodesets and names
std::vector<std::string> dirichletNames(numLevels*(1+numTracers));
std::ostringstream s;
for (int i=0,n=0; i<numLevels; ++i) {
s.str(std::string());
s << "rho_"<<i;
dirichletNames[n++] = s.str();
for (int j=0; j<numTracers; ++j) {
s.str(std::string());
s << dof_names_tracers[j] <<"_"<<i;
dirichletNames[n++] = s.str();
}
}
Albany::BCUtils<Albany::DirichletTraits> dirUtils;
dfm = dirUtils.constructBCEvaluators(meshSpecs.nsNames,
dirichletNames,
this->params,
this->paramLib);
offsets_ = dirUtils.getOffsets();
}
// 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
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);
}
//------------------------------------------------------------------------------
// 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);
}