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);
 
  virtual 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 Real & _tally_sum_tol;
 
  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;
};