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 "OpenMCNuclideDensities.h"
#include "OpenMCTallyNuclides.h"
 
#include "mpi.h"
#include "openmc/bank.h"
#include "openmc/capi.h"
#include "openmc/cell.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/source.h"
#include "openmc/state_point.h"
#include "openmc/tallies/tally.h"
#include "openmc/tallies/filter_cell_instance.h"
#include "xtensor/xview.hpp"
 
class OpenMCProblemBase : public CardinalProblem, public PostprocessorInterface
{
public:
 OpenMCProblemBase(const InputParameters & params);
 
 static InputParameters validParams();
 
 virtual ~OpenMCProblemBase() override;
 
 std::string subdomainName(const SubdomainID & id) const;
 
 void catchOpenMCError(const int & err, const std::string descriptor) const;
 
 bool isHeatingScore(const std::string & score) const;
 
 unsigned int addExternalVariable(const std::string & name, const std::vector<SubdomainName> * block = nullptr);
 
 const Real & scaling() const { return _scaling; }
 
 bool hasScaling() const { return _specified_scaling; }
 
 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;
 
 void importProperties() const;
 
 xt::xtensor<double, 1> tallySum(openmc::Tally * tally, const unsigned int & score) const;
 
 double tallySumAcrossBins(std::vector<openmc::Tally *> tally, const unsigned int & score) const;
 
 double tallyMeanAcrossBins(std::vector<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;
 
 xt::xtensor<double, 1> relativeError(const xt::xtensor<double, 1> & sum,
 const xt::xtensor<double, 1> & sum_sq, const int & n_realizations) const;
 
 const Real & densityConversionFactor() const { return _density_conversion_factor; }
 
 int nParticles() const;
 
 int nTotalParticles() const { return _total_n_particles; }
 
 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 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;
 
protected:
 void getOpenMCUserObjects();
 
 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<OpenMCTallyNuclides *> _tally_nuclides_uos;
 
 std::vector<unsigned int> _local_to_global_elem;
 
 static constexpr Real _density_conversion_factor{0.001};
 
 static constexpr int MATERIAL_VOID{-1};
};