OpenMCProblemBase.h

Go to the documentation of this file.

/********************************************************************/
/*                  SOFTWARE COPYRIGHT NOTIFICATION                 */
/*                             Cardinal                             */
/*                                                                  */
/*                  (c) 2021 UChicago Argonne, LLC                  */
/*                        ALL RIGHTS RESERVED                       */
/*                                                                  */
/*                 Prepared by UChicago Argonne, LLC                */
/*               Under Contract No. DE-AC02-06CH11357               */
/*                With the U. S. Department of Energy               */
/*                                                                  */
/*             Prepared by Battelle Energy Alliance, LLC            */
/*               Under Contract No. DE-AC07-05ID14517               */
/*                With the U. S. Department of Energy               */
/*                                                                  */
/*                 See LICENSE for full restrictions                */
/********************************************************************/

#pragma once

#define LIBMESH

#include "CardinalProblem.h"
#include "PostprocessorInterface.h"
#include "CardinalEnums.h"

#include "mpi.h"
#include "openmc/bank.h"
#include "openmc/capi.h"
#include "openmc/cell.h"
#include "openmc/constants.h"
#include "openmc/geometry.h"
#include "openmc/geometry_aux.h"
#include "openmc/hdf5_interface.h"
#include "openmc/material.h"
#include "openmc/mesh.h"
#include "openmc/settings.h"
#include "openmc/simulation.h"
#include "openmc/random_ray/random_ray_simulation.h"
#include "openmc/source.h"
#include "openmc/state_point.h"
#include "openmc/tallies/tally.h"
#include "openmc/tallies/filter_cell_instance.h"

// Forward declarations to avoid cyclic dependencies.
class OpenMCNuclideDensities;
class OpenMCDomainFilterEditor;
class OpenMCTallyEditor;
class OpenMCCellTransform;
class CriticalitySearchBase;
class ModelModifiersBase;

typedef openmc::tensor::Tensor<double> OMCTensor;

class OpenMCProblemBase : public CardinalProblem, public PostprocessorInterface
{
public:
  OpenMCProblemBase(const InputParameters & params);

  static InputParameters validParams();

  virtual ~OpenMCProblemBase() override;

  std::string subdomainName(const SubdomainID & id) const;

  bool isReactionRateScore(const std::string & score) const;

  bool isHeatingScore(const std::string & score) const;

  Real tallyNormalizationValue() const;

  bool validRandomRayScore(const std::string & score) const;

  unsigned int addExternalVariable(const std::string & name,
                                   const std::string & system,
                                   const std::vector<SubdomainName> * block = nullptr);

  const Real & scaling() const { return _scaling; }

  bool hasScaling() const { return _specified_scaling; }

  bool runRandomRay() const;

  std::string enumToTallyScore(const std::string & score) const;

  std::string tallyScoreToEnum(const std::string & score) const;

  virtual void geometryType(bool & has_csg_universe, bool & has_dag_universe) const;

  bool firstSolve() const;

  openmc::TriggerMetric triggerMetric(trigger::TallyTriggerTypeEnum trigger) const;
  openmc::TriggerMetric triggerMetric(std::string trigger) const;

  openmc::TallyEstimator tallyEstimator(tally::TallyEstimatorEnum estimator) const;

  std::string estimatorToString(openmc::TallyEstimator estimator) const;

  void externalSolve() override;

  virtual void initialSetup() override;

  virtual void syncSolutions(ExternalProblem::Direction direction) override;
  virtual bool adaptMesh() override;

  void importProperties() const;

  OMCTensor tallySum(const openmc::Tally * tally, const unsigned int & score) const;

  double tallySumAcrossBins(std::vector<const openmc::Tally *> tally,
                            const unsigned int & score) const;

  double tallyMeanAcrossBins(std::vector<const openmc::Tally *> tally,
                             const unsigned int & score) const;

  typedef std::pair<int32_t, int32_t> cellInfo;

  bool cellIsVoid(const cellInfo & cell_info) const;

  bool cellHasZeroInstances(const cellInfo & cell_info) const;

