Albany::OrdinarySTKFieldContainer<Interleaved>::OrdinarySTKFieldContainer(
const Teuchos::RCP<Teuchos::ParameterList>& params_,
const Teuchos::RCP<stk::mesh::MetaData>& metaData_,
const Teuchos::RCP<stk::mesh::BulkData>& bulkData_,
const int neq_,
const AbstractFieldContainer::FieldContainerRequirements& req,
const int numDim_,
const Teuchos::RCP<Albany::StateInfoStruct>& sis)
: GenericSTKFieldContainer<Interleaved>(params_, metaData_, bulkData_, neq_, numDim_),
buildSphereVolume(false) {
typedef typename AbstractSTKFieldContainer::VectorFieldType VFT;
typedef typename AbstractSTKFieldContainer::ScalarFieldType SFT;
typedef typename AbstractSTKFieldContainer::SphereVolumeFieldType SVFT;
int num_time_deriv = params_->get<int>("Number Of Time Derivatives");
//Start STK stuff
this->coordinates_field = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, "coordinates");
stk::mesh::put_field(*this->coordinates_field , metaData_->universal_part(), numDim_);
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*this->coordinates_field, Ioss::Field::MESH);
#endif
solution_field.resize(num_time_deriv + 1);
solution_field_dtk.resize(num_time_deriv + 1);
for(int num_vecs = 0; num_vecs <= num_time_deriv; num_vecs++){
solution_field[num_vecs] = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK,
params_->get<std::string>(sol_tag_name[num_vecs], sol_id_name[num_vecs]));
stk::mesh::put_field(*solution_field[num_vecs] , metaData_->universal_part(), neq_);
#if defined(ALBANY_DTK)
solution_field_dtk[num_vecs] = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK,
params_->get<std::string>(res_tag_name[num_vecs], sol_dtk_id_name[num_vecs]));
stk::mesh::put_field(*solution_field_dtk[num_vecs] , metaData_->universal_part() , neq_);
#endif
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*solution_field[num_vecs], Ioss::Field::TRANSIENT);
#if defined(ALBANY_DTK)
stk::io::set_field_role(*solution_field_dtk[num_vecs], Ioss::Field::TRANSIENT);
#endif
#endif
}
#if defined(ALBANY_LCM)
residual_field = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK,
params_->get<std::string>(res_tag_name[0], res_id_name[0]));
stk::mesh::put_field(*residual_field, metaData_->universal_part() , neq_);
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*residual_field, Ioss::Field::TRANSIENT);
#endif
#endif
#if defined(ALBANY_LCM) && defined(ALBANY_SEACAS)
// sphere volume is a mesh attribute read from a genesis mesh file containing sphere element (used for peridynamics)
bool hasSphereVolumeFieldContainerRequirement = (std::find(req.begin(), req.end(), "Sphere Volume") != req.end());
if(hasSphereVolumeFieldContainerRequirement){
this->sphereVolume_field = metaData_->template get_field< SVFT >(stk::topology::ELEMENT_RANK, "volume");
if(this->sphereVolume_field != 0){
buildSphereVolume = true;
stk::io::set_field_role(*this->sphereVolume_field, Ioss::Field::ATTRIBUTE);
}
}
#endif
// If the problem requests that the initial guess at the solution equals the input node coordinates,
// set that here
/*
if(std::find(req.begin(), req.end(), "Initial Guess Coords") != req.end()){
this->copySTKField(this->coordinates_field, solution_field);
}
*/
this->addStateStructs(sis);
initializeSTKAdaptation();
}
Albany::OrdinarySTKFieldContainer<Interleaved>::OrdinarySTKFieldContainer(
const Teuchos::RCP<Teuchos::ParameterList>& params_,
const Teuchos::RCP<stk::mesh::MetaData>& metaData_,
const int neq_,
const AbstractFieldContainer::FieldContainerRequirements& req,
const int numDim_,
const Teuchos::RCP<Albany::StateInfoStruct>& sis)
: GenericSTKFieldContainer<Interleaved>(params_, metaData_, neq_, numDim_),
buildSphereVolume(false) {
typedef typename AbstractSTKFieldContainer::VectorFieldType VFT;
typedef typename AbstractSTKFieldContainer::ScalarFieldType SFT;
#ifdef ALBANY_LCM
buildSphereVolume = (std::find(req.begin(), req.end(), "Sphere Volume") != req.end());
#endif
//Start STK stuff
this->coordinates_field = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, "coordinates");
solution_field = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK,
params_->get<std::string>("Exodus Solution Name", "solution"));
#ifdef ALBANY_LCM
residual_field = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK,
params_->get<std::string>("Exodus Residual Name", "residual"));
#endif
stk::mesh::put_field(*this->coordinates_field , metaData_->universal_part(), numDim_);
stk::mesh::put_field(*solution_field , metaData_->universal_part(), neq_);
#ifdef ALBANY_LCM
stk::mesh::put_field(*residual_field , metaData_->universal_part() , neq_);
#endif
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*this->coordinates_field, Ioss::Field::MESH);
stk::io::set_field_role(*solution_field, Ioss::Field::TRANSIENT);
#ifdef ALBANY_LCM
stk::io::set_field_role(*residual_field, Ioss::Field::TRANSIENT);
#endif
#endif
#ifdef ALBANY_LCM
// sphere volume is a mesh attribute read from a genesis mesh file containing sphere element (used for peridynamics)
if(buildSphereVolume){
this->sphereVolume_field = metaData_->get_field< stk::mesh::Field<double> >(stk::topology::ELEMENT_RANK, "volume");
TEUCHOS_TEST_FOR_EXCEPTION(this->sphereVolume_field == 0, std::logic_error, "\n**** Error: Expected volume field for sphere elements, field not found.\n");
stk::io::set_field_role(*this->sphereVolume_field, Ioss::Field::ATTRIBUTE);
}
#endif
// If the problem requests that the initial guess at the solution equals the input node coordinates,
// set that here
/*
if(std::find(req.begin(), req.end(), "Initial Guess Coords") != req.end()){
this->copySTKField(this->coordinates_field, solution_field);
}
*/
this->buildStateStructs(sis);
initializeSTKAdaptation();
}
Albany::OrdinarySTKFieldContainer<Interleaved>::OrdinarySTKFieldContainer(
const Teuchos::RCP<Teuchos::ParameterList>& params_,
stk::mesh::fem::FEMMetaData* metaData_,
stk::mesh::BulkData* bulkData_,
const int neq_,
const AbstractFieldContainer::FieldContainerRequirements& req,
const int numDim_,
const Teuchos::RCP<Albany::StateInfoStruct>& sis)
: GenericSTKFieldContainer<Interleaved>(params_, metaData_, bulkData_, neq_, numDim_),
buildSurfaceHeight(false),
buildTemperature(false),
buildBasalFriction(false),
buildThickness(false),
buildFlowFactor(false),
buildSurfaceVelocity(false),
buildVelocityRMS(false) {
typedef typename AbstractSTKFieldContainer::VectorFieldType VFT;
typedef typename AbstractSTKFieldContainer::ScalarFieldType SFT;
#ifdef ALBANY_FELIX
buildSurfaceHeight = (std::find(req.begin(), req.end(), "Surface Height") != req.end());
buildTemperature = (std::find(req.begin(), req.end(), "Temperature") != req.end());
buildBasalFriction = (std::find(req.begin(), req.end(), "Basal Friction") != req.end());
buildThickness = (std::find(req.begin(), req.end(), "Thickness") != req.end());
buildFlowFactor = (std::find(req.begin(), req.end(), "Flow Factor") != req.end());
buildSurfaceVelocity = (std::find(req.begin(), req.end(), "Surface Velocity") != req.end());
buildVelocityRMS = (std::find(req.begin(), req.end(), "Velocity RMS") != req.end());
#endif
//Start STK stuff
this->coordinates_field = & metaData_->declare_field< VFT >("coordinates");
solution_field = & metaData_->declare_field< VFT >(
params_->get<std::string>("Exodus Solution Name", "solution"));
#ifdef ALBANY_LCM
residual_field = & metaData_->declare_field< VFT >(
params_->get<std::string>("Exodus Residual Name", "residual"));
#endif
#ifdef ALBANY_FELIX
if(buildSurfaceHeight)
this->surfaceHeight_field = & metaData_->declare_field< SFT >("surface_height");
if(buildTemperature)
this->temperature_field = & metaData_->declare_field< SFT >("temperature");
if(buildBasalFriction)
this->basalFriction_field = & metaData_->declare_field< SFT >("basal_friction");
if(buildThickness)
this->thickness_field = & metaData_->declare_field< SFT >("thickness");
if(buildFlowFactor)
this->flowFactor_field = & metaData_->declare_field< SFT >("flow_factor");
if(buildSurfaceVelocity)
this->surfaceVelocity_field = & metaData_->declare_field< VFT >("surface_velocity");
if(buildVelocityRMS)
this->velocityRMS_field = & metaData_->declare_field< VFT >("velocity_RMS");
#endif
stk::mesh::put_field(*this->coordinates_field , metaData_->node_rank() , metaData_->universal_part(), numDim_);
stk::mesh::put_field(*solution_field , metaData_->node_rank() , metaData_->universal_part(), neq_);
#ifdef ALBANY_LCM
stk::mesh::put_field(*residual_field , metaData_->node_rank() , metaData_->universal_part() , neq_);
#endif
#ifdef ALBANY_FELIX
if(buildSurfaceHeight)
stk::mesh::put_field( *this->surfaceHeight_field , metaData_->node_rank() , metaData_->universal_part());
if(buildTemperature)
stk::mesh::put_field( *this->temperature_field , metaData_->element_rank() , metaData_->universal_part());
if(buildBasalFriction)
stk::mesh::put_field( *this->basalFriction_field , metaData_->node_rank() , metaData_->universal_part());//*metaData_->get_part("basalside","Mpas Interface"));
if(buildThickness)
stk::mesh::put_field( *this->thickness_field , metaData_->node_rank() , metaData_->universal_part());
if(buildFlowFactor)
stk::mesh::put_field( *this->flowFactor_field , metaData_->element_rank() , metaData_->universal_part());
if(buildSurfaceVelocity)
stk::mesh::put_field( *this->surfaceVelocity_field , metaData_->node_rank() , metaData_->universal_part(), neq_);
if(buildVelocityRMS)
stk::mesh::put_field( *this->velocityRMS_field , metaData_->node_rank() , metaData_->universal_part(), neq_);
#endif
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*this->coordinates_field, Ioss::Field::MESH);
stk::io::set_field_role(*solution_field, Ioss::Field::TRANSIENT);
#ifdef ALBANY_LCM
stk::io::set_field_role(*residual_field, Ioss::Field::TRANSIENT);
#endif
#ifdef ALBANY_FELIX
// ATTRIBUTE writes only once per file, but somehow did not work on restart.
//stk::io::set_field_role(*surfaceHeight_field, Ioss::Field::ATTRIBUTE);
if(buildSurfaceHeight)
stk::io::set_field_role(*this->surfaceHeight_field, Ioss::Field::TRANSIENT);
if(buildTemperature)
stk::io::set_field_role(*this->temperature_field, Ioss::Field::TRANSIENT);
if(buildBasalFriction)
stk::io::set_field_role(*this->basalFriction_field, Ioss::Field::TRANSIENT);
if(buildThickness)
stk::io::set_field_role(*this->thickness_field, Ioss::Field::TRANSIENT);
if(buildFlowFactor)
stk::io::set_field_role(*this->flowFactor_field, Ioss::Field::TRANSIENT);
if(buildSurfaceVelocity)
stk::io::set_field_role(*this->surfaceVelocity_field, Ioss::Field::TRANSIENT);
if(buildVelocityRMS)
stk::io::set_field_role(*this->velocityRMS_field, Ioss::Field::TRANSIENT);
#endif
#endif
// If the problem requests that the initial guess at the solution equals the input node coordinates,
// set that here
/*
if(std::find(req.begin(), req.end(), "Initial Guess Coords") != req.end()){
this->copySTKField(this->coordinates_field, solution_field);
}
*/
this->buildStateStructs(sis);
initializeSTKAdaptation();
}
Albany::OrdinarySTKFieldContainer<Interleaved>::OrdinarySTKFieldContainer(
const Teuchos::RCP<Teuchos::ParameterList>& params_,
const Teuchos::RCP<stk::mesh::MetaData>& metaData_,
const int neq_,
const AbstractFieldContainer::FieldContainerRequirements& req,
const int numDim_,
const Teuchos::RCP<Albany::StateInfoStruct>& sis)
: GenericSTKFieldContainer<Interleaved>(params_, metaData_, neq_, numDim_),
buildSphereVolume(false) {
typedef typename AbstractSTKFieldContainer::VectorFieldType VFT;
typedef typename AbstractSTKFieldContainer::ScalarFieldType SFT;
//Start STK stuff
this->coordinates_field = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, "coordinates");
solution_field = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK,
params_->get<std::string>("Exodus Solution Name", "solution"));
#if defined(ALBANY_LCM)
residual_field = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK,
params_->get<std::string>("Exodus Residual Name", "residual"));
#endif
stk::mesh::put_field(*this->coordinates_field , metaData_->universal_part(), numDim_);
stk::mesh::put_field(*solution_field , metaData_->universal_part(), neq_);
#if defined(ALBANY_LCM)
stk::mesh::put_field(*residual_field , metaData_->universal_part() , neq_);
#endif
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*this->coordinates_field, Ioss::Field::MESH);
stk::io::set_field_role(*solution_field, Ioss::Field::TRANSIENT);
#if defined(ALBANY_LCM)
stk::io::set_field_role(*residual_field, Ioss::Field::TRANSIENT);
#endif
#endif
#if defined(ALBANY_LCM)
// sphere volume is a mesh attribute read from a genesis mesh file containing sphere element (used for peridynamics)
// for whatever reason, its type is stk::mesh::Field<double, stk::mesh::Cartesian3d>
// the read won't work if you try to read it as a SFT
bool hasSphereVolumeFieldContainerRequirement = (std::find(req.begin(), req.end(), "Sphere Volume") != req.end());
if(hasSphereVolumeFieldContainerRequirement){
this->sphereVolume_field = metaData_->template get_field< stk::mesh::Field<double, stk::mesh::Cartesian3d> >(stk::topology::ELEMENT_RANK, "volume");
if(this->sphereVolume_field != 0){
buildSphereVolume = true;
stk::io::set_field_role(*this->sphereVolume_field, Ioss::Field::ATTRIBUTE);
}
}
#endif
// If the problem requests that the initial guess at the solution equals the input node coordinates,
// set that here
/*
if(std::find(req.begin(), req.end(), "Initial Guess Coords") != req.end()){
this->copySTKField(this->coordinates_field, solution_field);
}
*/
this->buildStateStructs(sis);
initializeSTKAdaptation();
}
Albany::MultiSTKFieldContainer<Interleaved>::MultiSTKFieldContainer(
const Teuchos::RCP<Teuchos::ParameterList>& params_,
const Teuchos::RCP<stk::mesh::MetaData>& metaData_,
const Teuchos::RCP<stk::mesh::BulkData>& bulkData_,
const int neq_,
const AbstractFieldContainer::FieldContainerRequirements& req,
const int numDim_,
const Teuchos::RCP<Albany::StateInfoStruct>& sis,
const Teuchos::Array<Teuchos::Array<std::string> >& solution_vector,
const Teuchos::Array<std::string>& residual_vector)
: GenericSTKFieldContainer<Interleaved>(params_, metaData_, bulkData_, neq_, numDim_),
haveResidual(false), buildSphereVolume(false) {
typedef typename AbstractSTKFieldContainer::VectorFieldType VFT;
typedef typename AbstractSTKFieldContainer::ScalarFieldType SFT;
typedef typename AbstractSTKFieldContainer::SphereVolumeFieldType SVFT;
sol_vector_name.resize(solution_vector.size());
sol_index.resize(solution_vector.size());
// Check the input
for(int vec_num = 0; vec_num < solution_vector.size(); vec_num++){
if(solution_vector[vec_num].size() == 0) { // Do the default solution vector
std::string name = params_->get<std::string>(sol_tag_name[vec_num], sol_id_name[vec_num]);
VFT* solution = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, name);
stk::mesh::put_field(*solution, metaData_->universal_part(), neq_);
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*solution, Ioss::Field::TRANSIENT);
#endif
sol_vector_name[vec_num].push_back(name);
sol_index[vec_num].push_back(this->neq);
}
else if(solution_vector[vec_num].size() == 1) { // User is just renaming the entire solution vector
VFT* solution = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, solution_vector[vec_num][0]);
stk::mesh::put_field(*solution, metaData_->universal_part(), neq_);
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*solution, Ioss::Field::TRANSIENT);
#endif
sol_vector_name[vec_num].push_back(solution_vector[vec_num][0]);
sol_index[vec_num].push_back(neq_);
}
else { // user is breaking up the solution into multiple fields
// make sure the number of entries is even
TEUCHOS_TEST_FOR_EXCEPTION((solution_vector[vec_num].size() % 2), std::logic_error,
"Error in input file: specification of solution vector layout is incorrect." << std::endl);
int len, accum = 0;
for(int i = 0; i < solution_vector[vec_num].size(); i += 2) {
if(solution_vector[vec_num][i + 1] == "V") {
len = numDim_; // vector
accum += len;
VFT* solution = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, solution_vector[vec_num][i]);
stk::mesh::put_field(*solution, metaData_->universal_part(), len);
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*solution, Ioss::Field::TRANSIENT);
#endif
sol_vector_name[vec_num].push_back(solution_vector[vec_num][i]);
sol_index[vec_num].push_back(len);
}
else if(solution_vector[vec_num][i + 1] == "S") {
len = 1; // scalar
accum += len;
SFT* solution = & metaData_->declare_field< SFT >(stk::topology::NODE_RANK, solution_vector[vec_num][i]);
stk::mesh::put_field(*solution, metaData_->universal_part());
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*solution, Ioss::Field::TRANSIENT);
#endif
sol_vector_name[vec_num].push_back(solution_vector[vec_num][i]);
sol_index[vec_num].push_back(len);
}
else
TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
"Error in input file: specification of solution vector layout is incorrect." << std::endl);
}
TEUCHOS_TEST_FOR_EXCEPTION(accum != neq_, std::logic_error,
"Error in input file: specification of solution vector layout is incorrect." << std::endl);
}
}
#if defined(ALBANY_LCM)
// do the residual next
if(residual_vector.size() == 0) { // Do the default residual vector
std::string name = params_->get<std::string>(res_tag_name, res_id_name);
VFT* residual = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, name);
stk::mesh::put_field(*residual, metaData_->universal_part(), neq_);
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*residual, Ioss::Field::TRANSIENT);
#endif
res_vector_name.push_back(name);
res_index.push_back(neq_);
}
else if(residual_vector.size() == 1) { // User is just renaming the entire residual vector
VFT* residual = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, residual_vector[0]);
stk::mesh::put_field(*residual, metaData_->universal_part(), neq_);
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*residual, Ioss::Field::TRANSIENT);
#endif
res_vector_name.push_back(residual_vector[0]);
res_index.push_back(neq_);
}
else { // user is breaking up the residual into multiple fields
// make sure the number of entries is even
TEUCHOS_TEST_FOR_EXCEPTION((residual_vector.size() % 2), std::logic_error,
"Error in input file: specification of residual vector layout is incorrect." << std::endl);
int len, accum = 0;
for(int i = 0; i < residual_vector.size(); i += 2) {
if(residual_vector[i + 1] == "V") {
len = numDim_; // vector
accum += len;
VFT* residual = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, residual_vector[i]);
stk::mesh::put_field(*residual, metaData_->universal_part(), len);
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*residual, Ioss::Field::TRANSIENT);
#endif
res_vector_name.push_back(residual_vector[i]);
res_index.push_back(len);
}
else if(residual_vector[i + 1] == "S") {
len = 1; // scalar
accum += len;
SFT* residual = & metaData_->declare_field< SFT >(stk::topology::NODE_RANK, residual_vector[i]);
stk::mesh::put_field(*residual, metaData_->universal_part());
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*residual, Ioss::Field::TRANSIENT);
#endif
res_vector_name.push_back(residual_vector[i]);
res_index.push_back(len);
}
else
TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
"Error in input file: specification of residual vector layout is incorrect." << std::endl);
}
TEUCHOS_TEST_FOR_EXCEPTION(accum != neq_, std::logic_error,
"Error in input file: specification of residual vector layout is incorrect." << std::endl);
}
haveResidual = true;
#endif
//Do the coordinates
this->coordinates_field = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, "coordinates");
stk::mesh::put_field(*this->coordinates_field , metaData_->universal_part(), numDim_);
#ifdef ALBANY_SEACAS
stk::io::set_field_role(*this->coordinates_field, Ioss::Field::MESH);
#endif
#if defined(ALBANY_LCM) && defined(ALBANY_SEACAS)
// sphere volume is a mesh attribute read from a genesis mesh file containing sphere element (used for peridynamics)
bool hasSphereVolumeFieldContainerRequirement = (std::find(req.begin(), req.end(), "Sphere Volume") != req.end());
if(hasSphereVolumeFieldContainerRequirement){
this->sphereVolume_field = metaData_->template get_field< SVFT >(stk::topology::ELEMENT_RANK, "volume");
if(this->sphereVolume_field != 0){
buildSphereVolume = true;
stk::io::set_field_role(*this->sphereVolume_field, Ioss::Field::ATTRIBUTE);
}
}
#endif
this->addStateStructs(sis);
initializeSTKAdaptation();
}
