void DiracKernel::updateCaches(const Elem* old_elem, const Elem* new_elem, Point p, unsigned id) { // Update the point cache. Remove old cached data, only cache // new_elem if it is non-NULL and local. _point_cache.erase(id); if (new_elem && (new_elem->processor_id() == processor_id())) _point_cache[id] = std::make_pair(new_elem, p); // Update the reverse cache // // First, remove the Point from the old_elem's vector reverse_cache_t::iterator it = _reverse_point_cache.find(old_elem); if (it != _reverse_point_cache.end()) { reverse_cache_t::mapped_type & points = it->second; { reverse_cache_t::mapped_type::iterator points_it = points.begin(), points_end = points.end(); for (; points_it != points_end; ++points_it) { // If the point matches, remove it from the vector of points if (p.relative_fuzzy_equals(points_it->first)) { // Vector erasure. It can be slow but these vectors are // generally very short. It also invalidates existing // iterators, so we need to break out of the loop and // not use them any more. points.erase(points_it); break; } } // If the points vector is now empty, remove old_elem from the reverse cache entirely if (points.empty()) _reverse_point_cache.erase(old_elem); } } // Next, if new_elem is not NULL and local, add the point to the new_elem's vector if (new_elem && (new_elem->processor_id() == processor_id())) { reverse_cache_t::mapped_type & points = _reverse_point_cache[new_elem]; points.push_back(std::make_pair(p, id)); } }
void ContactSlipDamper::timestepSetup() { GeometricSearchData & displaced_geom_search_data = _displaced_problem->geomSearchData(); std::map<std::pair<unsigned int, unsigned int>, PenetrationLocator *> * penetration_locators = &displaced_geom_search_data._penetration_locators; for (pl_iterator plit = penetration_locators->begin(); plit != penetration_locators->end(); ++plit) { PenetrationLocator & pen_loc = *plit->second; if (operateOnThisInteraction(pen_loc)) { std::vector<dof_id_type> & slave_nodes = pen_loc._nearest_node._slave_nodes; for (unsigned int i = 0; i < slave_nodes.size(); i++) { dof_id_type slave_node_num = slave_nodes[i]; if (pen_loc._penetration_info[slave_node_num]) { PenetrationInfo & info = *pen_loc._penetration_info[slave_node_num]; const Node * node = info._node; if (node->processor_id() == processor_id()) // && info.isCaptured()) //TODO maybe just set this everywhere? info._slip_reversed = false; } } } } }
void NodalNormalsEvaluator::execute() { if (_current_node->processor_id() == processor_id()) { if (_current_node->n_dofs(_aux.number(), _fe_problem.getVariable(_tid, "nodal_normal_x").number()) > 0) { Threads::spin_mutex::scoped_lock lock(nodal_normals_evaluator_mutex); dof_id_type dof_x = _current_node->dof_number(_aux.number(), _fe_problem.getVariable(_tid, "nodal_normal_x").number(), 0); dof_id_type dof_y = _current_node->dof_number(_aux.number(), _fe_problem.getVariable(_tid, "nodal_normal_y").number(), 0); dof_id_type dof_z = _current_node->dof_number(_aux.number(), _fe_problem.getVariable(_tid, "nodal_normal_z").number(), 0); NumericVector<Number> & sln = _aux.solution(); Real nx = sln(dof_x); Real ny = sln(dof_y); Real nz = sln(dof_z); Real n = std::sqrt((nx * nx) + (ny * ny) + (nz * nz)); if (std::abs(n) >= 1e-13) { // divide by n only if it is not close to zero to avoid NaNs sln.set(dof_x, nx / n); sln.set(dof_y, ny / n); sln.set(dof_z, nz / n); } } } }
Real FindValueOnLine::getValueAtPoint(const Point & p) { const Elem * elem = (*_pl)(p); if (elem) { Real value; if (elem->processor_id() == processor_id()) { // element is local _point_vec[0] = p; _subproblem.reinitElemPhys(elem, _point_vec, 0); value = _coupled_var->sln()[0]; } // broadcast value _communicator.broadcast(value, elem->processor_id()); return value; } else { // there is no element mooseError("No element found at the current search point. Please make sure the sampling line stays inside the mesh completely."); } }
void MaterialTensorOnLine::finalize() { _communicator.set_union(_dist); _communicator.set_union(_value); if (processor_id() == 0) { std::vector<std::pair<Real, Real> > table; // std::map<unsigned int, Real>::iterator id(_dist.begin()); // std::map<unsigned int, Real>::iterator is(_value.begin()); std::map<std::pair<unsigned int, unsigned int>, Real>::iterator id(_dist.begin()); std::map<std::pair<unsigned int, unsigned int>, Real>::iterator is(_value.begin()); while (id != _dist.end() && is != _value.end()) { table.push_back(std::make_pair(id->second,is->second)); id++; is++; } std::sort(table.begin(),table.end()); _output_file << "time " << _fe_problem.time() << std::endl; for (std::vector<std::pair<Real, Real> >::iterator it = table.begin(); it != table.end(); ++it) { _output_file << it->first << " " << it->second << std::endl; } } }
ExodusTimeSequenceStepper::ExodusTimeSequenceStepper(const InputParameters & parameters) : TimeSequenceStepperBase(parameters), _mesh_file(getParam<MeshFileName>("mesh")) { // Read the Exodus file on processor 0 std::vector<Real> times; if (processor_id() == 0) { // Check that the required file exists MooseUtils::checkFileReadable(_mesh_file); // dummy mesh ReplicatedMesh mesh(_communicator); ExodusII_IO exodusII_io(mesh); exodusII_io.read(_mesh_file); times = exodusII_io.get_time_steps(); } // distribute timestep list unsigned int num_steps = times.size(); _communicator.broadcast(num_steps); times.resize(num_steps); _communicator.broadcast(times); setupSequence(times); }
void CSV::output() { // Call the base class output (populates tables) TableOutput::output(); // Print the table containing all the data to a file if (!_all_data_table.empty() && processor_id() == 0) _all_data_table.printCSV(filename(), 1, _align); // Output each VectorPostprocessor's data to a file for (std::map<std::string, FormattedTable>::iterator it = _vector_postprocessor_tables.begin(); it != _vector_postprocessor_tables.end(); ++it) { std::ostringstream output; output << _file_base << "_" << it->first; output << "_" << std::setw(_padding) << std::setprecision(0) << std::setfill('0') << std::right << timeStep(); output << ".csv"; if (_set_delimiter) it->second.setDelimiter(_delimiter); it->second.setPrecision(_precision); it->second.printCSV(output.str(), 1, _align); } }
Real ExceptionKernel::computeQpResidual() { // We need a thread lock here so that we don't introduce a race condition when inspecting or // changing the static variable Threads::spin_mutex::scoped_lock lock(Threads::spin_mutex); if (_when == WhenType::INITIAL_CONDITION) throw MooseException("MooseException thrown during initial condition computation"); // Make sure we have called computeQpResidual enough times to // guarantee that we are in the middle of a linear solve, to verify // that we can throw an exception at that point. // Also, only throw on one rank if the user requests it else if (_when == WhenType::RESIDUAL && !_res_has_thrown && time_to_throw() && (_rank == DofObject::invalid_processor_id || _rank == processor_id())) { // The residual has now thrown _res_has_thrown = true; if (_should_throw) throw MooseException("MooseException thrown during residual calculation"); else mooseError("Intentional error triggered during residual calculation"); } else return 0.; }
void SlopeLimitingBase::deserialize(std::vector<std::string> & serialized_buffers) { // The input string stream used for deserialization std::istringstream iss; mooseAssert(serialized_buffers.size() == _app.n_processors(), "Unexpected size of serialized_buffers: " << serialized_buffers.size()); for (auto rank = decltype(_app.n_processors())(0); rank < serialized_buffers.size(); ++rank) { if (rank == processor_id()) continue; iss.str(serialized_buffers[rank]); // populate the stream with a new buffer iss.clear(); // reset the string stream state // Load the communicated data into all of the other processors' slots unsigned int size = 0; iss.read((char *)&size, sizeof(size)); for (unsigned int i = 0; i < size; i++) { dof_id_type key; loadHelper(iss, key, this); std::vector<RealGradient> value; loadHelper(iss, value, this); // merge the data we received from other procs _lslope.insert(std::pair<dof_id_type, std::vector<RealGradient>>(key, value)); } } }
void FeatureFloodCount::visitNodalNeighbors(const Node * node, int current_idx, FeatureData * feature, bool recurse) { mooseAssert(node, "Node is NULL"); std::vector<const Node *> neighbors; MeshTools::find_nodal_neighbors(_mesh.getMesh(), *node, _nodes_to_elem_map, neighbors); // Loop over all nodal neighbors for (unsigned int i = 0; i < neighbors.size(); ++i) { const Node * neighbor_node = neighbors[i]; processor_id_type my_proc_id = processor_id(); // Only recurse on nodes this processor can see if (_mesh.isSemiLocal(const_cast<Node *>(neighbor_node))) { if (neighbor_node->processor_id() != my_proc_id) feature->_ghosted_ids.insert(neighbor_node->id()); // Premark Halo values feature->_halo_ids.insert(neighbor_node->id()); if (recurse) flood(neighbors[i], current_idx, feature); } } }
void PointSamplerBase::finalize() { // Save off for speed unsigned int pid = processor_id(); /* * Figure out which processor is actually going "claim" each point. * If multiple processors found the point and computed values what happens is that * maxloc will give us the smallest PID in max_id */ std::vector<unsigned int> max_id(_found_points.size()); _communicator.maxloc(_found_points, max_id); for (unsigned int i=0; i<max_id.size(); i++) { // Only do this check on the proc zero because it's the same on every processor // _found_points should contain all 1's at this point (ie every point was found by a proc) if (pid == 0 && !_found_points[i]) mooseError("In " << name() << ", sample point not found: " << _points[i]); if (max_id[i] == pid) SamplerBase::addSample(_points[i], _ids[i], _values[i]); } SamplerBase::finalize(); }
Real SolutionTimeAdaptiveDT::computeDT() { //Ratio grew so switch direction if (_sol_time_vs_dt > _old_sol_time_vs_dt && _sol_time_vs_dt > _older_sol_time_vs_dt) { _direction *= -1; // Make sure we take at least two steps in this new direction _old_sol_time_vs_dt = std::numeric_limits<Real>::max(); _older_sol_time_vs_dt = std::numeric_limits<Real>::max(); } // if (_t_step > 1) Real local_dt = _dt + _dt * _percent_change*_direction; if ((_adapt_log) && (processor_id() == 0)) { Real out_dt = getCurrentDT(); if (out_dt > _dt_max) out_dt = _dt_max; _adaptive_log<<"***Time step: "<<_t_step<<", time = "<<_time+out_dt<<std::endl; _adaptive_log<<"Cur DT: "<<out_dt<<std::endl; _adaptive_log<<"Older Ratio: "<<_older_sol_time_vs_dt<<std::endl; _adaptive_log<<"Old Ratio: "<<_old_sol_time_vs_dt<<std::endl; _adaptive_log<<"New Ratio: "<<_sol_time_vs_dt<<std::endl; } return local_dt; }
void MeshASMPartitioning::DoPartition( const unsigned *block_size, vector < vector< unsigned > > &block_elements, vector <unsigned> &block_type_range){ unsigned iproc = processor_id(); unsigned ElemOffset = _mesh._elementOffset[iproc]; unsigned ElemOffsetp1 = _mesh._elementOffset[iproc + 1]; unsigned OwnedElements = ElemOffsetp1 - ElemOffset; unsigned counter[3] = {0, 0, 0}; unsigned flag_block[3] = {4, 3, 2}; for (unsigned iel = ElemOffset; iel < ElemOffsetp1; iel++) { unsigned flag_mat = _mesh.GetElementMaterial(iel); if (flag_mat == flag_block[0]) { counter[0]++; } else if (flag_mat == flag_block[1]) { counter[1]++; } } counter[2] = OwnedElements - counter[0] - counter[1]; block_type_range.resize(3); unsigned block_start = 0; unsigned iMaterial = 0; while (iMaterial < 3) { if (counter[iMaterial] != 0 ) { //material of this type is there unsigned reminder = counter[iMaterial] % block_size[iMaterial]; unsigned blocks = (0 == reminder) ? counter[iMaterial] / block_size[iMaterial] : counter[iMaterial] / block_size[iMaterial] + 1 ; block_elements.resize(block_start + blocks); for (int i = 0; i < blocks; i++) { block_elements[block_start + i].resize(block_size[iMaterial]); } if (0 != reminder ) { block_elements[block_start + (blocks - 1u)].resize(reminder); } unsigned counter = 0; for (unsigned iel = ElemOffset; iel < ElemOffsetp1; iel++) { unsigned flag_mat = _mesh.GetElementMaterial(iel); if ( flag_block[iMaterial] == flag_mat ) { block_elements[ block_start + (counter / block_size[iMaterial]) ][ counter % block_size[iMaterial] ] = iel; counter++; } } block_type_range[iMaterial] = block_start + blocks; block_start += blocks; } else { block_type_range[iMaterial] = block_start; } iMaterial++; } }
void GCTaskThread::run() { // Set up the thread for stack overflow support this->record_stack_base_and_size(); this->initialize_thread_local_storage(); // Bind yourself to your processor. if (processor_id() != GCTaskManager::sentinel_worker()) { if (TraceGCTaskThread) { tty->print_cr("GCTaskThread::run: " " binding to processor %u", processor_id()); } if (!os::bind_to_processor(processor_id())) { DEBUG_ONLY( warning("Couldn't bind GCTaskThread %u to processor %u", which(), processor_id()); ) } }
void SlaveConstraint::addPoints() { _point_to_info.clear(); std::set<dof_id_type> & has_penetrated = _penetration_locator._has_penetrated; std::map<dof_id_type, PenetrationInfo *>::iterator it = _penetration_locator._penetration_info.begin(), end = _penetration_locator._penetration_info.end(); for (; it!=end; ++it) { PenetrationInfo * pinfo = it->second; if (!pinfo) { continue; } dof_id_type slave_node_num = it->first; const Node * node = pinfo->_node; std::set<dof_id_type>::iterator hpit = has_penetrated.find(slave_node_num); if (hpit != has_penetrated.end() && node->processor_id() == processor_id()) { // Find an element that is connected to this node that and that is also on this processor std::vector<dof_id_type> & connected_elems = _mesh.nodeToElemMap()[slave_node_num]; Elem * elem = NULL; for (unsigned int i=0; i<connected_elems.size() && !elem; ++i) { Elem * cur_elem = _mesh.elem(connected_elems[i]); if (cur_elem->processor_id() == processor_id()) elem = cur_elem; } mooseAssert(elem, "Couldn't find an element on this processor that is attached to the slave node!"); addPoint(elem, *node); _point_to_info[*node] = pinfo; } } }
MaterialTensorOnLine::~MaterialTensorOnLine() { if (_stream_open && processor_id() == 0) { _output_file.close(); _stream_open = false; } }
void SlaveConstraint::addPoints() { _point_to_info.clear(); std::map<dof_id_type, PenetrationInfo *>::iterator it = _penetration_locator._penetration_info.begin(), end = _penetration_locator._penetration_info.end(); const auto & node_to_elem_map = _mesh.nodeToElemMap(); for (; it != end; ++it) { PenetrationInfo * pinfo = it->second; // Skip this pinfo if there are no DOFs on this node. if (!pinfo || pinfo->_node->n_comp(_sys.number(), _vars[_component]) < 1) continue; dof_id_type slave_node_num = it->first; const Node * node = pinfo->_node; if (pinfo->isCaptured() && node->processor_id() == processor_id()) { // Find an element that is connected to this node that and that is also on this processor auto node_to_elem_pair = node_to_elem_map.find(slave_node_num); mooseAssert(node_to_elem_pair != node_to_elem_map.end(), "Missing node in node to elem map"); const std::vector<dof_id_type> & connected_elems = node_to_elem_pair->second; Elem * elem = NULL; for (unsigned int i = 0; i < connected_elems.size() && !elem; ++i) { Elem * cur_elem = _mesh.elemPtr(connected_elems[i]); if (cur_elem->processor_id() == processor_id()) elem = cur_elem; } mooseAssert(elem, "Couldn't find an element on this processor that is attached to the slave node!"); addPoint(elem, *node); _point_to_info[*node] = pinfo; } } }
void SplitTester::execute() { if (!_fe_problem.mesh().isDistributedMesh()) mooseError("Not using DistributedMesh but should be"); auto & m = _fe_problem.mesh().getMesh(); if (m.n_elem_on_proc(processor_id()) == m.n_elem()) mooseError("Elements not shared properly between distributed mesh procs"); }
void DiracKernel::addPoint(const Elem * elem, Point p, unsigned /*id*/) { if (!elem || (elem->processor_id() != processor_id())) return; _dirac_kernel_info.addPoint(elem, p); _local_dirac_kernel_info.addPoint(elem, p); }
//---------------------------------------------------------------------------------------------------------------- void MeshASMPartitioning::DoPartition( const unsigned *block_size, vector < vector< unsigned > > &block_elements, vector <unsigned> &block_type_range){ unsigned iproc=processor_id(); unsigned ElemOffset = _mesh.IS_Mts2Gmt_elem_offset[iproc]; unsigned ElemOffsetp1 = _mesh.IS_Mts2Gmt_elem_offset[iproc+1]; unsigned OwnedElements = ElemOffsetp1 - ElemOffset; unsigned counter[2]={0,0}; for (unsigned iel_mts = ElemOffset; iel_mts < ElemOffsetp1; iel_mts++) { unsigned kel = _mesh.IS_Mts2Gmt_elem[iel_mts]; unsigned flag_mat = _mesh.el->GetElementMaterial(kel); if(2 == flag_mat){ counter[1]++; } } counter[0]=OwnedElements - counter[1]; block_type_range.resize(2); unsigned flag_block[2]={4,2}; unsigned block_start=0; unsigned iblock=0; while(iblock < 2){ if(counter[iblock] !=0 ){ unsigned reminder = counter[iblock] % block_size[iblock]; unsigned blocks = (0 == reminder)? counter[iblock]/block_size[iblock] : counter[iblock]/block_size[iblock] + 1 ; block_elements.resize(block_start+blocks); for(int i = 0; i < blocks; i++) block_elements[block_start + i].resize(block_size[iblock]); if (0 != reminder ){ block_elements[block_start + (blocks-1u)].resize(reminder); } unsigned counter=0; for (unsigned iel_mts = ElemOffset; iel_mts < ElemOffsetp1; iel_mts++) { unsigned kel = _mesh.IS_Mts2Gmt_elem[iel_mts]; unsigned flag_mat = _mesh.el->GetElementMaterial(kel); if( flag_block[iblock] == flag_mat ){ block_elements[ block_start + (counter / block_size[iblock]) ][ counter % block_size[iblock] ]=iel_mts; counter++; } } block_type_range[iblock]=block_start+blocks; block_start += blocks; } else{ block_type_range[iblock]=block_start; } iblock++; } }
void CSV::output() { // Call the base class output (populates tables) TableOutput::output(); // Print the table containing all the data to a file if (!_all_data_table.empty() && processor_id() == 0) _all_data_table.printCSV(filename()); }
void DiracKernel::addPoint(const Elem * elem, Point p) { if (!elem || (elem->processor_id() != processor_id())) return; _dirac_kernel_info.addPoint(elem, p); _elements.insert(elem); _points[elem].insert(p); }
const Elem * PointSamplerBase::getLocalElemContainingPoint(const Point & p, unsigned int id) { const Elem * elem = (*_pl)(p); if (elem && elem->processor_id() == processor_id()) return elem; return NULL; }
ExampleApp::ExampleApp(InputParameters parameters) : MooseApp(parameters) { srand(processor_id()); Moose::registerObjects(_factory); ExampleApp::registerObjects(_factory); Moose::associateSyntax(_syntax, _action_factory); ExampleApp::associateSyntax(_syntax, _action_factory); }
void GapHeatTransfer::computeGapValues() { if (!_quadrature) { _has_info = true; _gap_temp = _gap_temp_value[_qp]; _gap_distance = _gap_distance_value[_qp]; } else { Node * qnode = _mesh.getQuadratureNode(_current_elem, _current_side, _qp); PenetrationInfo * pinfo = _penetration_locator->_penetration_info[qnode->id()]; _gap_temp = 0.0; _gap_distance = 88888; _has_info = false; _edge_multiplier = 1.0; if (pinfo) { _gap_distance = pinfo->_distance; _has_info = true; Elem * slave_side = pinfo->_side; std::vector<std::vector<Real> > & slave_side_phi = pinfo->_side_phi; _gap_temp = _variable->getValue(slave_side, slave_side_phi); Real tangential_tolerance = _penetration_locator->getTangentialTolerance(); if (tangential_tolerance != 0.0) { _edge_multiplier = 1.0 - pinfo->_tangential_distance / tangential_tolerance; if (_edge_multiplier < 0.0) { _edge_multiplier = 0.0; } } } else { if (_warnings) { std::stringstream msg; msg << "No gap value information found for node "; msg << qnode->id(); msg << " on processor "; msg << processor_id(); mooseWarning( msg.str() ); } } } Point current_point(_q_point[_qp]); GapConductance::computeGapRadii(_gap_geometry_type, current_point, _p1, _p2, _gap_distance, _normals[_qp], _r1, _r2, _radius); }
void GrainTracker::swapSolutionValuesHelper(Node * curr_node, unsigned int curr_var_idx, unsigned int new_var_idx, std::map<Node *, CacheValues> & cache, REMAP_CACHE_MODE cache_mode) { if (curr_node && curr_node->processor_id() == processor_id()) { // Reinit the node so we can get and set values of the solution here _subproblem.reinitNode(curr_node, 0); // Get the value out of the solution vector or the cache Real current, old, older; if (cache_mode == FILL || cache_mode == BYPASS) { current = _vars[curr_var_idx]->nodalSln()[0]; old = _vars[curr_var_idx]->nodalSlnOld()[0]; older = _vars[curr_var_idx]->nodalSlnOlder()[0]; } else // USE { std::map<Node *, CacheValues>::const_iterator it = cache.find(curr_node); mooseAssert(it != cache.end(), "Error in cache"); current = it->second.current; old = it->second.old; older = it->second.older; } // Cache the value or use it! if (cache_mode == FILL) { cache[curr_node].current = current; cache[curr_node].old = old; cache[curr_node].older = older; } else // USE or BYPASS { { dof_id_type & dof_index = _vars[new_var_idx]->nodalDofIndex(); // Transfer this solution from the current to the new _nl.solution().set(dof_index, current); _nl.solutionOld().set(dof_index, old); _nl.solutionOlder().set(dof_index, older); } { dof_id_type & dof_index = _vars[curr_var_idx]->nodalDofIndex(); // Set the DOF for the current variable to zero _nl.solution().set(dof_index, 0.0); _nl.solutionOld().set(dof_index, 0.0); _nl.solutionOlder().set(dof_index, 0.0); } } } }
void CSV::output(const ExecFlagType & type) { // Start the performance log Moose::perf_log.push("CSV::output()", "Output"); // Call the base class output (populates tables) TableOutput::output(type); // Print the table containing all the data to a file if (_write_all_table && !_all_data_table.empty() && processor_id() == 0) _all_data_table.printCSV(filename(), 1, _align); // Output each VectorPostprocessor's data to a file if (_write_vector_table && processor_id() == 0) { for (auto & it : _vector_postprocessor_tables) { std::ostringstream output; output << _file_base << "_" << MooseUtils::shortName(it.first); output << "_" << std::setw(_padding) << std::setprecision(0) << std::setfill('0') << std::right << timeStep() << ".csv"; if (_set_delimiter) it.second.setDelimiter(_delimiter); it.second.setPrecision(_precision); it.second.printCSV(output.str(), 1, _align); if (_time_data) { std::ostringstream filename; filename << _file_base << "_" << MooseUtils::shortName(it.first) << "_time.csv"; _vector_postprocessor_time_tables[it.first].printCSV(filename.str()); } } } // Re-set write flags _write_all_table = false; _write_vector_table = false; Moose::perf_log.pop("CSV::output()", "Output"); }
ExampleApp::ExampleApp(const std::string & name, InputParameters parameters) : MooseApp(name, parameters) { srand(processor_id()); Moose::registerObjects(_factory); ExampleApp::registerObjects(_factory); Moose::associateSyntax(_syntax, _action_factory); ExampleApp::associateSyntax(_syntax, _action_factory); }
HeatConductionApp::HeatConductionApp(const InputParameters & parameters) : MooseApp(parameters) { srand(processor_id()); Moose::registerObjects(_factory); HeatConductionApp::registerObjects(_factory); Moose::associateSyntax(_syntax, _action_factory); HeatConductionApp::associateSyntax(_syntax, _action_factory); }
// DEPRECATED CONSTRUCTOR HeatConductionApp::HeatConductionApp(const std::string & deprecated_name, InputParameters parameters) : MooseApp(deprecated_name, parameters) { srand(processor_id()); Moose::registerObjects(_factory); HeatConductionApp::registerObjects(_factory); Moose::associateSyntax(_syntax, _action_factory); HeatConductionApp::associateSyntax(_syntax, _action_factory); }