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); }