  std::string materialName(const int32_t index) const;

  OMCTensor
  relativeError(const OMCTensor & sum, const OMCTensor & sum_sq, const int & n_realizations) const;

  Real relativeError(const Real & sum, const Real & sum_sq, const int & n_realizations) const;

  const Real densityConversionFactor() const;

  const Real * _particles;

  int nParticles() const;

  int nTotalParticles() const { return _total_n_particles; }

  openmc::RunMode runMode() const { return _run_mode; }

  int32_t cellID(const int32_t index) const;

  int32_t materialID(const int32_t index) const;

  std::string printPoint(const Point & p) const;

  std::string printMaterial(const int32_t & index) const;

  void writeSourceBank(const std::string & filename);

  unsigned int numElemsInSubdomain(const SubdomainID & id) const;

  bool isLocalElem(const Elem * elem) const;

  unsigned int globalElemID(const unsigned int & id) const { return _local_to_global_elem[id]; }

  virtual void setCellTemperature(const int32_t & id,
                                  const int32_t & instance,
                                  const Real & T,
                                  const cellInfo & cell_info) const;

  virtual void setCellDensity(const int32_t & id,
                              const int32_t & instance,
                              const Real & density,
                              const cellInfo & cell_info) const;

  virtual std::string printCell(const cellInfo & cell_info, const bool brief = false) const;

  virtual std::vector<int32_t> cellFill(const cellInfo & cell_info, int & fill_type) const;

  bool materialFill(const cellInfo & cell_info, int32_t & material_index) const;

  long unsigned int numCells() const;

  virtual std::vector<int32_t> getMappedTallyIDs() const = 0;

  bool computeKineticsParams() const { return _calc_kinetics_params; }

  const openmc::Tally & getCommonKineticsTally();

  const openmc::Tally & getMGBetaTally();

protected:
  virtual void critSearchStep() = 0;

  void getOpenMCUserObjects();

  bool hasCellTransform() const;

  void checkOpenMCUserObjectIDs() const;

  void checkTallyEditorIDs() const;

  void executeFilterEditors();

  void executeTallyEditors();

  // execute tallly and filte editors
  void executeEditors();

  void sendNuclideDensitiesToOpenMC();

  void sendTallyNuclidesToOpenMC();

  void fillElementalAuxVariable(const unsigned int & var_num,
                                const std::vector<unsigned int> & elem_ids,
                                const Real & value);

  std::string sourceBankFileName() const
  {
    return openmc::settings::path_output + "initial_source_" +
           std::to_string(_fixed_point_iteration) + ".h5";
  }

  const bool & _verbose;

  const Real * _power;

  const Real * _source_strength;

  bool _reuse_source;

  const bool _specified_scaling;

  const Real & _scaling;

  const bool & _skip_statepoint;

  int _fixed_point_iteration;

  unsigned int _total_n_particles;

  long unsigned int _n_openmc_cells;

  int _n_cell_digits;

  openmc::RunMode _run_mode;

  std::vector<OpenMCNuclideDensities *> _nuclide_densities_uos;

  std::vector<OpenMCDomainFilterEditor *> _filter_editor_uos;

  std::vector<OpenMCTallyEditor *> _tally_editor_uos;

  std::vector<OpenMCCellTransform *> _cell_transform_uos;

  std::vector<unsigned int> _local_to_global_elem;

  const bool _has_adaptivity;

  bool _run_on_adaptivity_cycle;

  const bool _calc_kinetics_params;

  const bool & _reset_seed;

  const int64_t _initial_seed;

  int _ifp_common_tally_index = -1;

  int _ifp_mg_beta_tally_index = -1;

  openmc::Tally * _ifp_common_tally = nullptr;

  openmc::Tally * _ifp_mg_beta_tally = nullptr;

  const std::string & _xml_directory;

  static constexpr Real _density_conversion_factor{0.001};

  static constexpr int MATERIAL_VOID{-1};

  CriticalitySearchBase * _criticality_search = nullptr;
};