SteadyAndAdjoint.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#include "SteadyAndAdjoint.h"
#include "FEProblemBase.h"
 
registerMooseObject("OptimizationApp", SteadyAndAdjoint);
 
InputParameters
SteadyAndAdjoint::validParams()
{
  InputParameters params = Steady::validParams();
  params += AdjointSolve::validParams();
  params.addClassDescription(
      "Executioner for evaluating steady-state simulations and their adjoint.");
 
  // We need the full matrix for the adjoint solve, so set this to NEWTON
  params.set<MooseEnum>("solve_type") = "newton";
  params.suppressParameter<MooseEnum>("solve_type");
 
  // The adjoint system (second one) is solved by _adjoint_solve
  // This is a parameter of the MultiSystemSolveObject, which we set from here, the executioner.
  // We seek to prevent the MultiSystemSolveObject from solving both systems
  // This is abusing input parameters, but SolveObjects do not have their own syntax
  // and we need to send this parameter from the executioner to the default nested SolveObject
  params.renameParam("system_names", "forward_system", "");
 
  return params;
}
 
SteadyAndAdjoint::SteadyAndAdjoint(const InputParameters & parameters)
  : Steady(parameters), _adjoint_solve(*this)
{
}
 
void
SteadyAndAdjoint::execute()
{
  // This is basically copied from Steady (without AMR)
  if (_app.isRecovering())
  {
    _console << "\nCannot recover steady solves!\nExiting...\n" << std::endl;
    _last_solve_converged = true;
    return;
  }
 
  _time_step = 0;
  _time = _time_step;
  _problem.outputStep(EXEC_INITIAL);
  _time = _system_time;
 
  preExecute();
 
  _problem.advanceState();
  _time_step = 1;
  _problem.timestepSetup();
 
  // Solving forward and adjoint problem here (only difference from Steady)
  _last_solve_converged = _fixed_point_solve->solve();
 
  if (!lastSolveConverged())
    _console << "Forward solve did not converge." << std::endl;
 
  _console << "Starting Adjoint solve" << std::endl;
 
  // this is to check that they are both true
  bool adjoint_solve_converged = _adjoint_solve.solve();
  _last_solve_converged &= adjoint_solve_converged;
 
  if (!lastSolveConverged())
  {
    if (!adjoint_solve_converged)
      _console << "Adjoint solve did not converge." << std::endl;
  }
  else
  {
    _time = _time_step;
    _problem.outputStep(EXEC_TIMESTEP_END);
    _time = _system_time;
  }
 
  {
    TIME_SECTION("final", 1, "Executing Final Objects")
    _problem.execMultiApps(EXEC_FINAL);
    _problem.finalizeMultiApps();
    _problem.postExecute();
    _problem.execute(EXEC_FINAL);
    _time = _time_step;
    _problem.outputStep(EXEC_FINAL);
    _time = _system_time;
  }
 
  postExecute();
}