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 "xtensor/xview.hpp"
 
class OpenMCCellAverageProblem;
class MooseMesh;
class AuxiliarySystem;
class FilterBase;
 
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,
                    unsigned int global_score,
                    const std::string & output_type);
 
  void addScore(const std::string & score);
 
  void computeSumAndMean();
 
  void relaxAndNormalizeTally(unsigned int local_score, const Real & alpha, const Real & norm);
 
  const openmc::Tally * getWrappedTally() const;
 
  int32_t getTallyID() 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 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 hasScore(const std::string & score) const {…}
 
  bool renamesTallyVars() const { return _renames_tally_vars; }
 
  unsigned int numExtFilterBins() const { return _num_ext_filter_bins; }
 
protected:
  virtual Real storeResultsInner(const std::vector<unsigned int> & var_numbers,
                                 unsigned int local_score,
                                 unsigned int global_score,
                                 std::vector<xt::xtensor<double, 1>> 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);
 
  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;
 
  unsigned int _filter_index;
 
  unsigned int _num_ext_filter_bins = 1;
 
  std::vector<Real> _local_sum_tally;
 
  std::vector<Real> _local_mean_tally;
 
  const MultiMooseEnum * _tally_trigger;
 
  std::vector<Real> _tally_trigger_threshold;
 
  std::vector<bool> _trigger_ignore_zeros;
 
  std::vector<xt::xtensor<double, 1>> _current_tally;
 
  std::vector<xt::xtensor<double, 1>> _previous_tally;
 
  std::vector<xt::xtensor<double, 1>> _current_raw_tally;
 
  std::vector<xt::xtensor<double, 1>> _current_raw_tally_rel_error;
 
  std::vector<xt::xtensor<double, 1>> _current_raw_tally_std_dev;
 
  const bool _renames_tally_vars;
 
  const bool _has_outputs;
 
  std::vector<std::string> _output_name;
 
  const bool _is_adaptive;
 
  static constexpr Real ZERO_TALLY_THRESHOLD = 1e-12;
};
class TallyBase : public MooseObject {…};