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         216 : OptimizationInfo::validParams()
      17             : {
      18         216 :   InputParameters params = GeneralReporter::validParams();
      19         216 :   params.addClassDescription("Reports Optimization Output");
      20             : 
      21         216 :   MultiMooseEnum items("current_iterate function_value gnorm cnorm xdiff");
      22         432 :   params.addParam<MultiMooseEnum>(
      23             :       "items",
      24             :       items,
      25             :       "The information to output, if nothing is provided everything will be output.");
      26         216 :   params.set<ExecFlagEnum>("execute_on") = EXEC_TIMESTEP_END;
      27         216 :   params.suppressParameter<ExecFlagEnum>("execute_on");
      28         216 :   return params;
      29         216 : }
      30             : 
      31         108 : OptimizationInfo::OptimizationInfo(const InputParameters & parameters)
      32             :   : GeneralReporter(parameters),
      33         108 :     _optimization_executioner(dynamic_cast<Optimize *>(_app.getExecutioner())),
      34         216 :     _items(getParam<MultiMooseEnum>("items")),
      35         216 :     _functionValue(declareHelper<std::vector<double>>("function_value", REPORTER_MODE_REPLICATED)),
      36         216 :     _gnorm(declareHelper<std::vector<double>>("gnorm", REPORTER_MODE_REPLICATED)),
      37         216 :     _cnorm(declareHelper<std::vector<double>>("cnorm", REPORTER_MODE_REPLICATED)),
      38         216 :     _xdiff(declareHelper<std::vector<double>>("xdiff", REPORTER_MODE_REPLICATED)),
      39         108 :     _currentIterate(declareHelper<std::vector<int>>("current_iterate", REPORTER_MODE_REPLICATED)),
      40         108 :     _objectiveIterate(
      41         144 :         (!_items.isValid() || _items.isValueSet("current_iterate"))
      42         468 :             ? declareValueByName<std::vector<int>>("objective_iterate", REPORTER_MODE_REPLICATED)
      43           0 :             : declareUnusedValue<std::vector<int>>()),
      44         108 :     _gradientIterate(
      45         144 :         (!_items.isValid() || _items.isValueSet("current_iterate"))
      46         468 :             ? declareValueByName<std::vector<int>>("gradient_iterate", REPORTER_MODE_REPLICATED)
      47           0 :             : declareUnusedValue<std::vector<int>>()),
      48         108 :     _hessianIterate(
      49         144 :         (!_items.isValid() || _items.isValueSet("current_iterate"))
      50         468 :             ? declareValueByName<std::vector<int>>("hessian_iterate", REPORTER_MODE_REPLICATED)
      51           0 :             : declareUnusedValue<std::vector<int>>()),
      52         108 :     _functionSolves(
      53         144 :         (!_items.isValid() || _items.isValueSet("current_iterate"))
      54         468 :             ? declareValueByName<std::vector<int>>("function_solves", REPORTER_MODE_REPLICATED)
      55         108 :             : declareUnusedValue<std::vector<int>>())
      56             : {
      57         108 :   if (!_optimization_executioner)
      58           0 :     mooseError("The OptimizationInfo Reporter can only be used with a Optimize Executioner");
      59         108 : }
      60             : 
      61             : void
      62        2556 : OptimizationInfo::execute()
      63             : {
      64        2556 :   _optimization_executioner->getOptimizeSolve().getTaoSolutionStatus(_currentIterate,
      65             :                                                                      _gnorm,
      66             :                                                                      _objectiveIterate,
      67             :                                                                      _cnorm,
      68             :                                                                      _gradientIterate,
      69             :                                                                      _xdiff,
      70             :                                                                      _hessianIterate,
      71             :                                                                      _functionValue,
      72             :                                                                      _functionSolves);
      73        2556 : }