void Godunov::MultiPhase(const double & CFL, unsigned phase) { double t = 0; Cell leftCell; Cell rightCell; bool phaseInteraction; while (t < getMax()) { BoundaryConditions(); for (unsigned i = 0; i < getCell().size(); ++i) { phaseInteraction = false; leftCell = getCell()[i % getCell().size()]; rightCell = getCell()[(i + 1) % getCell().size()]; if (i == getCell().size() - 2) continue; for (unsigned j = 0; j < phase; ++j) if (leftCell.getPhase()[j].getPhi() != rightCell.getPhase()[j].getPhi()) { phaseInteraction = true; break; } if (!phaseInteraction) { for (unsigned j = 0; j < phase; ++j) detachedRiemann(leftCell, rightCell, i, j); } } computeDT(CFL); timeIntegration(); for (unsigned i = 0; i < getCell().size(); ++i) { setCell()[i].computeScalFromCons(); } t += getDt(); } }
void Transient::execute() { preExecute(); // NOTE: if you remove this line, you will see a subset of tests failing. Those tests might have a wrong answer and might need to be regolded. // The reason is that we actually move the solution back in time before we actually start solving (which I think is wrong). So this call here // is to maintain backward compatibility and so that MOOSE is giving the same answer. However, we might remove this call and regold the test // in the future eventually. if (!_app.isRecovering()) _problem.copyOldSolutions(); // Start time loop... while (true) { if (_first != true) incrementStepOrReject(); _first = false; if (!keepGoing()) break; computeDT(); takeStep(); endStep(); _steps_taken++; } postExecute(); }
Real PostprocessorDT::computeInitialDT() { if (_has_initial_dt) return _initial_dt; else return computeDT(); }
void Godunov::Solve(const double& CFL) { //dt_ = 0.00005; computeDT(CFL); if (getCell()[0].getPhase().size() == 1) SinglePhase(CFL); else MultiPhase(CFL, getCell()[0].getPhase().size()); BoundaryConditions(); }
void Transient::init() { if (!_time_stepper.get()) { InputParameters pars = _app.getFactory().getValidParams("ConstantDT"); pars.set<FEProblem *>("_fe_problem") = &_problem; pars.set<Transient *>("_executioner") = this; /** * We have a default "dt" set in the Transient parameters but it's possible for users to set other * parameters explicitly that could provide a better calculated "dt". Rather than provide difficult * to understand behavior using the default "dt" in this case, we'll calculate "dt" properly. */ if (!_pars.isParamSetByAddParam("end_time") && !_pars.isParamSetByAddParam("num_steps") && _pars.isParamSetByAddParam("dt")) pars.set<Real>("dt") = (getParam<Real>("end_time") - getParam<Real>("start_time")) / static_cast<Real>(getParam<unsigned int>("num_steps")); else pars.set<Real>("dt") = getParam<Real>("dt"); pars.set<bool>("reset_dt") = getParam<bool>("reset_dt"); _time_stepper = MooseSharedNamespace::static_pointer_cast<TimeStepper>(_app.getFactory().create("ConstantDT", "TimeStepper", pars)); } _problem.initialSetup(); _time_stepper->init(); if (_app.isRestarting()) _time_old = _time; Moose::setup_perf_log.push("Output Initial Condition","Setup"); _problem.outputStep(EXEC_INITIAL); Moose::setup_perf_log.pop("Output Initial Condition","Setup"); // If this is the first step if (_t_step == 0) _t_step = 1; if (_t_step > 1) //Recover case _dt_old = _dt; else { computeDT(); // _dt = computeConstrainedDT(); _dt = getDT(); } }
void Transient::init() { if (_time_stepper == NULL) { InputParameters pars = _app.getFactory().getValidParams("ConstantDT"); pars.set<FEProblem *>("_fe_problem") = &_problem; pars.set<Transient *>("_executioner") = this; pars.set<Real>("dt") = getParam<Real>("dt"); pars.set<bool>("reset_dt") = getParam<bool>("reset_dt"); _time_stepper = static_cast<TimeStepper *>(_app.getFactory().create("ConstantDT", "TimeStepper", pars)); } _problem.initialSetup(); _time_stepper->init(); Moose::setup_perf_log.push("Output Initial Condition","Setup"); _output_warehouse.outputInitial(); if (_output_initial) { _problem.output(); _problem.outputPostprocessors(); _problem.outputRestart(); } Moose::setup_perf_log.pop("Output Initial Condition","Setup"); // If this is the first step if (_t_step == 0) _t_step = 1; if (_t_step > 1) //Restart case { _dt_old = _dt; } else { computeDT(); // _dt = computeConstrainedDT(); _dt = getDT(); } }
void TimeStepper::computeStep() { if (_t_step < 2 || (_reset_dt && !_has_reset_dt)) { _has_reset_dt = true; if (converged()) _current_dt = computeInitialDT(); else _current_dt = computeFailedDT(); } else { if (converged()) _current_dt = computeDT(); else _current_dt = computeFailedDT(); } }
void PostdominatorTree::analyze(ir::IRKernel& kernel) { // form a vector of the basic blocks in post-order report("Building post-dominator tree."); cfg = kernel.cfg(); report(" Starting with post order sequence"); // form a vector of the basic blocks in post-order ir::ControlFlowGraph::BlockPointerVector post_order = cfg->reverse_topological_sequence(); ir::ControlFlowGraph::reverse_pointer_iterator it = post_order.rbegin(); ir::ControlFlowGraph::reverse_pointer_iterator end = post_order.rend(); for (; it != end; ++it) { blocks.push_back(*it); blocksToIndex[*it] = (int)blocks.size()-1; p_dom.push_back(-1); report(" " << (*it)->label()); } computeDT(); }
void Transient::init() { if (!_time_stepper.get()) { InputParameters pars = _app.getFactory().getValidParams("ConstantDT"); pars.set<FEProblem *>("_fe_problem") = &_problem; pars.set<Transient *>("_executioner") = this; pars.set<Real>("dt") = getParam<Real>("dt"); pars.set<bool>("reset_dt") = getParam<bool>("reset_dt"); _time_stepper = MooseSharedNamespace::static_pointer_cast<TimeStepper>(_app.getFactory().create("ConstantDT", "TimeStepper", pars)); } _problem.initialSetup(); _time_stepper->init(); if (_app.isRestarting()) _time_old = _time; Moose::setup_perf_log.push("Output Initial Condition","Setup"); _problem.outputStep(EXEC_INITIAL); Moose::setup_perf_log.pop("Output Initial Condition","Setup"); // If this is the first step if (_t_step == 0) _t_step = 1; if (_t_step > 1) //Recover case _dt_old = _dt; else { computeDT(); // _dt = computeConstrainedDT(); _dt = getDT(); } }
void Godunov::SinglePhase(const double & CFL) { double t = 0; while (t < getMax()) { BoundaryConditions(); for (unsigned i = 0; i < getCell().size(); ++i) { if (i == getCell().size() - 2) continue; RiemannSolver riemann(getCell()[i % getCell().size()], getCell()[(i + 1) % getCell().size()], 1); riemann.solve(); riemann.phase_star_[0].Sample(0, setCell()[i].setPhase()[0].setU_half(), setCell()[i].setPhase()[0].setP_half(), setCell()[i].setPhase()[0].setD_half(), riemann.phase_star_[0].pstar[0] , riemann.phase_star_[0].ustar[0]); setCell()[i].setPhase()[0].InterCellFlux(); } computeDT(CFL); timeIntegration(); for (unsigned i = 0; i < getCell().size(); ++i) { setCell()[i].setPhase()[0].computeScalFromCons(); } t += getDt(); } }
Real FunctionDT::computeInitialDT() { return computeDT(); }
Real AdaptiveTransient::computeConstrainedDT() { _diag.str(""); _diag.clear(); Real dt_cur = computeDT(); // Don't let the time step size exceed maximum time step size if (dt_cur > _dtmax) { dt_cur = _dtmax; _diag << "Limiting dt to dtmax: " << std::setw(9) << std::setprecision(6) << std::setfill('0') << std::showpoint << std::left << _dtmax << std::endl; } // Limit the timestep to limit change in the function //TODO: handle conflict of this with dtmin Real function_limited_dt = limitDTByFunction(dt_cur); if (function_limited_dt < dt_cur) { dt_cur = function_limited_dt; _diag << "Limiting dt to limit change in function. dt: " << std::setw(9) << std::setprecision(6) << std::setfill('0') << std::showpoint << std::left << dt_cur << std::endl; } // Don't allow time step size to be smaller than minimum time step size if (dt_cur < _dtmin) { dt_cur = _dtmin; _diag << "Increasing dt to dtmin: " << std::setw(9) << std::setprecision(6) << std::setfill('0') << std::showpoint << std::left << _dtmin << std::endl; } // Don't let time go beyond simulation end time if (_time_old + dt_cur > _end_time) { dt_cur = _end_time - _time_old; _diag << "Limiting dt for end time: " << std::setw(9) << std::setprecision(6) << std::setfill('0') << std::showpoint << std::left << _end_time << " dt: " << std::setw(9) << std::setprecision(6) << std::setfill('0') << std::showpoint << std::left << dt_cur << std::endl; } // Adjust to the next sync time if needed if (_remaining_sync_time && _time_old + dt_cur >= _curr_sync_time_iter->first) { dt_cur = _curr_sync_time_iter->first - _time_old; _synced_last_step = true; _last_sync_type = _curr_sync_time_iter->second; if (_last_sync_type == SYNC) _diag << "Limiting dt for sync time: "; else _diag << "Limiting dt to sync with dt function time: "; _diag << std::setw(9) << std::setprecision(6) << std::setfill('0') << std::showpoint << std::left << _curr_sync_time_iter->first << " dt: " << std::setw(9) << std::setprecision(6) << std::setfill('0') << std::showpoint << std::left << dt_cur << std::endl; if (++_curr_sync_time_iter == _sync_times.end()) _remaining_sync_time = false; _prev_dt = _dt; } if (_diag.str().size() > 0) { Moose::out << _diag.str() << std::endl; } return dt_cur; }