TallyBase.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

#include "MooseObject.h"
#include "CardinalEnums.h"

#include "openmc/tallies/tally.h"
#include "openmc/tensor.h"

class OpenMCCellAverageProblem;
class MooseMesh;
class AuxiliarySystem;
class FilterBase;

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

class TallyBase : public MooseObject
{
public:
  static InputParameters validParams();

  TallyBase(const InputParameters & parameters);

  virtual std::pair<unsigned int, openmc::Filter *> spatialFilter() = 0;

  virtual void initializeTally();

  virtual void resetTally();

  Real storeResults(const std::vector<unsigned int> & var_numbers,
                    unsigned int local_score,
                    const std::string & output_type);

  void addScore(const std::string & score);

  void setRelaxation(relaxation::RelaxationEnum relaxation_type, const Real & relaxation_factor);

  void computeSumAndMean();

  virtual void gatherLinkedSum();

  virtual void renormalizeLinkedTallies();

  void relaxAndNormalizeTally();

  void addLinkedTally(const TallyBase * other);

  const openmc::Tally * getWrappedTally() const;

  const openmc::Tally * getWrappedGlobalTally() const;

  int32_t getTallyID() const;

  int32_t getGlobalTallyID() const;

  const std::vector<std::string> & getScores() const { return _tally_score; }

  int scoreIndex(const std::string & score) const;

  const std::vector<std::string> & getAuxVarNames() const { return _tally_name; }

  const std::vector<std::string> & getOutputs() const { return _output_name; }

  openmc::TallyEstimator getTallyEstimator() const { return _estimator; }

  const Real & getMean(unsigned int local_score) const { return _local_mean_tally[local_score]; }

  const Real & getSum(unsigned int local_score) const { return _local_sum_tally[local_score]; }

  std::vector<std::string> getScoreVars(const std::string & score) const;

  bool extBinSkipped(unsigned int ext_bin) const { return _ext_bins_to_skip[ext_bin]; }

  bool hasTrigger() const { return _tally_trigger != nullptr; }

  bool hasOutputs() const { return _has_outputs; }

  bool hasScore(const std::string & score) const
  {
    return std::find(_tally_score.begin(), _tally_score.end(), score) != _tally_score.end();
  }

  bool renamesTallyVars() const { return _renames_tally_vars; }

  unsigned int numExtFilterBins() const { return _num_ext_filter_bins; }

  const std::set<SubdomainID> & getBlocks() const { return _tally_blocks; }

  virtual bool addingGlobalTally() const { return _needs_global_tally; }

  const std::vector<const TallyBase *> & linkedTallies() const { return _linked_tallies; }

protected:
  virtual Real storeResultsInner(const std::vector<unsigned int> & var_numbers,
                                 unsigned int local_score,
                                 const std::vector<OMCTensor> & tally_vals,
                                 bool norm_by_src_rate = true) = 0;

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

  void applyTriggersToLocalTally(openmc::Tally * tally);

  Real tallyNormalization(unsigned int score) const;

  void checkTallySum(const unsigned int & score) const;

  void checkNormalization(const Real & sum, unsigned int score) const;

  OpenMCCellAverageProblem & _openmc_problem;

  MooseMesh & _mesh;

  AuxiliarySystem & _aux;

  std::vector<std::shared_ptr<FilterBase>> _ext_filters;

  openmc::TallyEstimator _estimator;

  std::vector<std::string> _tally_score;

  std::vector<std::string> _tally_name;

  openmc::Tally * _local_tally = nullptr;

  unsigned int _local_tally_index;

  openmc::Tally * _global_tally = nullptr;

  unsigned int _global_tally_index;

  unsigned int _filter_index;

  unsigned int _num_ext_filter_bins = 1;

  std::vector<Real> _local_sum_tally;

  std::vector<Real> _global_sum_tally;

  std::vector<Real> _local_mean_tally;

  std::vector<Real> _linked_local_sum_tally;

  const MultiMooseEnum * _tally_trigger;

  std::vector<Real> _tally_trigger_threshold;

  std::vector<bool> _trigger_ignore_zeros;

  std::vector<OMCTensor> _current_tally;

  std::vector<OMCTensor> _previous_tally;

  std::vector<OMCTensor> _current_raw_tally;

  std::vector<OMCTensor> _current_raw_tally_rel_error;

  std::vector<OMCTensor> _current_raw_tally_std_dev;

  const bool _normalize_by_global;

  const bool _check_tally_sum;

  const bool _needs_global_tally;

  const bool _renames_tally_vars;

  const bool _has_outputs;

  std::vector<std::string> _output_name;

  const bool _is_adaptive;

  std::vector<bool> _ext_bins_to_skip;

  std::set<SubdomainID> _tally_blocks;

  std::vector<const TallyBase *> _linked_tallies;

  relaxation::RelaxationEnum _relaxation_type;

  Real _relaxation_factor;

  static constexpr Real ZERO_TALLY_THRESHOLD = 1e-12;
};