CardinalEnums.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 "MooseEnum.h"
#include "MultiMooseEnum.h"
 
MooseEnum getSynchronizationEnum();
MooseEnum getNekOrderEnum();
MooseEnum getBinnedVelocityComponentEnum();
MooseEnum getNekFieldEnum();
MooseEnum getOperationEnum();
MooseEnum getTallyTypeEnum();
MooseEnum getTallyEstimatorEnum();
MooseEnum getEigenvalueEnum();
MooseEnum getRelaxationEnum();
MooseEnum getTallyTriggerEnum();
MooseEnum getInitialPropertiesEnum();
MultiMooseEnum getTallyScoreEnum();
MooseEnum getSingleTallyScoreEnum();
MooseEnum getEnergyGroupsEnum();
MooseEnum getNekMeshEnum();
MooseEnum getFilterTypeEnum();
 
namespace nek_mesh
{
 
enum NekMeshEnum
{
  fluid,
  solid,
  all
};
enum NekMeshEnum {…};
} // namespace nek_mesh
namespace nek_mesh {…}
 
namespace synchronization
{
enum SynchronizationEnum
{
  constant,
  parent_app
};
enum SynchronizationEnum {…};
} //namespace synchronization
namespace synchronization {…}
 
namespace order
{
enum NekOrderEnum
{
  first,
  second
};
enum NekOrderEnum {…};
} // namespace order
namespace order {…}
 
namespace component
{
enum BinnedVelocityComponentEnum
{
  normal,
  user
};
enum BinnedVelocityComponentEnum {…};
} // namespace component
namespace component {…}
 
namespace field
{
enum NekFieldEnum
{
  velocity_x,
  velocity_y,
  velocity_z,
  velocity,
  velocity_component,
  velocity_x_squared,
  velocity_y_squared,
  velocity_z_squared,
  temperature,
  pressure,
  scalar01,
  scalar02,
  scalar03,
  unity,
  usrwrk00,
  usrwrk01,
  usrwrk02
};
enum NekFieldEnum {…};
 
enum NekWriteEnum
{
  flux,
  heat_source,
  x_displacement,
  y_displacement,
  z_displacement,
  mesh_velocity_x,
  mesh_velocity_y,
  mesh_velocity_z
};
enum NekWriteEnum {…};
} // namespace field
namespace field {…}
 
namespace operation
{
enum OperationEnum
{
  max,
  min,
  average
};
enum OperationEnum {…};
} // namespace operation
namespace operation {…}
 
namespace tally
{
enum TallyTypeEnum
{
  cell,
  mesh,
  none
};
enum TallyTypeEnum {…};
 
enum TallyEstimatorEnum
{
  collision,
  tracklength,
  analog
};
enum TallyEstimatorEnum {…};
 
enum TallyScoreEnum
{
  heating,
  heating_local,
  kappa_fission,
  fission_q_prompt,
  fission_q_recoverable,
  damage_energy,
  flux,
  H3_production
};
enum TallyScoreEnum {…};
} // namespace tally
namespace tally {…}
 
namespace trigger
{
enum TallyTriggerTypeEnum
{
  variance,
  std_dev,
  rel_err,
  none
};
enum TallyTriggerTypeEnum {…};
} // namespace trigger
namespace trigger {…}
 
namespace energyfilter
{
enum GroupStructureEnum
{
  CASMO_2,
  CASMO_4,
  CASMO_8,
  CASMO_16,
  CASMO_25,
  CASMO_40,
  VITAMINJ_42,
  SCALE_44,
  MPACT_51,
  MPACT_60,
  MPACT_69,
  CASMO_70,
  XMAS_172,
  VITAMINJ_175,
  SCALE_252,
  TRIPOLI_315,
  SHEM_361,
  CCFE_709,
  UKAEA_1102,
  ECCO_1968
};
enum GroupStructureEnum {…};
} // namespace energyfilter
namespace energyfilter {…}
 
namespace coupling
{
enum CouplingFields
{
  temperature,
  density,
  density_and_temperature,
  none
};
enum CouplingFields {…};
 
enum OpenMCInitialCondition
{
  hdf5,
  moose,
  xml
};
enum OpenMCInitialCondition {…};
} // namespace coupling
namespace coupling {…}
 
namespace eigenvalue
{
enum EigenvalueEnum
{
  collision,
  absorption,
  tracklength,
  combined
};
enum EigenvalueEnum {…};
} // namespace eigenvalue
namespace eigenvalue {…}
 
namespace relaxation
{
enum RelaxationEnum
{
  constant,
  robbins_monro,
  dufek_gudowski,
  none
};
enum RelaxationEnum {…};
} // namespace relaxation
namespace relaxation {…}
 
enum OpenMCFilterType
{
  cell,
  material,
  universe,
  mesh,
  none
};
enum OpenMCFilterType {…};