InputParameterWarehouse.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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

#pragma once

#include <gtest/gtest.h>
#include "MooseObjectName.h"
#include "MooseTypes.h"
#include "ControllableItem.h"
#include "ControllableParameter.h"
#include "Factory.h"
#include "ControlOutput.h"

// Forward declarations
class InputParameters;

class InputParameterWarehouse
{
public:
  InputParameterWarehouse();

  virtual ~InputParameterWarehouse() = default;


  const InputParameters & getInputParametersObject(const std::string & name,
                                                   THREAD_ID tid = 0) const;
  const InputParameters & getInputParametersObject(const std::string & tag,
                                                   const std::string & name,
                                                   THREAD_ID tid = 0) const;
  const InputParameters & getInputParametersObject(const MooseObjectName & object_name,
                                                   THREAD_ID tid = 0) const;

  const std::multimap<MooseObjectName, std::shared_ptr<InputParameters>> &
  getInputParameters(THREAD_ID tid = 0) const;

  void addControllableParameterConnection(const MooseObjectParameterName & master,
                                          const MooseObjectParameterName & slave,
                                          bool error_on_empty = true);

  void addControllableParameterAlias(const MooseObjectParameterName & alias,
                                     const MooseObjectParameterName & slave);

  /***
   * Helper method for printing controllable items.
   */
  std::string dumpChangedControls(bool reset_changed) const;

  template <typename T>
  std::vector<T> getControllableParameterValues(const MooseObjectParameterName & input) const;

private:
  std::vector<std::multimap<MooseObjectName, std::shared_ptr<InputParameters>>> _input_parameters;

  std::vector<std::vector<std::shared_ptr<ControllableItem>>> _controllable_items;

  InputParameters &
  addInputParameters(const std::string & name, InputParameters parameters, THREAD_ID tid = 0);

  void removeInputParameters(const MooseObject & moose_object, THREAD_ID tid = 0);

  ControllableParameter getControllableParameter(const MooseObjectParameterName & input) const;

  std::vector<ControllableItem *> getControllableItems(const MooseObjectParameterName & desired,
                                                       THREAD_ID tid = 0) const;


  InputParameters & getInputParameters(const std::string & name, THREAD_ID tid = 0) const;
  InputParameters &
  getInputParameters(const std::string & tag, const std::string & name, THREAD_ID tid = 0) const;
  InputParameters & getInputParameters(const MooseObjectName & object_name,
                                       THREAD_ID tid = 0) const;

  friend MooseObjectPtr
  Factory::create(const std::string &, const std::string &, InputParameters, THREAD_ID, bool);
  friend void Factory::releaseSharedObjects(const MooseObject &, THREAD_ID);

  friend class Control;

  // Allow unit test to call methods
  FRIEND_TEST(InputParameterWarehouse, getControllableItems);
  FRIEND_TEST(InputParameterWarehouse, getControllableParameter);
  FRIEND_TEST(InputParameterWarehouse, getControllableParameterValues);
  FRIEND_TEST(InputParameterWarehouse, addControllableParameterConnection);
  FRIEND_TEST(InputParameterWarehouse, addControllableParameterAlias);
};

template <typename T>
std::vector<T>
InputParameterWarehouse::getControllableParameterValues(
    const MooseObjectParameterName & input) const
{
  ControllableParameter param = getControllableParameter(input);
  return param.get<T>();
}