Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "OptimizationInfo.h"
      11             : #include "Optimize.h"
      12             : 
      13             : registerMooseObject("OptimizationApp", OptimizationInfo);
      14             : 
      15             : InputParameters
      16         144 : OptimizationInfo::validParams()
      17             : {
      18         144 :   InputParameters params = GeneralReporter::validParams();
      19         144 :   params.addClassDescription("Reports Optimization Output");
      20             : 
      21         144 :   MultiMooseEnum items("current_iterate function_value gnorm cnorm xdiff");
      22         288 :   params.addParam<MultiMooseEnum>(
      23             :       "items",
      24             :       items,
      25             :       "The information to output, if nothing is provided everything will be output.");
      26         144 :   params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
      27         144 :   params.suppressParameter<ExecFlagEnum>("execute_on");
      28         144 :   return params;
      29         144 : }
      30             : 
      31          72 : OptimizationInfo::OptimizationInfo(const InputParameters & parameters)
      32             :   : GeneralReporter(parameters),
      33          72 :     _optimization_executioner(dynamic_cast<Optimize *>(_app.getExecutioner())),
      34         144 :     _items(getParam<MultiMooseEnum>("items")),
      35         144 :     _functionValue(declareHelper<std::vector<double>>("function_value", REPORTER_MODE_REPLICATED)),
      36         144 :     _gnorm(declareHelper<std::vector<double>>("gnorm", REPORTER_MODE_REPLICATED)),
      37         144 :     _cnorm(declareHelper<std::vector<double>>("cnorm", REPORTER_MODE_REPLICATED)),
      38         144 :     _xdiff(declareHelper<std::vector<double>>("xdiff", REPORTER_MODE_REPLICATED)),
      39          72 :     _currentIterate(declareHelper<std::vector<int>>("current_iterate", REPORTER_MODE_REPLICATED)),
      40          72 :     _objectiveIterate(
      41          96 :         (!_items.isValid() || _items.isValueSet("current_iterate"))
      42         312 :             ? declareValueByName<std::vector<int>>("objective_iterate", REPORTER_MODE_REPLICATED)
      43           0 :             : declareUnusedValue<std::vector<int>>()),
      44          72 :     _gradientIterate(
      45          96 :         (!_items.isValid() || _items.isValueSet("current_iterate"))
      46         312 :             ? declareValueByName<std::vector<int>>("gradient_iterate", REPORTER_MODE_REPLICATED)
      47           0 :             : declareUnusedValue<std::vector<int>>()),
      48          72 :     _hessianIterate(
      49          96 :         (!_items.isValid() || _items.isValueSet("current_iterate"))
      50         312 :             ? declareValueByName<std::vector<int>>("hessian_iterate", REPORTER_MODE_REPLICATED)
      51           0 :             : declareUnusedValue<std::vector<int>>()),
      52          72 :     _functionSolves(
      53          96 :         (!_items.isValid() || _items.isValueSet("current_iterate"))
      54         312 :             ? declareValueByName<std::vector<int>>("function_solves", REPORTER_MODE_REPLICATED)
      55          72 :             : declareUnusedValue<std::vector<int>>())
      56             : {
      57          72 :   if (!_optimization_executioner)
      58           0 :     mooseError("The OptimizationInfo Reporter can only be used with a Optimize Executioner");
      59          72 : }
      60             : 
      61             : void
      62        1704 : OptimizationInfo::execute()
      63             : {
      64        1704 :   _optimization_executioner->getOptimizeSolve().getTaoSolutionStatus(_currentIterate,
      65             :                                                                      _gnorm,
      66             :                                                                      _objectiveIterate,
      67             :                                                                      _cnorm,
      68             :                                                                      _gradientIterate,
      69             :                                                                      _xdiff,
      70             :                                                                      _hessianIterate,
      71             :                                                                      _functionValue,
      72             :                                                                      _functionSolves);
      73        1704 : }