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;

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

  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]; }

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

  bool hasOutputs() const { return _has_outputs; }

  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) = 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_std_dev;

  const bool _renames_tally_vars;

  const bool _has_outputs;

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

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