FeatureFloodCount::FeatureFloodCount(const InputParameters & parameters) :
GeneralPostprocessor(parameters),
Coupleable(parameters, false),
MooseVariableDependencyInterface(),
ZeroInterface(parameters),
_vars(getCoupledMooseVars()),
_threshold(getParam<Real>("threshold")),
_connecting_threshold(isParamValid("connecting_threshold") ? getParam<Real>("connecting_threshold") : getParam<Real>("threshold")),
_mesh(_subproblem.mesh()),
_var_number(_vars[0]->number()),
_single_map_mode(getParam<bool>("use_single_map")),
_condense_map_info(getParam<bool>("condense_map_info")),
_global_numbering(getParam<bool>("use_global_numbering")),
_var_index_mode(getParam<bool>("enable_var_coloring")),
_use_less_than_threshold_comparison(getParam<bool>("use_less_than_threshold_comparison")),
_maps_size(_single_map_mode ? 1 : _vars.size()),
_entities_visited(_vars.size()), // This map is always sized to the number of variables
_feature_count(0),
_partial_feature_sets(_app.n_processors()),
_feature_sets(_maps_size),
_feature_maps(_maps_size),
_pbs(NULL),
_element_average_value(parameters.isParamValid("elem_avg_value") ? getPostprocessorValue("elem_avg_value") : _real_zero),
_compute_boundary_intersecting_volume(getParam<bool>("compute_boundary_intersecting_volume")),
_is_elemental(getParam<MooseEnum>("flood_entity_type") == "ELEMENTAL" ? true : false)
{
// Size the data structures to hold the correct number of maps
for (unsigned int rank = 0; rank < _app.n_processors(); ++rank)
_partial_feature_sets[rank].resize(_maps_size);
if (_var_index_mode)
_var_index_maps.resize(_maps_size);
}
// DEPRECATED CONSTRUCTOR
ElementUserObject::ElementUserObject(const std::string & deprecated_name, InputParameters parameters) :
UserObject(deprecated_name, parameters),
BlockRestrictable(parameters),
MaterialPropertyInterface(parameters, blockIDs()),
UserObjectInterface(parameters),
Coupleable(parameters, false),
ScalarCoupleable(parameters),
MooseVariableDependencyInterface(),
TransientInterface(parameters, "element_user_objects"),
PostprocessorInterface(parameters),
RandomInterface(parameters, _fe_problem, _tid, false),
ZeroInterface(parameters),
_mesh(_subproblem.mesh()),
_current_elem(_assembly.elem()),
_current_elem_volume(_assembly.elemVolume()),
_q_point(_assembly.qPoints()),
_qrule(_assembly.qRule()),
_JxW(_assembly.JxW()),
_coord(_assembly.coordTransformation())
{
// Keep track of which variables are coupled so we know what we depend on
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
}
SideUserObject::SideUserObject(const std::string & name, InputParameters parameters) :
UserObject(name, parameters),
BoundaryRestrictable(name, parameters),
MaterialPropertyInterface(parameters),
Coupleable(parameters, false),
MooseVariableDependencyInterface(),
UserObjectInterface(parameters),
TransientInterface(parameters, name, "side_user_objects"),
PostprocessorInterface(parameters),
ZeroInterface(parameters),
_mesh(_subproblem.mesh()),
_q_point(_assembly.qPointsFace()),
_qrule(_assembly.qRuleFace()),
_JxW(_assembly.JxWFace()),
_coord(_assembly.coordTransformation()),
_normals(_assembly.normals()),
_current_elem(_assembly.elem()),
_current_side(_assembly.side()),
_current_side_elem(_assembly.sideElem()),
_current_side_volume(_assembly.sideElemVolume())
{
// Keep track of which variables are coupled so we know what we depend on
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
}
InterfaceUserObject::InterfaceUserObject(const InputParameters & parameters)
: UserObject(parameters),
BoundaryRestrictableRequired(this, false), // false for applying to sidesets
TwoMaterialPropertyInterface(this, Moose::EMPTY_BLOCK_IDS, boundaryIDs()),
NeighborCoupleable(this, false, false),
MooseVariableDependencyInterface(),
UserObjectInterface(this),
TransientInterface(this),
PostprocessorInterface(this),
_mesh(_subproblem.mesh()),
_q_point(_assembly.qPointsFace()),
_qrule(_assembly.qRuleFace()),
_JxW(_assembly.JxWFace()),
_coord(_assembly.coordTransformation()),
_normals(_assembly.normals()),
_current_elem(_assembly.elem()),
_current_side(_assembly.side()),
_current_side_elem(_assembly.sideElem()),
_current_side_volume(_assembly.sideElemVolume()),
_neighbor_elem(_assembly.neighbor()),
_current_neighbor_volume(_assembly.neighborVolume())
{
// Keep track of which variables are coupled so we know what we depend on
const std::vector<MooseVariableFEBase *> & coupled_vars = getCoupledMooseVars();
for (const auto & var : coupled_vars)
addMooseVariableDependency(var);
}
NodalFloodCount::NodalFloodCount(const std::string & name, InputParameters parameters) :
GeneralPostprocessor(name, parameters),
Coupleable(parameters, false),
MooseVariableDependencyInterface(),
ZeroInterface(parameters),
_vars(getCoupledMooseVars()),
_threshold(getParam<Real>("threshold")),
_connecting_threshold(isParamValid("connecting_threshold") ? getParam<Real>("connecting_threshold") : getParam<Real>("threshold")),
_mesh(_subproblem.mesh()),
_var_number(_vars[0]->number()),
_single_map_mode(getParam<bool>("use_single_map")),
_condense_map_info(getParam<bool>("condense_map_info")),
_global_numbering(getParam<bool>("use_global_numbering")),
_var_index_mode(getParam<bool>("enable_var_coloring")),
_maps_size(_single_map_mode ? 1 : _vars.size()),
_pbs(NULL),
_element_average_value(parameters.isParamValid("elem_avg_value") ? getPostprocessorValue("elem_avg_value") : _real_zero),
_track_memory(getParam<bool>("track_memory_usage"))
// _bubble_volume_file_name(parameters.isParamValid("bubble_volume_file") ? getParam<FileName>("bubble_volume_file") : "")
{
// Size the data structures to hold the correct number of maps
_bubble_maps.resize(_maps_size);
_bubble_sets.resize(_maps_size);
_region_counts.resize(_maps_size);
_region_offsets.resize(_maps_size);
if (_var_index_mode)
_var_index_maps.resize(_maps_size);
// This map is always size to the number of variables
_nodes_visited.resize(_vars.size());
}
ElementIndicator::ElementIndicator(const std::string & name, InputParameters parameters) :
Indicator(name, parameters),
TransientInterface(parameters, name, "indicators"),
PostprocessorInterface(parameters),
Coupleable(parameters, false),
ScalarCoupleable(parameters),
MooseVariableInterface(parameters, false),
MaterialPropertyInterface(parameters),
ZeroInterface(parameters),
_field_var(_sys.getVariable(_tid, name)),
_current_elem(_field_var.currentElem()),
_current_elem_volume(_assembly.elemVolume()),
_q_point(_assembly.qPoints()),
_qrule(_assembly.qRule()),
_JxW(_assembly.JxW()),
_coord(_assembly.coordTransformation()),
_var(_subproblem.getVariable(_tid, parameters.get<VariableName>("variable"))),
_u(_var.sln()),
_grad_u(_var.gradSln()),
_u_dot(_var.uDot()),
_du_dot_du(_var.duDotDu())
{
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for(unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
addMooseVariableDependency(mooseVariable());
}
NodalScalarKernel::NodalScalarKernel(const InputParameters & parameters) :
ScalarKernel(parameters),
Coupleable(parameters, true),
MooseVariableDependencyInterface(),
_node_ids(getParam<std::vector<dof_id_type> >("nodes"))
{
// Fill in the MooseVariable dependencies
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
}
AuxNodalScalarKernel::AuxNodalScalarKernel(const InputParameters & parameters)
: AuxScalarKernel(parameters),
Coupleable(this, true),
MooseVariableDependencyInterface(),
_node_ids(getParam<std::vector<dof_id_type>>("nodes"))
{
// Fill in the MooseVariable dependencies
const std::vector<MooseVariableFEBase *> & coupled_vars = getCoupledMooseVars();
for (const auto & var : coupled_vars)
addMooseVariableDependency(var);
}
Material::Material(const InputParameters & parameters)
: MooseObject(parameters),
BlockRestrictable(this),
BoundaryRestrictable(this, blockIDs(), false), // false for being _not_ nodal
SetupInterface(this),
Coupleable(this, false),
MooseVariableDependencyInterface(),
ScalarCoupleable(this),
FunctionInterface(this),
DistributionInterface(this),
UserObjectInterface(this),
TransientInterface(this),
MaterialPropertyInterface(this, blockIDs(), boundaryIDs()),
PostprocessorInterface(this),
VectorPostprocessorInterface(this),
DependencyResolverInterface(),
Restartable(this, "Materials"),
MeshChangedInterface(parameters),
// The false flag disables the automatic call buildOutputVariableHideList;
// for Material objects the hide lists are handled by MaterialOutputAction
OutputInterface(parameters, false),
RandomInterface(parameters,
*parameters.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base"),
parameters.get<THREAD_ID>("_tid"),
false),
_subproblem(*getCheckedPointerParam<SubProblem *>("_subproblem")),
_fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
_tid(parameters.get<THREAD_ID>("_tid")),
_assembly(_subproblem.assembly(_tid)),
_bnd(_material_data_type != Moose::BLOCK_MATERIAL_DATA),
_neighbor(_material_data_type == Moose::NEIGHBOR_MATERIAL_DATA),
_qp(std::numeric_limits<unsigned int>::max()),
_qrule(_bnd ? _assembly.qRuleFace() : _assembly.qRule()),
_JxW(_bnd ? _assembly.JxWFace() : _assembly.JxW()),
_coord(_assembly.coordTransformation()),
_q_point(_bnd ? _assembly.qPointsFace() : _assembly.qPoints()),
_normals(_assembly.normals()),
_current_elem(_neighbor ? _assembly.neighbor() : _assembly.elem()),
_current_subdomain_id(_neighbor ? _assembly.currentNeighborSubdomainID()
: _assembly.currentSubdomainID()),
_current_side(_neighbor ? _assembly.neighborSide() : _assembly.side()),
_mesh(_subproblem.mesh()),
_coord_sys(_assembly.coordSystem()),
_compute(getParam<bool>("compute")),
_constant_option(getParam<MooseEnum>("constant_on").getEnum<ConstantTypeEnum>()),
_has_stateful_property(false)
{
// Fill in the MooseVariable dependencies
const std::vector<MooseVariableFE *> & coupled_vars = getCoupledMooseVars();
for (const auto & var : coupled_vars)
addMooseVariableDependency(var);
}
// DEPRECATED CONSTRUCTOR
QuadraturePointMarker::QuadraturePointMarker(const std::string & deprecated_name, InputParameters parameters) :
Marker(deprecated_name, parameters),
Coupleable(parameters, false),
MaterialPropertyInterface(parameters),
_qrule(_assembly.qRule()),
_q_point(_assembly.qPoints()),
_qp(0)
{
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
}
Material::Material(const std::string & name, InputParameters parameters) :
MooseObject(name, parameters),
BlockRestrictable(parameters),
BoundaryRestrictable(parameters, blockIDs()),
SetupInterface(parameters),
Coupleable(parameters, false),
MooseVariableDependencyInterface(),
ScalarCoupleable(parameters),
FunctionInterface(parameters),
UserObjectInterface(parameters),
TransientInterface(parameters, "materials"),
MaterialPropertyInterface(parameters, blockIDs(), boundaryIDs()),
PostprocessorInterface(parameters),
DependencyResolverInterface(),
Restartable(parameters, "Materials"),
ZeroInterface(parameters),
MeshChangedInterface(parameters),
// The false flag disables the automatic call buildOutputVariableHideList;
// for Material objects the hide lists are handled by MaterialOutputAction
OutputInterface(parameters, false),
_subproblem(*parameters.get<SubProblem *>("_subproblem")),
_fe_problem(*parameters.get<FEProblem *>("_fe_problem")),
_tid(parameters.get<THREAD_ID>("_tid")),
_assembly(_subproblem.assembly(_tid)),
_bnd(parameters.get<bool>("_bnd")),
_neighbor(getParam<bool>("_neighbor")),
_material_data(*parameters.get<MaterialData *>("_material_data")),
_qp(std::numeric_limits<unsigned int>::max()),
_qrule(_bnd ? _assembly.qRuleFace() : _assembly.qRule()),
_JxW(_bnd ? _assembly.JxWFace() : _assembly.JxW()),
_coord(_assembly.coordTransformation()),
_q_point(_bnd ? _assembly.qPointsFace() : _assembly.qPoints()),
_normals(_assembly.normals()),
_current_elem(_neighbor ? _assembly.neighbor() : _assembly.elem()),
_current_side(_neighbor ? _assembly.neighborSide() : _assembly.side()),
_mesh(_subproblem.mesh()),
_coord_sys(_assembly.coordSystem()),
_has_stateful_property(false)
{
// Fill in the MooseVariable dependencies
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
// Update the MaterialData pointer in BlockRestrictable to use the correct MaterialData object
_blk_material_data = &_material_data;
}
NodalUserObject::NodalUserObject(const InputParameters & parameters) :
UserObject(parameters),
BlockRestrictable(parameters),
BoundaryRestrictable(parameters, blockIDs()),
MaterialPropertyInterface(parameters, blockIDs(), boundaryIDs()),
UserObjectInterface(parameters),
Coupleable(parameters, true),
ScalarCoupleable(parameters),
MooseVariableDependencyInterface(),
TransientInterface(parameters, "nodal_user_objects"),
PostprocessorInterface(parameters),
RandomInterface(parameters, _fe_problem, _tid, true),
ZeroInterface(parameters),
_mesh(_subproblem.mesh()),
_qp(0),
_current_node(_assembly.node())
{
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
}
InternalSideIndicator::InternalSideIndicator(const std::string & name, InputParameters parameters) :
Indicator(name, parameters),
NeighborCoupleable(parameters, false),
ScalarCoupleable(parameters),
NeighborMooseVariableInterface(parameters, false),
TwoMaterialPropertyInterface(parameters),
_field_var(_sys.getVariable(_tid, name)),
_current_elem(_assembly.elem()),
_neighbor_elem(_assembly.neighbor()),
_current_side(_assembly.side()),
_current_side_elem(_assembly.sideElem()),
_coord_sys(_assembly.coordSystem()),
_q_point(_assembly.qPointsFace()),
_qrule(_assembly.qRuleFace()),
_JxW(_assembly.JxWFace()),
_coord(_assembly.coordTransformation()),
_boundary_id(parameters.get<BoundaryID>("_boundary_id")),
_var(_subproblem.getVariable(_tid, parameters.get<VariableName>("variable"))),
_scale_by_flux_faces(parameters.get<bool>("scale_by_flux_faces")),
_u(_var.sln()),
_grad_u(_var.gradSln()),
_normals(_field_var.normals()),
_u_neighbor(_var.slnNeighbor()),
_grad_u_neighbor(_var.gradSlnNeighbor())
{
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for(unsigned int i=0; i<coupled_vars.size(); i++)
addMooseVariableDependency(coupled_vars[i]);
addMooseVariableDependency(mooseVariable());
}
InternalSideIndicator::InternalSideIndicator(const InputParameters & parameters)
: Indicator(parameters),
NeighborCoupleable(this, false, false),
ScalarCoupleable(this),
NeighborMooseVariableInterface(
this, false, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_STANDARD),
_field_var(_sys.getVariable(_tid, name())),
_current_elem(_assembly.elem()),
_neighbor_elem(_assembly.neighbor()),
_current_side(_assembly.side()),
_current_side_elem(_assembly.sideElem()),
_coord_sys(_assembly.coordSystem()),
_q_point(_assembly.qPointsFace()),
_qrule(_assembly.qRuleFace()),
_JxW(_assembly.JxWFace()),
_coord(_assembly.coordTransformation()),
_boundary_id(parameters.get<BoundaryID>("_boundary_id")),
_var(_subproblem.getStandardVariable(_tid, parameters.get<VariableName>("variable"))),
_scale_by_flux_faces(parameters.get<bool>("scale_by_flux_faces")),
_u(_var.sln()),
_grad_u(_var.gradSln()),
_normals(_field_var.normals()),
_u_neighbor(_var.slnNeighbor()),
_grad_u_neighbor(_var.gradSlnNeighbor())
{
const std::vector<MooseVariableFEBase *> & coupled_vars = getCoupledMooseVars();
for (const auto & var : coupled_vars)
addMooseVariableDependency(var);
addMooseVariableDependency(mooseVariable());
}
NodalUserObject::NodalUserObject(const InputParameters & parameters) :
UserObject(parameters),
BlockRestrictable(parameters),
BoundaryRestrictable(parameters, blockIDs(), true), // true for applying to nodesets
MaterialPropertyInterface(this, blockIDs(), boundaryIDs()),
UserObjectInterface(this),
Coupleable(this, true),
ScalarCoupleable(this),
MooseVariableDependencyInterface(),
TransientInterface(this),
PostprocessorInterface(this),
RandomInterface(parameters, _fe_problem, _tid, true),
ZeroInterface(parameters),
_mesh(_subproblem.mesh()),
_qp(0),
_current_node(_assembly.node()),
_unique_node_execute(getParam<bool>("unique_node_execute"))
{
const std::vector<MooseVariable *> & coupled_vars = getCoupledMooseVars();
for (const auto & var : coupled_vars)
addMooseVariableDependency(var);
}
ElementUserObject::ElementUserObject(const InputParameters & parameters)
: UserObject(parameters),
BlockRestrictable(this),
MaterialPropertyInterface(this, blockIDs(), Moose::EMPTY_BOUNDARY_IDS),
UserObjectInterface(this),
Coupleable(this, false),
MooseVariableDependencyInterface(),
TransientInterface(this),
PostprocessorInterface(this),
RandomInterface(parameters, _fe_problem, _tid, false),
_mesh(_subproblem.mesh()),
_current_elem(_assembly.elem()),
_current_elem_volume(_assembly.elemVolume()),
_q_point(_assembly.qPoints()),
_qrule(_assembly.qRule()),
_JxW(_assembly.JxW()),
_coord(_assembly.coordTransformation())
{
// Keep track of which variables are coupled so we know what we depend on
const std::vector<MooseVariableFEBase *> & coupled_vars = getCoupledMooseVars();
for (const auto & var : coupled_vars)
addMooseVariableDependency(var);
}
FeatureFloodCount::FeatureFloodCount(const InputParameters & parameters) :
GeneralPostprocessor(parameters),
Coupleable(this, false),
MooseVariableDependencyInterface(),
ZeroInterface(parameters),
_vars(getCoupledMooseVars()),
_threshold(getParam<Real>("threshold")),
_connecting_threshold(isParamValid("connecting_threshold") ? getParam<Real>("connecting_threshold") : getParam<Real>("threshold")),
_mesh(_subproblem.mesh()),
_var_number(_vars[0]->number()),
_single_map_mode(getParam<bool>("use_single_map")),
_condense_map_info(getParam<bool>("condense_map_info")),
_global_numbering(getParam<bool>("use_global_numbering")),
_var_index_mode(getParam<bool>("enable_var_coloring")),
_compute_halo_maps(getParam<bool>("compute_halo_maps")),
_compute_var_to_feature_map(getParam<bool>("compute_var_to_feature_map")),
_use_less_than_threshold_comparison(getParam<bool>("use_less_than_threshold_comparison")),
_n_vars(_vars.size()),
_maps_size(_single_map_mode ? 1 : _vars.size()),
_n_procs(_app.n_processors()),
_entities_visited(_vars.size()), // This map is always sized to the number of variables
_feature_counts_per_map(_maps_size),
_feature_count(0),
_partial_feature_sets(_maps_size),
_feature_maps(_maps_size),
_pbs(nullptr),
_element_average_value(parameters.isParamValid("elem_avg_value") ? getPostprocessorValue("elem_avg_value") : _real_zero),
_halo_ids(_maps_size),
_is_elemental(getParam<MooseEnum>("flood_entity_type") == "ELEMENTAL"),
_is_master(processor_id() == 0)
{
if (_var_index_mode)
_var_index_maps.resize(_maps_size);
addMooseVariableDependency(_vars);
}