Namespaces
namespace	GRIN
namespace	Functions
namespace	Map
namespace	Construction
namespace	Documentation_1_10
namespace	ExternalFiles
namespace	Table
namespace	Styles
namespace	Array
namespace	DoubleDifferentialCrossSection
namespace	Distributions
namespace	TargetInfo
namespace	Transporting
namespace	ACE_URR
namespace	Sums
namespace	RISI

Classes
class	GNDS_FileTypeInfo
class	Exception
class	SetupInfo
class	Form
class	LazyParsingHelperForm
class	PhysicalQuantity
class	ParticleInfo
class	AxisDomain
class	Axis
class	Grid
class	Axes
class	FlattenedArrayData
class	Array3d
class	Suite
class	Component
class	Flux
class	Group
class	Transportable
class	ExternalFile
class	Product
class	DelayedNeutron
class	DelayedNeutronProduct
class	FissionFragmentData
class	OutputChannel
class	Reaction
class	Protare
class	ProtareSingle
class	ProtareComposite
class	ProtareTNSL
class	Groups
class	Fluxes
class	MultiGroupCalulationInformation
class	Data1d
class	Vector
class	Matrix
class	GNDS_FileTypeInfoUserData

Typedefs
typedef std::set< std::size_t >	ExcludeReactionsSet
typedef bool(*	MapWalkCallBack) (Map::ProtareBase const a_protareEntry, std::string const &a_library, void a_userData, int a_level)
typedef Form (	parseSuite) (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pop, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
typedef std::pair< std::string, double >	stringAndDoublePair
typedef std::vector< stringAndDoublePair >	stringAndDoublePairs
typedef std::map< std::string, ParticleInfo >	ParticleSubstitution
typedef std::vector< DelayedNeutronProduct >	DelayedNeutronProducts

Enumerations
enum class	GNDS_FileType { uninitialized , unknown , pops , protare , covarianceSuite , map }
enum class	ProtareType { single , composite , TNSL }
enum class	FormType { generic , lazyParsingHelperForm , group , groups , transportable , flux , fluxes , externalFile , style , reaction , product , delayedNeutron , fissionFragmentData , rate , physicalQuantity , axisDomain , axis , grid , axes , flattenedArrayData , array3d , array , constant1d , XYs1d , Ys1d , polynomial1d , Legendre1d , gridded1d , reference1d , xs_pdf_cdf1d , regions1d , resonancesWithBackground1d , resonanceBackground1d , resonanceBackgroundRegion1d , URR_probabilityTables1d , fissionEnergyRelease1d , branching1d , branching1dPids , thermalNeutronScatteringLaw1d , unspecified1d , XYs2d , recoil2d , isotropic2d , discreteGamma2d , primaryGamma2d , regions2d , gridded2d , generalEvaporation2d , simpleMaxwellianFission2d , evaporation2d , Watt2d , MadlandNix2d , weighted_function2d , weightedFunctionals2d , NBodyPhaseSpace2d , XYs3d , regions3d , gridded3d , angularTwoBody , KalbachMann , uncorrelated , unspecified , reference3d , multiGroup3d , energyAngular , energyAngularMC , angularEnergy , angularEnergyMC , LLNL_angularEnergy , coherentPhotonScattering , incoherentPhotonScattering , incoherentBoundToFreePhotonScattering , thermalNeutronScatteringLaw , branching3d , coherentElastic , incoherentElastic , incoherentInelastic , CoulombPlusNuclearElastic3d , LLNLLegendre , crossSectionSum , multiplicitySum , summands , ACE_URR_probabilityTable , ACE_URR_incidentEnergy , table , columnHeaders , column , GRIN_inelasticIncidentEnergy , GRIN_captureLevelProbability }
enum class	Frame { lab , centerOfMass }
enum class	TransportCorrectionType { None , Pendlebury , LLNL , Ferguson }
enum class	FileType { XML , HDF }

Functions
std::vector< std::string >	vectorOfStrings (std::string const &a_string)
Form *	parseExternalFilesSuite (Construction::Settings const &a_construction, Suite parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pop, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseStylesSuite (Construction::Settings const &a_construction, Suite parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pop, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseTransportablesSuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseReaction (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseOrphanProduct (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseFissionComponent (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseReactionType (std::string const &a_moniker, Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseSumsCrossSectionsSuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseSumsMultiplicitiesSuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseDoubleDifferentialCrossSectionSuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseScatteringAtom (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseCrossSectionSuite (Construction::Settings const &a_construction, Suite parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pop, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseDelayedNeutronsSuite (Construction::Settings const &a_construction, Suite parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pop, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseFissionEnergyReleasesSuite (Construction::Settings const &a_construction, Suite parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pop, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parsePhysicalQuantitySuite (Construction::Settings const &a_construction, Suite parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pop, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseAvailableSuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseQSuite (Construction::Settings const &a_construction, Suite parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pop, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseProductSuite (Construction::Settings const &a_construction, Suite parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pop, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseMultiplicitySuite (Construction::Settings const &a_construction, Suite parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pop, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseDistributionSuite (Construction::Settings const &a_construction, Suite parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pop, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseAverageEnergySuite (Construction::Settings const &a_construction, Suite parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pop, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseAverageMomentumSuite (Construction::Settings const &a_construction, Suite parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pop, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseACE_URR_probabilityTables (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Form *	parseColumnHeaders (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const a_styles)
Functions::Function1dForm *	data1dParse (Construction::Settings const &a_construction, HAPI::Node const &a_node, SetupInfo &a_setupInfo, Suite *parent)
Functions::Function1dForm *	data1dParseAllowEmpty (Construction::Settings const &a_construction, HAPI::Node const &a_node, SetupInfo &a_setupInfo, Suite *a_parent)
void	data1dListParse (Construction::Settings const &a_construction, HAPI::Node const &a_node, SetupInfo &a_setupInfo, std::vector< Functions::Function1dForm * > &a_function1ds)
Functions::Function2dForm *	data2dParse (Construction::Settings const &a_construction, HAPI::Node const &a_node, SetupInfo &a_setupInfo, Suite *parent)
void	data2dListParse (Construction::Settings const &a_construction, HAPI::Node const &a_node, SetupInfo &a_setupInfo, std::vector< Functions::Function2dForm * > &a_function2ds)
Functions::Function3dForm *	data3dParse (Construction::Settings const &a_construction, HAPI::Node const &a_node, SetupInfo &a_setupInfo, Suite *parent)
void	checkOuterDomainValues1d (std::vector< Functions::Function1dForm * > &a_functions, std::vector< double > &a_Xs)
void	checkOuterDomainValues2d (std::vector< Functions::Function2dForm * > &a_functions, std::vector< double > &a_Xs)
void	checkSequentialDomainLimits1d (std::vector< Functions::Function1dForm * > &a_functions, std::vector< double > &a_Xs)
void	checkSequentialDomainLimits2d (std::vector< Functions::Function2dForm * > &a_functions, std::vector< double > &a_Xs)
int	parseFlattened1d (Construction::Settings const &a_construction, HAPI::Node const &a_node, SetupInfo &a_setupInfo, Vector &data)
Vector	collapse (Vector const &a_vector, Transporting::Settings const &a_settings, Transporting::Particles const &a_particles, double a_temperature)
Matrix	collapse (Matrix const &a_matrix, Transporting::Settings const &a_settings, Transporting::Particles const &a_particles, double a_temperature, std::string const &a_productID)
Vector	transportCorrect (Vector const &a_vector, Vector const &a_transportCorrection)
Matrix	transportCorrect (Matrix const &a_matrix, Vector const &a_transportCorrection)
Vector	multiGroupXYs1d (Transporting::MultiGroup const &a_boundaries, Functions::XYs1d const &a_function, Transporting::Flux const &a_flux)
Vector *	multiGroupTwoXYs1ds (MultiGroupCalulationInformation const &a_multiGroupCalulationInformation, Functions::XYs1d const &a_function1, Functions::XYs1d const &a_function2)
void	calculate1dMultiGroupDataInComponent (ProtareSingle const *a_protare, std::string const &a_heatedMultiGroupLabel, MultiGroupCalulationInformation const &a_multiGroupCalulationInformation, Component &a_component, Functions::XYs1d const &a_crossSection)
void	calculate1dMultiGroupFissionEnergyRelease (MultiGroupCalulationInformation const &a_multiGroupCalulationInformation, Functions::XYs1d const &a_weight, Functions::Function1dForm const a_evaluated, Functions::Function1dForm a_gridded1d)
int	ENDL_CFromENDF_MT (int ENDF_MT, int ENDL_C, int ENDL_S)
GNDS_FileType	GNDS_fileType (std::string const &a_fileName, GNDS_FileTypeInfo &a_GNDS_fileTypeInfo)
long	binarySearchVector (double a_x, std::vector< double > const &a_Xs)
void	intsToXMLList (GUPI::WriteInfo &a_writeInfo, std::string const &a_indent, std::vector< int > const &a_values, std::string const &a_attributes)
void	parseValuesOfDoubles (Construction::Settings const &a_construction, HAPI::Node const &a_node, SetupInfo &a_setupInfo, nf_Buffer< double > &a_vector)
void	parseValuesOfDoubles (HAPI::Node const &a_node, SetupInfo &a_setupInfo, nf_Buffer< double > &a_vector, int a_useSystem_strtod)
void	parseValuesOfInts (Construction::Settings const &a_construction, HAPI::Node const &a_node, SetupInfo &a_setupInfo, std::vector< int > &a_vector)
void	parseValuesOfInts (HAPI::Node const &a_node, SetupInfo &a_setupInfo, nf_Buffer< int > &a_vector)
void	doublesToXMLList (GUPI::WriteInfo &a_writeInfo, std::string const &a_indent, std::vector< double > const &a_values, std::size_t a_start=0, bool a_newLine=true, std::string const &a_valueType="")
Frame	parseFrame (HAPI::Node const &a_node, SetupInfo &a_setupInfo, std::string const &a_name)
std::string	frameToString (Frame a_frame)
std::string	intToString (int a_value)
std::string	size_t_ToString (std::size_t a_value)
std::string	nodeWithValuesToDoubles (GUPI::WriteInfo &a_writeInfo, std::string const &a_nodeName, std::vector< double > const &a_values)
void	excludeReactionsSetAdjust (ExcludeReactionsSet &a_excludeReactionsSet, Protare const &a_protare)
Functions::Ys1d	gridded1d2GIDI_Ys1d (Functions::Function1dForm const &a_function1d)
Functions::Ys1d	vector2GIDI_Ys1d (Axes const &a_axes, Vector const &a_vector)
std::string	LLNL_gidToLabel (int a_gid)
std::string	LLNL_fidToLabel (int a_fid)
std::vector< std::string >	sortedListOfStrings (std::vector< std::string > const &a_strings, bool a_orderIsAscending=true)
void	energy2dToXMLList (GUPI::WriteInfo &a_writeInfo, std::string const &a_moniker, std::string const &a_indent, Functions::Function1dForm *a_function)
std::vector< Transporting::Flux >	settingsFluxesFromFunction3d (Functions::Function3dForm const &a_function3d)
void	calculate1dMultiGroupDataInComponent (LUPI_maybeUnused ProtareSingle const *a_protare, std::string const &a_heatedMultiGroupLabel, MultiGroupCalulationInformation const &a_multiGroupCalulationInformation, Component &a_component, Functions::XYs1d const &a_weight)
void	parseValuesOfDoubles (HAPI::Node const &a_node, SetupInfo &a_setupInfo, nf_Buffer< double > &a_values, LUPI_maybeUnused int a_useSystem_strtod)
void	parseValuesOfInts (LUPI_maybeUnused Construction::Settings const &a_construction, HAPI::Node const &a_node, SetupInfo &a_setupInfo, nf_Buffer< int > &a_values)
Frame	parseFrame (HAPI::Node const &a_node, LUPI_maybeUnused SetupInfo &a_setupInfo, std::string const &a_name)
Form *	parseExternalFilesSuite (LUPI_maybeUnused Construction::Settings const &a_construction, GIDI::Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, LUPI_maybeUnused PoPI::Database const &a_pops, LUPI_maybeUnused PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseStylesSuite (Construction::Settings const &a_construction, GIDI::Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseTransportablesSuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, LUPI_maybeUnused PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseSumsCrossSectionsSuite (Construction::Settings const &a_construction, LUPI_maybeUnused Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseSumsMultiplicitiesSuite (Construction::Settings const &a_construction, LUPI_maybeUnused Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseDoubleDifferentialCrossSectionSuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pops, PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseScatteringAtom (Construction::Settings const &a_construction, LUPI_maybeUnused Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, LUPI_maybeUnused PoPI::Database const &a_pops, LUPI_maybeUnused PoPI::Database const &a_internalPoPs, LUPI_maybeUnused std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseCrossSectionSuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, LUPI_maybeUnused PoPI::Database const &a_pops, LUPI_maybeUnused PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseFissionEnergyReleasesSuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, LUPI_maybeUnused PoPI::Database const &a_pops, LUPI_maybeUnused PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parsePhysicalQuantitySuite (LUPI_maybeUnused Construction::Settings const &a_construction, LUPI_maybeUnused Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, LUPI_maybeUnused PoPI::Database const &a_pops, LUPI_maybeUnused PoPI::Database const &a_internalPoPs, LUPI_maybeUnused std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseAvailableSuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, LUPI_maybeUnused PoPI::Database const &a_pops, LUPI_maybeUnused PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseQSuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, LUPI_maybeUnused PoPI::Database const &a_pops, LUPI_maybeUnused PoPI::Database const &a_internalPoPs, LUPI_maybeUnused std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseMultiplicitySuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, LUPI_maybeUnused PoPI::Database const &a_pops, LUPI_maybeUnused PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseDistributionSuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, LUPI_maybeUnused PoPI::Database const &a_pops, LUPI_maybeUnused PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseAverageEnergySuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, LUPI_maybeUnused PoPI::Database const &a_pops, LUPI_maybeUnused PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseAverageMomentumSuite (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, LUPI_maybeUnused PoPI::Database const &a_pops, LUPI_maybeUnused PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseACE_URR_probabilityTables (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, LUPI_maybeUnused PoPI::Database const &a_pops, LUPI_maybeUnused PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
Form *	parseColumnHeaders (Construction::Settings const &a_construction, Suite a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, LUPI_maybeUnused PoPI::Database const &a_pops, LUPI_maybeUnused PoPI::Database const &a_internalPoPs, std::string const &a_name, LUPI_maybeUnused Styles::Suite const a_styles)
std::ostream &	operator<< (std::ostream &a_os, PhysicalQuantity const &a_physicalQuantity)

Typedef Documentation

◆ DelayedNeutronProducts

typedef std::vector<DelayedNeutronProduct> GIDI::DelayedNeutronProducts

Definition at line 4031 of file GIDI.hpp.

◆ ExcludeReactionsSet

typedef std::set<std::size_t> GIDI::ExcludeReactionsSet

Definition at line 47 of file GIDI.hpp.

◆ MapWalkCallBack

typedef bool(* GIDI::MapWalkCallBack) (Map::ProtareBase const *a_protareEntry, std::string const &a_library, void *a_userData, int a_level)

Definition at line 62 of file GIDI.hpp.

◆ parseSuite

typedef Form *(* GIDI::parseSuite) (Construction::Settings const &a_construction, Suite *a_parent, HAPI::Node const &a_node, SetupInfo &a_setupInfo, PoPI::Database const &a_pop, PoPI::Database const &a_internalPoPs, std::string const &a_name, Styles::Suite const *a_styles)

Definition at line 86 of file GIDI.hpp.

◆ ParticleSubstitution

typedef std::map<std::string, ParticleInfo> GIDI::ParticleSubstitution

Definition at line 487 of file GIDI.hpp.

◆ stringAndDoublePair

typedef std::pair<std::string, double> GIDI::stringAndDoublePair

Definition at line 485 of file GIDI.hpp.

◆ stringAndDoublePairs

typedef std::vector<stringAndDoublePair> GIDI::stringAndDoublePairs

Definition at line 486 of file GIDI.hpp.

Enumeration Type Documentation

◆ FileType

enum class GIDI::FileType

strong

Enumerator
XML
HDF

Definition at line 148 of file GIDI.hpp.

148{ XML, HDF };

GIDI::FileType::HDF

@ HDF

Definition GIDI.hpp:148

GIDI::FileType::XML

@ XML

Definition GIDI.hpp:148

◆ FormType

enum class GIDI::FormType

strong

Enumerator
generic
lazyParsingHelperForm
group
groups
transportable
flux
fluxes
externalFile
style
reaction
product
delayedNeutron
fissionFragmentData
rate
physicalQuantity
axisDomain
axis
grid
axes
flattenedArrayData
array3d
array
constant1d
XYs1d
Ys1d
polynomial1d
Legendre1d
gridded1d
reference1d
xs_pdf_cdf1d
regions1d
resonancesWithBackground1d
resonanceBackground1d
resonanceBackgroundRegion1d
URR_probabilityTables1d
fissionEnergyRelease1d
branching1d
branching1dPids
thermalNeutronScatteringLaw1d
unspecified1d
XYs2d
recoil2d
isotropic2d
discreteGamma2d
primaryGamma2d
regions2d
gridded2d
generalEvaporation2d
simpleMaxwellianFission2d
evaporation2d
Watt2d
MadlandNix2d
weighted_function2d
weightedFunctionals2d
NBodyPhaseSpace2d
XYs3d
regions3d
gridded3d
angularTwoBody
KalbachMann
uncorrelated
unspecified
reference3d
multiGroup3d
energyAngular
energyAngularMC
angularEnergy
angularEnergyMC
LLNL_angularEnergy
coherentPhotonScattering
incoherentPhotonScattering
incoherentBoundToFreePhotonScattering
thermalNeutronScatteringLaw
branching3d
coherentElastic
incoherentElastic
incoherentInelastic
CoulombPlusNuclearElastic3d
LLNLLegendre
crossSectionSum
multiplicitySum
summands
ACE_URR_probabilityTable
ACE_URR_incidentEnergy
table
columnHeaders
column
GRIN_inelasticIncidentEnergy
GRIN_captureLevelProbability

Definition at line 118 of file GIDI.hpp.

                    { generic, lazyParsingHelperForm, group, groups, transportable, flux, fluxes, externalFile, style,
                reaction, product, delayedNeutron, fissionFragmentData, rate,
                physicalQuantity, axisDomain, axis, grid, axes,
                flattenedArrayData, array3d, array,
                    // 1d functions.
                constant1d, XYs1d, Ys1d, polynomial1d, Legendre1d, gridded1d, reference1d, xs_pdf_cdf1d, regions1d, 
                resonancesWithBackground1d, resonanceBackground1d, resonanceBackgroundRegion1d, URR_probabilityTables1d,
                fissionEnergyRelease1d, branching1d, branching1dPids, thermalNeutronScatteringLaw1d, unspecified1d,
                    // 2d functions.
                XYs2d, recoil2d, isotropic2d, discreteGamma2d, primaryGamma2d, regions2d, gridded2d,
                generalEvaporation2d, simpleMaxwellianFission2d, evaporation2d, Watt2d, MadlandNix2d, 
                weighted_function2d, weightedFunctionals2d, NBodyPhaseSpace2d,
                    // 3d functions.
                XYs3d, regions3d, gridded3d,
                    // distributions.
                angularTwoBody, KalbachMann, uncorrelated, unspecified, reference3d, multiGroup3d, 
                energyAngular, energyAngularMC, angularEnergy, angularEnergyMC, LLNL_angularEnergy,
                coherentPhotonScattering, incoherentPhotonScattering, incoherentBoundToFreePhotonScattering, thermalNeutronScatteringLaw, branching3d,
                coherentElastic, incoherentElastic, incoherentInelastic, CoulombPlusNuclearElastic3d, LLNLLegendre,
                    // Sums stuff.
                crossSectionSum, multiplicitySum, summands,
                    // ACE style URR stuff currently in the applicationData node.
                ACE_URR_probabilityTable, ACE_URR_incidentEnergy,
                    // Table stuff.
                table, columnHeaders, column,
                    // Non-GNDS compliant GRIN forms.
                GRIN_inelasticIncidentEnergy, GRIN_captureLevelProbability };

◆ Frame

enum class GIDI::Frame

strong

Enumerator
lab
centerOfMass

Definition at line 146 of file GIDI.hpp.

146{ lab, centerOfMass };

GIDI::Frame::centerOfMass

@ centerOfMass

Definition GIDI.hpp:146

GIDI::Frame::lab

@ lab

Definition GIDI.hpp:146

◆ GNDS_FileType

enum class GIDI::GNDS_FileType

strong

Enumerator
uninitialized
unknown
pops
protare
covarianceSuite
map

Definition at line 89 of file GIDI.hpp.

89{ uninitialized, unknown, pops, protare, covarianceSuite, map };

GIDI::GNDS_FileType::protare

@ protare

Definition GIDI.hpp:89

GIDI::GNDS_FileType::map

@ map

Definition GIDI.hpp:89

GIDI::GNDS_FileType::uninitialized

@ uninitialized

Definition GIDI.hpp:89

GIDI::GNDS_FileType::unknown

@ unknown

Definition GIDI.hpp:89

GIDI::GNDS_FileType::pops

@ pops

Definition GIDI.hpp:89

GIDI::GNDS_FileType::covarianceSuite

@ covarianceSuite

Definition GIDI.hpp:89

◆ ProtareType

enum class GIDI::ProtareType

strong

Enumerator
single
composite
TNSL

Definition at line 116 of file GIDI.hpp.

116{ single, composite, TNSL };

GIDI::ProtareType::TNSL

@ TNSL

Definition GIDI.hpp:116

GIDI::ProtareType::single

@ single

Definition GIDI.hpp:116

GIDI::ProtareType::composite

@ composite

Definition GIDI.hpp:116

◆ TransportCorrectionType

enum class GIDI::TransportCorrectionType

strong

Enumerator
None
Pendlebury
LLNL
Ferguson

Definition at line 147 of file GIDI.hpp.

147{ None, Pendlebury, LLNL, Ferguson };

GIDI::TransportCorrectionType::Pendlebury

@ Pendlebury

Definition GIDI.hpp:147

GIDI::TransportCorrectionType::None

@ None

Definition GIDI.hpp:147

GIDI::TransportCorrectionType::LLNL

@ LLNL

Definition GIDI.hpp:147

GIDI::TransportCorrectionType::Ferguson

@ Ferguson

Definition GIDI.hpp:147

Function Documentation

◆ binarySearchVector()

long GIDI::binarySearchVector	(	double	a_x,
		std::vector< double > const &	a_Xs )

This function searchs the list of ascending values a_Xs for the two values that bound a_x using a bi-section search. If a_x is less than the first value, -2 is returned. If a_x is greater than the last value, -1 is returned. Otherwise, the returned index will be such that a_Xs[index] <= a_x < a_Xs[index+1].

Parameters

a_x	[in] The value to search.
a_Xs	[in] The list of ascending values to

Returns: [in] The index within the a_Xs list that bounds a_x.

Definition at line 33 of file GIDI_misc.cc.

                                                                     {
/*
*   Returns -2 is a_x < first point of a_Xs, -1 if > last point of a_Xs, and the lower index of a_Xs otherwise.
*/
    std::size_t size = a_Xs.size( );
    std::size_t imin = 0, imid, imax = size - 1;
 
    if( a_x < a_Xs[0] ) return( -2 );
    if( a_x > a_Xs[size-1] ) return( -1 );
    while( 1 ) {
        imid = ( imin + imax ) >> 1;
        if( imid == imin ) break;
        if( a_x < a_Xs[imid] ) {
            imax = imid; }
        else {
            imin = imid;
        }
    }
    return( static_cast<long>( imin ) );
}

Referenced by GIDI::Functions::Regions1d::evaluate(), GIDI::Functions::Regions2d::evaluate(), GIDI::Functions::XYs2d::evaluate(), and GIDI::Functions::XYs3d::evaluate().

◆ calculate1dMultiGroupDataInComponent() [1/2]

void GIDI::calculate1dMultiGroupDataInComponent	(	LUPI_maybeUnused ProtareSingle const *	a_protare,
		std::string const &	a_heatedMultiGroupLabel,
		MultiGroupCalulationInformation const &	a_multiGroupCalulationInformation,
		Component &	a_component,
		Functions::XYs1d const &	a_weight )

This function finds a component's data that can be multi-grouped (generally a Functions::XYs1d instance, multi-groups it with the boundaries and flux data in a_multiGroupCalulationInformation with weight a_crossSection and adds/replaces with style label a_heatedMultiGroupLabel.

Parameters

a_heatedMultiGroupLabel	[in] The label of the style for the multi-group data being added.
a_multiGroupCalulationInformation	[in] Store multi-group boundary and flux data used for multi-grouping.
a_component	[in] The Component whose data will be multi-grouped.
a_weight	[in] An additional function to weight the data with. This is generally a reactions cross section.

Definition at line 364 of file GIDI_collapse.cc.

                                                                                                                                                   {
 
    Functions::XYs1d const *xys1d = static_cast<Functions::XYs1d const *>( a_component.findInstanceOfTypeInLineage( a_heatedMultiGroupLabel, GIDI_XYs1dChars ) );
    Functions::XYs1d const *xys1d2{ nullptr };
 
    if( xys1d == nullptr ) {
        Functions::Constant1d const *constand1d = 
                static_cast<Functions::Constant1d const *>( a_component.findInstanceOfTypeInLineage( a_heatedMultiGroupLabel, GIDI_constant1dChars ) );
        if( constand1d != nullptr ) {
            xys1d2 = GIDI::Functions::XYs1d::makeConstantXYs1d( GIDI::Axes( ), constand1d->domainMin( ), constand1d->domainMax( ), constand1d->value( ) ); }
        else {
            Functions::Regions1d const *regions1d = 
                    static_cast<Functions::Regions1d const *>( a_component.findInstanceOfTypeInLineage( a_heatedMultiGroupLabel, GIDI_regions1dChars ) );
            if( regions1d != nullptr ) {
                xys1d2 = regions1d->asXYs1d( true, 1e-4, 1e-6, 1e-6 ); }
            else {
                Functions::Branching1d const *branching1d = 
                        static_cast<Functions::Branching1d const *>( a_component.findInstanceOfTypeInLineage( a_heatedMultiGroupLabel, GIDI_branching1dChars ) );
                if( branching1d != nullptr ) {
                    xys1d2 = Functions::XYs1d::makeConstantXYs1d( GIDI::Axes( ), a_weight.domainMin( ), a_weight.domainMax( ), branching1d->multiplicity( ) ); }
                else {
                    Functions::Polynomial1d const *polynomial1d =
                            static_cast<Functions::Polynomial1d const *>( a_component.findInstanceOfTypeInLineage( a_heatedMultiGroupLabel, GIDI_polynomial1dChars ) );
                    if( polynomial1d != nullptr ) {
                        xys1d2 = polynomial1d->asXYs1d( true, 1e-4, 1e-6, 1e-6 ); }
                    else {
                        throw Exception( "calculate1dMultiGroupDataInComponent: from findInstanceOfTypeInLineage, no XYs1d, Constant1d, Regions1d, Branching1d or Polynomial1d form found in "
                                + a_component.toXLink( ) + "." );
                    }
                }
            }
        }
        xys1d = xys1d2;
    }
 
    Vector *vector = multiGroupTwoXYs1ds( a_multiGroupCalulationInformation, *xys1d, a_weight );
    Functions::Gridded1d *gridded1d = a_component.get<Functions::Gridded1d>( a_heatedMultiGroupLabel );
    gridded1d->setData( *vector );
    delete vector;
    delete xys1d2;
}

◆ calculate1dMultiGroupDataInComponent() [2/2]

void GIDI::calculate1dMultiGroupDataInComponent	(	ProtareSingle const *	a_protare,
		std::string const &	a_heatedMultiGroupLabel,
		MultiGroupCalulationInformation const &	a_multiGroupCalulationInformation,
		Component &	a_component,
		Functions::XYs1d const &	a_crossSection )

Referenced by GIDI::OutputChannel::calculateMultiGroupData(), GIDI::Product::calculateMultiGroupData(), and GIDI::Reaction::calculateMultiGroupData().

◆ calculate1dMultiGroupFissionEnergyRelease()

void GIDI::calculate1dMultiGroupFissionEnergyRelease	(	MultiGroupCalulationInformation const &	a_multiGroupCalulationInformation,
		Functions::XYs1d const &	a_weight,
		Functions::Function1dForm const *	a_evaluated,
		Functions::Function1dForm *	a_gridded1d )

This function

Parameters

a_multiGroupCalulationInformation	[in] Store multi-group boundary and flux data used for multi-grouping.
a_weight	[in] An additional function to weight the data with. This is generally a reactions cross section.
a_evaluated	[in] This is the evaluated form of the fission energy released.
a_gridded1d	[in] This is the current multi-grouped form whose data will be replace.

Definition at line 416 of file GIDI_collapse.cc.

                                                                                                   {
 
    if( a_gridded1d == nullptr ) return;
 
    Functions::XYs1d const *xys1d = nullptr;
    Functions::Gridded1d *gridded1d = static_cast<Functions::Gridded1d *>( a_gridded1d );
 
    if( a_evaluated->moniker( ) == GIDI_XYs1dChars ) {
        xys1d = static_cast<Functions::XYs1d const *>( a_evaluated ); }
    else if( a_evaluated->moniker( ) == GIDI_polynomial1dChars ) {
        Functions::Polynomial1d const *polynomial1d = static_cast<Functions::Polynomial1d const *>( a_evaluated );
        xys1d = polynomial1d->asXYs1d( true, 1e-4, 1e-6, 1e-6 ); }
    else {
        throw Exception( "calculate1dMultiGroupFissionEnergyRelease: form not XYs1d or Polynomial1d: " + a_evaluated->toXLink( ) + "." );
    }
 
    Vector *vector = multiGroupTwoXYs1ds( a_multiGroupCalulationInformation, *xys1d, a_weight );
    gridded1d->setData( *vector );
    delete vector;
 
    if( a_evaluated != xys1d ) delete xys1d;
}

Referenced by GIDI::FissionFragmentData::calculateMultiGroupData().

◆ checkOuterDomainValues1d()

void GIDI::checkOuterDomainValues1d	(	std::vector< Functions::Function1dForm * > &	a_functions,
		std::vector< double > &	a_Xs )

Function that checks that the outerDomainValue values of the elements of a_functions are increasing and fills a_Xs with the outerDomainValue values.

Parameters

a_functions	[in] List of functions to check.
a_Xs	[in] A list of doubles that is filled with the outerDomainValues from the list of functions in a_functions.

Definition at line 923 of file GIDI_parseSuites.cc.

                                                                                                            {
 
    for( auto iter = a_functions.begin( ); iter != a_functions.end( ); ++iter ) {
        if( a_Xs.size( ) > 0 ) {
            if( (*iter)->outerDomainValue( ) <= a_Xs.back( ) ) throw Exception( "checkOuterDomainValues1d: next outerDomainValue <= current outerDomainValue." );
        }
        a_Xs.push_back( (*iter)->outerDomainValue( ) );
    }
}

◆ checkOuterDomainValues2d()

void GIDI::checkOuterDomainValues2d	(	std::vector< Functions::Function2dForm * > &	a_functions,
		std::vector< double > &	a_Xs )

Function that checks that the outerDomainValue values of the elements of a_functions are increasing and fills a_Xs with the outerDomainValue values.

Parameters

a_functions	[in] List of functions to check.
a_Xs	[in] A list of doubles that is filled with the outerDomainValues from the list of functions in a_functions.

Definition at line 940 of file GIDI_parseSuites.cc.

                                                                                                            {
 
    for( auto iter = a_functions.begin( ); iter != a_functions.end( ); ++iter ) {
        if( a_Xs.size( ) > 0 ) {
            if( (*iter)->outerDomainValue( ) <= a_Xs.back( ) ) throw Exception( "checkOuterDomainValues2d: next outerDomainValue <= current outerDomainValue." );
        }
        a_Xs.push_back( (*iter)->outerDomainValue( ) );
    }
}

◆ checkSequentialDomainLimits1d()

void GIDI::checkSequentialDomainLimits1d	(	std::vector< Functions::Function1dForm * > &	a_functions,
		std::vector< double > &	a_Xs )

Function that checks that the domain overlap of the elements of a_functions are . The domain minimum values from each function and the domain maximum value are filled into a_Xs.

Parameters

a_functions	[in] The list of functions whose domain limits are checked.
a_Xs	[in] A std::vector<double> that is with the domain minimum values from each function and the domain maximum value.

Definition at line 958 of file GIDI_parseSuites.cc.

                                                                                                                 {
 
    double domainMax = -1;
 
    for( auto iter = a_functions.begin( ); iter != a_functions.end( ); ++iter ) {
        double domainMin = (*iter)->domainMin( );
 
        if( a_Xs.size( ) > 0 ) {
            if( fabs( domainMax - domainMin ) > 1e-8 * ( fabs( domainMin ) + fabs( domainMax ) ) ) 
                    throw Exception( "checkSequentialDomainLimits1d: domains not abutting." );
        }
        a_Xs.push_back( domainMin );
        domainMax = (*iter)->domainMax( );
    }
    if( a_Xs.size( ) > 0 ) a_Xs.push_back( domainMax );
}

◆ checkSequentialDomainLimits2d()

void GIDI::checkSequentialDomainLimits2d	(	std::vector< Functions::Function2dForm * > &	a_functions,
		std::vector< double > &	a_Xs )

Function that checks that the domain overlap of the elements of a_functions are . The domain minimum values from each function and the domain maximum value are filled into a_Xs.

Parameters

a_functions	[in] The list of functions whose domain limits are checked.
a_Xs	[in] A std::vector<double> that is with the domain minimum values from each function and the domain maximum value.

Definition at line 983 of file GIDI_parseSuites.cc.

                                                                                                                 {
 
    double domainMax = -1;
 
    for( auto iter = a_functions.begin( ); iter != a_functions.end( ); ++iter ) {
        double domainMin = (*iter)->domainMin( );
 
        if( a_Xs.size( ) > 0 ) {
            if( fabs( domainMax - domainMin ) > 1e-8 * ( fabs( domainMin ) + fabs( domainMax ) ) ) 
                    throw Exception( "checkSequentialDomainLimits2d: domains not abutting." );
        }
        a_Xs.push_back( domainMin );
        domainMax = (*iter)->domainMax( );
    }
    if( a_Xs.size( ) > 0 ) a_Xs.push_back( a_functions.back( )->domainMax( ) );
}

◆ collapse() [1/2]

Matrix GIDI::collapse	(	Matrix const &	a_matrix,
		Transporting::Settings const &	a_settings,
		Transporting::Particles const &	a_particles,
		double	a_temperature,
		std::string const &	a_productID )

Collapses a multi-group matrix.

Parameters

a_matrix	[in] The Matrix to collapse.
a_settings	[in] Specifies the uncollapsed and collapsed multi-group information and the flux.
a_particles	[in] The list of particles to be transported.
a_temperature	[in] The temperature of the flux to use when collapsing.
a_productID	[in] Particle id of the outgoing particle.

Returns: Returns the collapsed Matrix.

Definition at line 87 of file GIDI_collapse.cc.

                                                                                                                                                                                {
 
    if( a_matrix.size( ) == 0 ) return( a_settings.multiGroupZeroMatrix( a_particles, a_productID, true ) );
 
    Transporting::Particle const *projectile( a_particles.particle( a_settings.projectileID( ) ) );
    Transporting::ProcessedFlux const *flux( projectile->nearestProcessedFluxToTemperature( a_temperature ) );
    std::vector<double> const &multiGroupFlux( flux->multiGroupFlux( ) );
    std::vector<std::size_t> const &projectileCollapseIndices( projectile->collapseIndices( ) );
 
    Transporting::Particle const *product( a_particles.particle( a_productID ) );
    std::size_t n2 = product->numberOfGroups( );
 
    std::vector<std::size_t> productCollapseIndices( product->collapseIndices( ) );
    productCollapseIndices[0] = 0;
    productCollapseIndices[n2] = a_matrix[0].size( );
 
    std::vector<double> conservationWeight( a_matrix[0].size( ), 1. );
    if( product->conserve() == Transporting::Conserve::energyOut ) {
        std::vector<double> boundaries = product->fineMultiGroup().boundaries();
        for( std::size_t i1 = 0; i1 < boundaries.size() - 1; ++i1 ) {
            conservationWeight[i1] = 0.5 * (boundaries[i1] + boundaries[i1+1]);
        }
    }
 
    Matrix productCollapsed( 0, 0 );
    for( std::size_t i1 = 0; i1 < a_matrix.size( ); ++i1 ) {
        productCollapsed.push_back( collapseVector( a_matrix[i1], productCollapseIndices, conservationWeight, false ) );
    }
 
    Matrix productCollapsedTranspose = productCollapsed.transpose( );
    Matrix collapsedTranspose( 0, 0 );
    for( std::size_t i2 = 0; i2 < n2; ++i2 ) {
        collapsedTranspose.push_back( collapseVector( productCollapsedTranspose[i2], projectileCollapseIndices, multiGroupFlux, true ) );
    }
 
    if( product->conserve() == Transporting::Conserve::energyOut ) {
        double denominator = 1;
        std::vector<double> boundaries = product->multiGroup().boundaries();
        for( std::size_t i1 = 0; i1 < boundaries.size() - 1; ++i1 ) {
            denominator = 0.5 * (boundaries[i1] + boundaries[i1+1]);
            collapsedTranspose[i1] /= denominator;
        }
    }
 
    return( collapsedTranspose.transpose( ) );
}

◆ collapse() [2/2]

Vector GIDI::collapse	(	Vector const &	a_vector,
		Transporting::Settings const &	a_settings,
		Transporting::Particles const &	a_particles,
		double	a_temperature )

Collapses a multi-group vector.

Parameters

a_vector	[in] The Vector to collapse.
a_settings	[in] Specifies the uncollapsed and collapsed multi-group information and the flux.
a_particles	[in] The list of particles to be transported.
a_temperature	[in] The temperature of the flux to use when collapsing.

Returns: Returns the collapsed Vector.

Definition at line 30 of file GIDI_collapse.cc.

                                                                                                                                                  {
 
    Transporting::Particle const *projectile( a_particles.particle( a_settings.projectileID( ) ) );
    Transporting::ProcessedFlux const *flux( projectile->nearestProcessedFluxToTemperature( a_temperature ) );
    std::vector<double> const &multiGroupFlux( flux->multiGroupFlux( ) );
    std::vector<std::size_t> const &collapseIndices( projectile->collapseIndices( ) );
 
    return( collapseVector( a_vector, collapseIndices, multiGroupFlux, true ) );
}

Referenced by GIDI::ProtareSingle::multiGroupTransportCorrection(), and GIDI::ProtareTNSL::multiGroupTransportCorrection().

◆ data1dListParse()

void GIDI::data1dListParse	(	Construction::Settings const &	a_construction,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		std::vector< Functions::Function1dForm * > &	a_function1ds )

Function that parses the list of 1d function nodes contained in a_node.

Parameters

a_construction	[in] Used to pass user options to the constructor.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_function1ds	[in] The object to fill with the list of parsed 1d functions.

Definition at line 808 of file GIDI_parseSuites.cc.

                                                                      {
 
    for( HAPI::Node child = a_node.first_child( ); !child.empty( ); child.to_next_sibling( ) ) {
        Functions::Function1dForm *form = data1dParse( a_construction, child, a_setupInfo, nullptr );
 
        if( form == nullptr ) throw Exception( "data1dListParse data1dParse returned nullptr." );
        a_function1ds.push_back( form );
    }
}

◆ data1dParse()

Functions::Function1dForm * GIDI::data1dParse	(	Construction::Settings const &	a_construction,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		Suite *	a_parent )

Function that parses a node one-d function node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.

Returns: The parsed and constructed GIDI::Function1d instance.

Definition at line 747 of file GIDI_parseSuites.cc.

                                                                                                                                                    {
 
    Functions::Function1dForm *form = nullptr;
    std::string name( a_node.name( ) );
 
    if( name == GIDI_constant1dChars ) {
        form = new Functions::Constant1d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_XYs1dChars ) {
        form = new Functions::XYs1d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_Ys1dChars ) {
        form = new Functions::Ys1d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_polynomial1dChars ) {
        form = new Functions::Polynomial1d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_LegendreChars ) {
        form = new Functions::Legendre1d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_regions1dChars ) {
        form = new Functions::Regions1d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_gridded1dChars ) {
        form = new Functions::Gridded1d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_referenceChars ) {
        form = new Functions::Reference1d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_xs_pdf_cdf1dChars ) {
        form = new Functions::Xs_pdf_cdf1d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_unspecifiedChars ) {
        form = new Functions::Unspecified1d( a_construction, a_node, a_setupInfo, a_parent ); }
    else {
        std::cout << "data1dParse: Ignoring unsupported 1d function = '" << name << "'" << std::endl;
    }
 
    return( form );
}

Referenced by data1dListParse(), data1dParseAllowEmpty(), GIDI::DoubleDifferentialCrossSection::n_ThermalNeutronScatteringLaw::DebyeWallerIntegral::DebyeWallerIntegral(), GIDI::Functions::Evaporation2d::Evaporation2d(), GIDI::Functions::FissionEnergyRelease::FissionEnergyRelease(), GIDI::Functions::GeneralEvaporation2d::GeneralEvaporation2d(), GIDI::Functions::MadlandNix2d::MadlandNix2d(), parseAvailableSuite(), parseAverageEnergySuite(), parseAverageMomentumSuite(), parseCrossSectionSuite(), parseMultiplicitySuite(), parseQSuite(), GIDI::Functions::ResonanceBackgroundRegion1d::ResonanceBackgroundRegion1d(), GIDI::Functions::SimpleMaxwellianFission2d::SimpleMaxwellianFission2d(), GIDI::Functions::Watt2d::Watt2d(), and GIDI::Functions::Weighted_function2d::Weighted_function2d().

◆ data1dParseAllowEmpty()

Functions::Function1dForm * GIDI::data1dParseAllowEmpty	(	Construction::Settings const &	a_construction,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		Suite *	a_parent )

Function that parses a node one-d function node. Called from a Suite::parse instance. If no node exists, returns nullptr.

Parameters

a_construction	[in] Used to pass user options to the constructor.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.

Returns: The parsed and constructed GIDI::Function1d instance.

Definition at line 790 of file GIDI_parseSuites.cc.

                          {
 
    std::string name( a_node.name( ) );
 
    if( name == "" ) return( nullptr );
    return( data1dParse( a_construction, a_node, a_setupInfo, a_parent ) );
}

Referenced by GIDI::DoubleDifferentialCrossSection::n_ThermalNeutronScatteringLaw::T_effective::T_effective().

◆ data2dListParse()

void GIDI::data2dListParse	(	Construction::Settings const &	a_construction,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		std::vector< Functions::Function2dForm * > &	a_function2ds )

Function that parses the list of 2d function nodes contained in a_node.

Parameters

a_construction	[in] Used to pass user options to the constructor.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_function2ds	[in] The object to fill with the list of parsed 2d functions.

Definition at line 878 of file GIDI_parseSuites.cc.

                                                              {
 
    for( HAPI::Node child = a_node.first_child( ); !child.empty( ); child.to_next_sibling( ) ) {
        Functions::Function2dForm *form = data2dParse( a_construction, child, a_setupInfo, nullptr );
 
        if( form == nullptr ) throw Exception( "data2dListParse data2dParse returned nullptr." );
        a_function2ds.push_back( form );
    }
}

◆ data2dParse()

Functions::Function2dForm * GIDI::data2dParse	(	Construction::Settings const &	a_construction,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		Suite *	a_parent )

Function that parses a node two-d function node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options to the constructor.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.

Returns: The parsed and constructed GIDI::Function2d instance.

Definition at line 829 of file GIDI_parseSuites.cc.

                                                                                                                                                    {
 
    Functions::Function2dForm *form = nullptr;
    std::string name( a_node.name( ) );
 
    if( name == GIDI_XYs2dChars ) {
        form = new Functions::XYs2d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_recoilChars ) {
        form = new Functions::Recoil2d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_isotropic2dChars ) {
        form = new Functions::Isotropic2d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_discreteGammaChars ) {
        form = new Functions::DiscreteGamma2d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_primaryGammaChars ) {
        form = new Functions::PrimaryGamma2d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_generalEvaporationChars ) {
        form = new Functions::GeneralEvaporation2d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_simpleMaxwellianFissionChars ) {
        form = new Functions::SimpleMaxwellianFission2d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_evaporationChars ) {
        form = new Functions::Evaporation2d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_WattChars ) {
        form = new Functions::Watt2d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_MadlandNixChars ) {
        form = new Functions::MadlandNix2d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_weightedFunctionalsChars ) {
        form = new Functions::WeightedFunctionals2d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_NBodyPhaseSpaceChars ) {
        form = new Functions::NBodyPhaseSpace2d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_regions2dChars ) {
        form = new Functions::Regions2d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_gridded2dChars ) {
        form = new Functions::Gridded2d( a_construction, a_node, a_setupInfo, a_parent ); }
    else {
        std::cout << "data2dParse: Ignoring unsupported 2d function = '" << name << "'" << std::endl;
    }
 
    return( form );
}

Referenced by GIDI::Distributions::AngularEnergyMC::AngularEnergyMC(), GIDI::Distributions::AngularTwoBody::AngularTwoBody(), data2dListParse(), GIDI::Distributions::EnergyAngularMC::EnergyAngularMC(), GIDI::Flux::Flux(), GIDI::Distributions::KalbachMann::KalbachMann(), GIDI::Distributions::LLNLAngularEnergy::LLNLAngularEnergy(), GIDI::DoubleDifferentialCrossSection::n_ThermalNeutronScatteringLaw::S_table::S_table(), GIDI::Distributions::Uncorrelated::Uncorrelated(), GIDI::Functions::URR_probabilityTables1d::URR_probabilityTables1d(), and GIDI::Functions::Weighted_function2d::Weighted_function2d().

◆ data3dParse()

Functions::Function3dForm * GIDI::data3dParse	(	Construction::Settings const &	a_construction,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		Suite *	a_parent )

Function that parses a node three-d function node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options to the constructor.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.

Returns: The parsed and constructed GIDI::Function3d instance.

Definition at line 900 of file GIDI_parseSuites.cc.

                                                                                                                                                    {
 
    Functions::Function3dForm *form = nullptr;
    std::string name( a_node.name( ) );
 
    if( name == GIDI_XYs3dChars ) {
        form = new Functions::XYs3d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( name == GIDI_gridded3dChars ) {
        form = new Functions::Gridded3d( a_construction, a_node, a_setupInfo ); }
    else {
        std::cout << "data3dParse: Ignoring unsupported 3d function = '" << name << "'" << std::endl;
    }
    
    return( form );
}

Referenced by GIDI::Fluxes::addFile(), GIDI::Distributions::AngularEnergy::AngularEnergy(), GIDI::Distributions::AngularEnergyMC::AngularEnergyMC(), GIDI::Distributions::EnergyAngular::EnergyAngular(), GIDI::Distributions::EnergyAngularMC::EnergyAngularMC(), and GIDI::Distributions::LLNLAngularEnergy::LLNLAngularEnergy().

◆ doublesToXMLList()

void GIDI::doublesToXMLList	(	GUPI::WriteInfo &	a_writeInfo,
		std::string const &	a_indent,
		std::vector< double > const &	a_values,
		std::size_t	a_start,
		bool	a_newLine,
		std::string const &	a_valueType )

Adds the list of doubles to the list of XML lines in a_writeInfo.

Parameters

a_writeInfo	[in/out] Instance containing incremental indentation, values per line and other information and stores the appended lines.
a_indent	[in] The amount to indent this node.
a_values	[in] The list of doubles to convert to strings and add to a_writeInfo.
a_start	[in] The value for the start attribute.
a_newLine	[in] If false, the first a_writeInfo.m_valuesPerLine values are added to the last line with no indentation; otherwise, they are put on a new line with indentation.
a_valueType	[in] The value for the valueType attribute.

Definition at line 180 of file GIDI_misc.cc.

                                                                                                                                                                                   {
 
    int valuesPerLine( a_writeInfo.m_valuesPerLine );
    std::string indent( a_indent );
    std::string attributes;
    std::string indent2 = a_writeInfo.incrementalIndent( a_indent );
    std::string XMLLine;
    std::string sep = "";
 
    if( !a_newLine ) indent = "";
    if( a_valueType != "" ) attributes += a_writeInfo.addAttribute( GIDI_valueTypeChars, a_valueType );
    if( a_start != 0 ) attributes += a_writeInfo.addAttribute( GIDI_startChars, size_t_ToString( a_start ) );
    XMLLine = a_writeInfo.nodeStarter( indent, GIDI_valuesChars, attributes );
 
    if( valuesPerLine < 1 ) valuesPerLine = 1;
    int numberOfValuesInLine = 0;
    for( std::size_t i1 = 0; i1 < a_values.size( ); ++i1 ) {
        XMLLine += sep + LUPI::Misc::doubleToShortestString( a_values[i1] );
        sep = a_writeInfo.m_sep;
        ++numberOfValuesInLine;
 
        if( numberOfValuesInLine == valuesPerLine ) {
            if( a_newLine ) {
                a_writeInfo.push_back( XMLLine ); }
            else {
                a_writeInfo.m_lines.back( ) += XMLLine;
            }
            numberOfValuesInLine = 0;
            XMLLine.clear( );
            XMLLine = indent2;
            a_newLine = true;
            sep = "";
        }
    }
    if( numberOfValuesInLine > 0 ) {
        if( a_newLine ) {
            a_writeInfo.push_back( XMLLine ); }
        else {
            a_writeInfo.m_lines.back( ) += XMLLine;
        } }
    else if( a_values.size( ) == 0 ) {
        a_writeInfo.push_back( XMLLine );
    }
 
    a_writeInfo.addNodeEnder( GIDI_valuesChars );
}

Referenced by GIDI::FlattenedArrayData::toXMLList(), GIDI::Grid::toXMLList(), GIDI::Functions::Gridded1d::toXMLList_func(), GIDI::Functions::Legendre1d::toXMLList_func(), GIDI::Functions::Polynomial1d::toXMLList_func(), GIDI::Functions::XYs1d::toXMLList_func(), and GIDI::Functions::Ys1d::toXMLList_func().

◆ ENDL_CFromENDF_MT()

int GIDI::ENDL_CFromENDF_MT	(	int	ENDF_MT,
		int *	ENDL_C,
		int *	ENDL_S )

Calculates the ENDL C and S values for a ENDF MT value.

Parameters

ENDF_MT	[in] The ENDF MT value.
ENDL_C	[out] The ENDL C value for the ENDF MT value.
ENDL_S	[out] The ENDL S value for the ENDF MT value.

Returns: Returns 0 if the ENDF MT value is valid and 1 otherwise.

Definition at line 923 of file GIDI_reaction.cc.

                                                               {
 
    int MT1_50ToC[] = { 1,   10,  -3,   11,   -5,    0,    0,    0,    0,  -10,
                       32,    0,   0,    0,    0,   12,   13,   15,   15,   15,
                       15,   26,  36,   33,  -25,    0,  -27,   20,   27,  -30,
                        0,   22,  24,   25,  -35,  -36,   14,   15,    0,    0,
                       29,   16,   0,   17,   34,    0,    0,    0,    0 };
    int MT100_200ToC[] = { -101,   46,   40,   41,   42,   44,   45,   37, -109,    0,
                             18,   48, -113, -114,   19,   39,   47,    0,    0,    0,
                              0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
                              0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
                              0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
                              0, -152, -153, -154,   43, -156, -157,   23,   31, -160,
                           -161, -162, -163, -164, -165, -166, -167, -168, -169, -170,
                           -171, -172, -173, -174, -175, -176, -177, -178, -179, -180,
                           -181, -182, -183, -184, -185, -186, -187, -188,   28, -190,
                           -191, -192,   38, -194, -195, -196, -197, -198, -199, -200 };
    *ENDL_C = 0;
    *ENDL_S = 0;
    if( ENDF_MT <= 0 ) {
        *ENDL_C = -ENDF_MT;
        return( 1 );
    }
    if( ENDF_MT > 1572 ) return( 1 );
    if( ENDF_MT < 50 ) {
        *ENDL_C = MT1_50ToC[ENDF_MT - 1]; }
    else if( ENDF_MT <= 91 ) {
        *ENDL_C = 11;
        if( ENDF_MT != 91 ) *ENDL_S = 1; }
    else if( ( ENDF_MT > 100 ) && ( ENDF_MT <= 200 ) ) {
        *ENDL_C = MT100_200ToC[ENDF_MT - 101]; }
    else if( ( ENDF_MT == 452 ) || ( ENDF_MT == 455 ) || ( ENDF_MT == 456 ) || ( ENDF_MT == 458 ) ) {
        *ENDL_C = 15;
        if( ENDF_MT == 455 ) *ENDL_S = 7; }
    else if( ( ENDF_MT >= 502 ) && ( ENDF_MT <= 572 ) ) {
        if( ENDF_MT == 502 ) {
            *ENDL_C = 71; }
        else if( ENDF_MT == 504 ) {
            *ENDL_C = 72; }
        else if( ( ENDF_MT >= 515 ) && ( ENDF_MT <= 517 ) ) {
            *ENDL_C = 74; }
        else if( ENDF_MT == 522 ) {
            *ENDL_C = 73; }
        else if( ( ENDF_MT >= 534 ) && ( ENDF_MT <= 572 ) ) {
            *ENDL_C = 73; } }
    else if( ENDF_MT >= 600 ) {
        if( ENDF_MT < 650 ) {
            *ENDL_C = 40;
            if( ENDF_MT != 649 ) *ENDL_S = 1; }
        else if( ENDF_MT < 700 ) {
            *ENDL_C = 41;
            if( ENDF_MT != 699 ) *ENDL_S = 1; }
        else if( ENDF_MT < 750 ) {
            *ENDL_C = 42;
            if( ENDF_MT != 749 ) *ENDL_S = 1; }
        else if( ENDF_MT < 800 ) {
            *ENDL_C = 44;
            if( ENDF_MT != 799 ) *ENDL_S = 1; }
        else if( ENDF_MT < 850 ) {
            *ENDL_C = 45;
            if( ENDF_MT != 849 ) *ENDL_S = 1; }
        else if( ( ENDF_MT >= 875 ) && ( ENDF_MT <= 891 ) ) {
            *ENDL_C = 12;
            if( ENDF_MT != 891 ) *ENDL_S = 1; }
        else if( ( ENDF_MT >= 1534 ) && (ENDF_MT <= 1572 ) ) {
            *ENDL_C = 72;
        }
    }
 
    return( 0 );
}

Referenced by GIDI::Reaction::Reaction(), and GIDI::Reaction::Reaction().

◆ energy2dToXMLList()

void GIDI::energy2dToXMLList	(	GUPI::WriteInfo &	a_writeInfo,
		std::string const &	a_moniker,
		std::string const &	a_indent,
		Functions::Function1dForm *	a_function )

Fills the argument a_writeInfo with the XML lines that represent this. Recursively enters each sub-node.

Parameters

a_writeInfo	[in/out] Instance containing incremental indentation and other information and stores the appended lines.
a_moniker	[in] The moniker for the energy type.
a_indent	[in] The amount to indent this node.
a_function	[in] The energy function whose information is converted to XML.

Definition at line 442 of file GIDI_misc.cc.

                                                                                                                                                 {
 
    std::string indent2 = a_writeInfo.incrementalIndent( a_indent );
 
    if( a_function == nullptr ) return;
 
    a_writeInfo.addNodeStarter( a_indent, a_moniker, "" );
    a_function->toXMLList( a_writeInfo, indent2 );
    a_writeInfo.addNodeEnder( a_moniker );
}

Referenced by GIDI::Functions::Evaporation2d::toXMLList_func(), GIDI::Functions::GeneralEvaporation2d::toXMLList_func(), GIDI::Functions::MadlandNix2d::toXMLList_func(), GIDI::Functions::SimpleMaxwellianFission2d::toXMLList_func(), and GIDI::Functions::Watt2d::toXMLList_func().

◆ excludeReactionsSetAdjust()

void GIDI::excludeReactionsSetAdjust	(	ExcludeReactionsSet &	a_excludeReactionsSet,
		Protare const &	a_protare )

Returns a new ExcludeReactionsSet with

Parameters

a_protare [in] The Protare instance used to determine the number of reactions to adjust the new indices by.

Returns: returns the startIndex attribute of a_node.

Definition at line 461 of file GIDI_misc.cc.

                                                                                                       {
 
    ExcludeReactionsSet excludeReactionsSet;
 
    for( auto iter = a_excludeReactionsSet.begin( ); iter != a_excludeReactionsSet.end( ); ++iter ) {
        if( (*iter) >= a_protare.numberOfReactions( ) ) {
            excludeReactionsSet.insert( (*iter) - a_protare.numberOfReactions( ) );
        }
    }
 
    a_excludeReactionsSet = std::move( excludeReactionsSet );
}

◆ frameToString()

std::string GIDI::frameToString ( Frame a_frame )

This function returns a std::string representation of a frame.

Parameters

a_frame [in] The frame to convert to a string.

Returns: A std::string instance.

Definition at line 375 of file GIDI_misc.cc.

                                         {
 
    if( a_frame == Frame::lab ) return( GIDI_labChars );
    return( GIDI_centerOfMassChars );
}

Referenced by GIDI::ProtareSingle::toXMLList(), and GIDI::Distributions::Distribution::toXMLNodeStarter().

◆ GNDS_fileType()

GNDS_FileType GIDI::GNDS_fileType	(	std::string const &	a_fileName,
		GNDS_FileTypeInfo &	a_GNDS_fileTypeInfo )

Opens the specified file and parses the first line to determine its GNDS type (i.e., protare (reactionSuite), map or PoPs file). Returns the GNDS type via the GNDS_FileType enum. If the return value and the value of a_GNDS_fileTypeInfo.GNDS_fileType( ) is uninitialized an error was detected opening the file or by the XML parser (expat). If it is unknown the parsed file is an XML file but not a valid GNDS file.

Parameters

a_fileName	[in] The path to the file whose GNDS type is to be determined.
a_GNDS_fileTypeInfo	[in] The GNDS_FileTypeInfo instance containing the return information.

Returns: enum indicating the GNDS type of file referened by a_fileName.

Definition at line 130 of file GIDI_GNDS_fileType.cc.

                                                                                                   {
 
    a_GNDS_fileTypeInfo.setGNDS_fileType( GNDS_FileType::uninitialized );
 
    char buffer[10 * 1024 + 1];
    size_t bufferSize = sizeof( buffer ) - 1;
    FILE *fileDescriptor;
 
#ifdef GIDI_PLUS_NOEXPAT
    throw Exception( "\nGIDI::fileType failed as expat not included." );
#endif
 
    fileDescriptor = fopen( a_fileName.c_str( ), "r" );
    if( fileDescriptor == nullptr ) throw Exception( "GIDI::fileType failed to open file '" + a_fileName + "'." );
 
    XML_Parser xmlParser = XML_ParserCreate( nullptr );
    if( xmlParser == nullptr ) {
        fclose( fileDescriptor );
        throw Exception( "XML_ParserCreate failed." );
    }
 
    XML_SetElementHandler( xmlParser, xml_startElementHandler, xml_endElementHandler );
 
    GNDS_FileTypeInfoUserData userData( xmlParser, a_GNDS_fileTypeInfo );
    XML_SetUserData( xmlParser, &userData );
 
    enum XML_Status status = XML_STATUS_ERROR;  // Initialize to silence compiler warning
    size_t count = 0;
    while( ( count = fread( buffer, bufferSize, 1, fileDescriptor ) ) > 0 ) {
        status = XML_Parse( xmlParser, buffer, (int) count, 0 );
        if( status != XML_STATUS_OK ) break;
    }
 
//    enum XML_Error error = XML_GetErrorCode( xmlParser );
    XML_ParserFree( xmlParser );
    fclose( fileDescriptor );
 
    if( status == XML_STATUS_ERROR ) throw Exception( "GIDI::fileType expat parsing error." );
//      What about other status values like XML_STATUS_SUSPENDED.
    return( a_GNDS_fileTypeInfo.GNDS_fileType( ) );
}

◆ gridded1d2GIDI_Ys1d()

Functions::Ys1d GIDI::gridded1d2GIDI_Ys1d ( Functions::Function1dForm const & a_function1d )

This function converts the y-values from the Gridded1d into a Ys1d instance.

Parameters

a_function1d [in] The Gridded1d whoses y-values are converted into a Ys1d instance.

Returns: A Ys1d instance of the y-values.

Definition at line 252 of file GIDI_misc.cc.

                                                                                 {
 
    std::vector<double> ys;
    Functions::Ys1d ys1d( a_function1d.axes( ), ptwXY_interpolationFlat, 0, ys );
 
    switch( a_function1d.type( ) ) {
    case FormType::gridded1d :
        {
            Functions::Gridded1d const &gridded1d = static_cast<Functions::Gridded1d const &>( a_function1d );
            Vector const &data = gridded1d.data( );
            std::size_t start = 0;
 
            for( ; start < data.size( ); ++start ) {
                if( data[start] != 0 ) break;
            }
            ys1d.setStart( start );
 
            for( std::size_t i1 = start; i1 < data.size( ); ++i1 ) ys1d.push_back( data[i1] );
        }
        break;
    default :
        throw Exception( "gridded1d2GIDI_Ys1d: unsupported 1d function type " + a_function1d.label( ) );
    }
 
    return( ys1d );
}

◆ intsToXMLList()

void GIDI::intsToXMLList	(	GUPI::WriteInfo &	a_writeInfo,
		std::string const &	a_indent,
		std::vector< int > const &	a_values,
		std::string const &	a_attributes )

Adds the list of integers to the list of XML lines in a_writeInfo.

Parameters

a_writeInfo	[in/out] Instance containing incremental indentation, values per line and other information and stores the appended lines.
a_indent	[in] The amount to indent this node.
a_values	[in] The list of integers to convert to strings and add to a_writeInfo.
a_attributes	[in] String representation of the attributes for the GNDS values node.

Definition at line 63 of file GIDI_misc.cc.

                                                                                                                                           {
 
    a_writeInfo.addNodeStarter( a_indent, GIDI_valuesChars, a_attributes );
 
    std::string intString;
    std::string sep( "" );
 
    for( std::size_t i1 = 0; i1 < a_values.size( ); ++i1 ) {
        intString += sep + intToString( a_values[i1] );
        if( i1 == 0 ) sep = a_writeInfo.m_sep;
    }
 
    a_writeInfo.m_lines.back( ) += intString;
    a_writeInfo.addNodeEnder( GIDI_valuesChars );
}

Referenced by GIDI::FlattenedArrayData::toXMLList().

◆ intToString()

std::string GIDI::intToString ( int a_value )

Returns a string representation of int a_value.

Parameters

a_value [in] The int value to convert to a string.

Returns: A std::string instance.

Definition at line 415 of file GIDI_misc.cc.

                                     {
 
    return( LUPI::Misc::argumentsToString( "%d", a_value ) );
}

◆ LLNL_fidToLabel()

std::string GIDI::LLNL_fidToLabel ( int a_fid )

This function converts an integer fid value (i.e., flux id) into the LLNL legacy bdfls label.

Parameters

a_fid [in] The integer fid used to construct the LLNL legacy bdfls label.

Returns: The LLNL legacy bdfls label.

Definition at line 324 of file GIDI_misc.cc.

                                       {
 
    return( LUPI::Misc::argumentsToString( "LLNL_fid_%d", a_fid ) );
}

Referenced by GIDI::Transporting::Fluxes_from_bdfls::getViaFID().

◆ LLNL_gidToLabel()

std::string GIDI::LLNL_gidToLabel ( int a_gid )

This function converts an integer gid value (i.e., group id) into the LLNL legacy bdfls label.

Parameters

a_gid [in] The integer gid used to construct the LLNL legacy bdfls label.

Returns: The LLNL legacy bdfls label.

Definition at line 311 of file GIDI_misc.cc.

                                       {
 
    return( LUPI::Misc::argumentsToString( "LLNL_gid_%d", a_gid ) );
}

Referenced by GIDI::Transporting::Groups_from_bdfls::getViaGID().

◆ multiGroupTwoXYs1ds()

Vector * GIDI::multiGroupTwoXYs1ds	(	MultiGroupCalulationInformation const &	a_multiGroupCalulationInformation,
		Functions::XYs1d const &	a_function1,
		Functions::XYs1d const &	a_function2 )

This function returns a flux weighted multi-group version of the product of a_function1 times * a_function2. The caller owns the returned instance and is respondible for deleting it (i.e., freeing its memory when no longer needed).

Parameters

a_multiGroupCalulationInformation	[in] Store multi-group boundary and flux data used for multi-grouping.
a_function1	[in] First function of the product.
a_function2	[in] Second function of the product, generally a reaction's cross section.

Returns: Returns the multi-grouped Vector.

Definition at line 267 of file GIDI_collapse.cc.

                                                    {
 
    ptwXPoints *boundaries_xs = const_cast<ptwXPoints *>( a_multiGroupCalulationInformation.m_boundaries_xs );
    ptwXPoints *multiGroupFlux = const_cast<ptwXPoints * >( a_multiGroupCalulationInformation.m_multiGroupFlux );
    ptwXYPoints *ptwXY1 = nullptr, *ptwXY2 = nullptr, *fluxes_xys = nullptr;
    ptwXPoints *groups = nullptr;
    std::string errorMessage( "GIDI::multiGroupTwoXYs1ds: ptwXY_clone2 for a_function1 failed." );
    statusMessageReporting *smr = nullptr;
 
    ptwXY1 = ptwXY_clone2( smr, a_function1.ptwXY( ) );
    if( ptwXY1 != nullptr ) {
        ptwXY2 = ptwXY_clone2( smr, a_function2.ptwXY( ) );
        if( ptwXY2 == nullptr ) {
            errorMessage = "GIDI::multiGroupTwoXYs1ds: ptwXY_clone2 for a_function2 failed."; }
        else {
            double min1, min2, max1, max2;
 
            ptwXY_domainMin( smr, ptwXY1, &min1 );
            ptwXY_domainMax( smr, ptwXY1, &max1 );
            ptwXY_domainMin( smr, ptwXY2, &min2 );
            ptwXY_domainMax( smr, ptwXY2, &max2 );
            fluxes_xys = ptwXY_domainSlice( smr, const_cast<ptwXYPoints *>( a_multiGroupCalulationInformation.m_fluxes_xys ), 
                    std::max( min1, min2 ), std::min( max1, max2), 10, 1 );
 
            if( fluxes_xys == nullptr ) {
                errorMessage = "GIDI::multiGroupTwoXYs1ds: ptwXY_domainSlice for flux failed."; }
            else {
                ptwXY_mutualifyDomains( smr, ptwXY1,     1e-12, 1e-12, 1, ptwXY2,     1e-12, 1e-12, 1 );
                ptwXY_mutualifyDomains( smr, ptwXY1,     1e-12, 1e-12, 1, fluxes_xys, 1e-12, 1e-12, 1 );
                ptwXY_mutualifyDomains( smr, fluxes_xys, 1e-12, 1e-12, 1, ptwXY2,     1e-12, 1e-12, 1 );
                groups = ptwXY_groupThreeFunctions( smr, ptwXY1, ptwXY2, fluxes_xys, boundaries_xs, ptwXY_group_normType_norm, multiGroupFlux );
            }
        }
    }
    ptwXY_free( ptwXY1 );
    ptwXY_free( ptwXY2 );
    ptwXY_free( fluxes_xys );
 
    if( groups == nullptr ) {
        throw Exception( errorMessage );
    }
 
    Vector *vector = new Vector( static_cast<std::size_t>( ptwX_length( smr, groups ) ), ptwX_getPointAtIndex( smr, groups, 0 ) );
    ptwX_free( groups );
 
    return( vector );
}

Referenced by calculate1dMultiGroupDataInComponent(), and calculate1dMultiGroupFissionEnergyRelease().

◆ multiGroupXYs1d()

Vector GIDI::multiGroupXYs1d	(	Transporting::MultiGroup const &	a_boundaries,
		Functions::XYs1d const &	a_function,
		Transporting::Flux const &	a_flux )

Returns a flux weighted multi-group version of the function a_function.

Parameters

a_boundaries	[in] List of multi-group boundaries.
a_function	[in] Function to multi-group.
a_flux	[in] Flux to use for weighting.

Returns: Returns the multi-grouped Vector of a_function.

Definition at line 214 of file GIDI_collapse.cc.

                                                                                                                                       {
 
    std::vector<double> const &boundaries = a_boundaries.boundaries( );
    int64_t boundariesSize = static_cast<int64_t>( boundaries.size( ) );
    ptwXPoints *boundaries_xs = ptwX_create( nullptr, boundariesSize, boundariesSize, &(boundaries[0]) );
    if( boundaries_xs == nullptr ) throw Exception( "GIDI::multiGroup: ptwX_create failed." );
 
    Transporting::Flux_order const &flux_order_0 = a_flux[0];
    double const *energies = flux_order_0.energies( );
    double const *fluxes = flux_order_0.fluxes( );
    ptwXYPoints *fluxes_xys = ptwXY_createFrom_Xs_Ys( nullptr, ptwXY_interpolationLinLin, ptwXY_interpolationToString( ptwXY_interpolationLinLin ), 
        12, 1e-3, static_cast<int64_t>( flux_order_0.size( ) ), 10, static_cast<int64_t>( flux_order_0.size( ) ), energies, fluxes, 0 );
    if( fluxes_xys == nullptr ) {
        ptwX_free( boundaries_xs );
        throw Exception( "GIDI::multiGroup: ptwXY_createFrom_Xs_Ys failed." );
    }
 
    ptwXPoints *multiGroupFlux = ptwXY_groupOneFunction( nullptr, fluxes_xys, boundaries_xs, ptwXY_group_normType_none, nullptr );
    if( multiGroupFlux == nullptr ) {
        ptwX_free( boundaries_xs );
        ptwXY_free( fluxes_xys );
        throw Exception( "GIDI::multiGroup: ptwXY_groupOneFunction failed." );
    }
 
    ptwXYPoints *ptwXY = ptwXY_clone2( nullptr, a_function.ptwXY( ) );
    ptwXPoints *groups = nullptr;
    if( ptwXY != nullptr ) {
        ptwXY_mutualifyDomains( nullptr, ptwXY, 1e-12, 1e-12, 1, fluxes_xys, 1e-12, 1e-12, 1 );
        groups = ptwXY_groupTwoFunctions( nullptr, ptwXY, fluxes_xys, boundaries_xs, ptwXY_group_normType_norm, multiGroupFlux );
    }
    ptwX_free( boundaries_xs );
    ptwXY_free( fluxes_xys );
    ptwX_free( multiGroupFlux );
    ptwXY_free( ptwXY );
    if( groups == nullptr ) throw Exception( "GIDI::multiGroup: ptwXY_groupTwoFunctions failed." );
 
    Vector vector( static_cast<std::size_t>( ptwX_length( nullptr, groups ) ), ptwX_getPointAtIndex( nullptr, groups, 0 ) );
    ptwX_free( groups );
 
    return( vector );
}

◆ nodeWithValuesToDoubles()

std::string GIDI::nodeWithValuesToDoubles	(	GUPI::WriteInfo &	a_writeInfo,
		std::string const &	a_nodeName,
		std::vector< double > const &	a_values )

Create the XML list for xs, pdf or cdf for an Xs_pdf_cdf1d instance.

Parameters

a_writeInfo	[in/out] Instance containing incremental indentation and other information and stores the appended lines.
a_nodeName	[in] The name of the node (e.g., "xs" );
a_values	[in] The list of doubles to wrap.

Returns: A std::string instance.

Definition at line 391 of file GIDI_misc.cc.

                                                                                                                                {
 
    std::string xml = a_writeInfo.nodeStarter( "", a_nodeName );
    std::string sep( "" );
 
    xml += a_writeInfo.nodeStarter( "", GIDI_valuesChars );
    for( std::size_t i1 = 0; i1 < a_values.size( ); ++i1 ) {
        xml += sep + LUPI::Misc::doubleToShortestString( a_values[i1] );
        if( i1 == 0 ) sep = " ";
    }
    xml += a_writeInfo.nodeEnder( GIDI_valuesChars );
    xml += a_writeInfo.nodeEnder( a_nodeName );
 
    return( xml );
}

Referenced by GIDI::Functions::Xs_pdf_cdf1d::toXMLList_func().

◆ operator<<()

std::ostream & GIDI::operator<<	(	std::ostream &	a_os,
		PhysicalQuantity const &	a_physicalQuantity )

Writes the information of a_physicalQuantity to a_os.

Parameters

a_os	[out] The stream to write to.
a_physicalQuantity	[in] The PhysicalQuantity whose information is written.

Definition at line 93 of file GIDI_physicalQuantity.cc.

                                                                                       {
 
    a_os << a_physicalQuantity.value( ) << " " << a_physicalQuantity.unit( );
 
    return( a_os );
}

◆ parseACE_URR_probabilityTables() [1/2]

Form * GIDI::parseACE_URR_probabilityTables	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		LUPI_maybeUnused PoPI::Database const &	a_pops,
		LUPI_maybeUnused PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

This function parses a probabilityTable child node of a probabilityTables node.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Function1d instance.

Definition at line 701 of file GIDI_parseSuites.cc.

                                                                                                                                                                                          {
 
    if( a_name != GIDI_ACE_URR_probabilityTableChars ) throw Exception( std::string( "Invalid " ) + GIDI_ACE_URR_probabilityTablesChars " child node of moniker " + a_name );
 
    return( new ACE_URR::ProbabilityTable( a_construction, a_node, a_setupInfo, a_parent ) );
}

◆ parseACE_URR_probabilityTables() [2/2]

Form * GIDI::parseACE_URR_probabilityTables	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

◆ parseAvailableSuite() [1/2]

Form * GIDI::parseAvailableSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		LUPI_maybeUnused PoPI::Database const &	a_pops,
		LUPI_maybeUnused PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a node under an <availableEnergy> or <availableMomentum> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Function1d instance.

Definition at line 474 of file GIDI_parseSuites.cc.

                                                                                                                                                                                  {
 
    if( a_construction.parseMode( ) == Construction::ParseMode::outline ) return( nullptr );
    if( ( a_construction.parseMode( ) == Construction::ParseMode::multiGroupOnly ) && ( a_name != GIDI_gridded1dChars ) ) return( nullptr );
 
    return( data1dParse( a_construction, a_node, a_setupInfo, a_parent ) );
}

◆ parseAvailableSuite() [2/2]

Form * GIDI::parseAvailableSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::Reaction::Reaction().

◆ parseAverageEnergySuite() [1/2]

Form * GIDI::parseAverageEnergySuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		LUPI_maybeUnused PoPI::Database const &	a_pops,
		LUPI_maybeUnused PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a node under an <averageEnergy> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Function1d instance.

Definition at line 651 of file GIDI_parseSuites.cc.

                                                                                                                                                                                  {
 
    if( a_construction.parseMode( ) == Construction::ParseMode::outline ) return( nullptr );
    if( ( a_construction.parseMode( ) == Construction::ParseMode::multiGroupOnly ) && ( a_name != GIDI_gridded1dChars ) ) return( nullptr );
 
    return( data1dParse( a_construction, a_node, a_setupInfo, a_parent ) );
}

◆ parseAverageEnergySuite() [2/2]

Form * GIDI::parseAverageEnergySuite	(	Construction::Settings const &	a_construction,
		Suite *	parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pop,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::Product::Product().

◆ parseAverageMomentumSuite() [1/2]

Form * GIDI::parseAverageMomentumSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		LUPI_maybeUnused PoPI::Database const &	a_pops,
		LUPI_maybeUnused PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a node under an <averageMomentum> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Function1d instance.

Definition at line 676 of file GIDI_parseSuites.cc.

                                                                                                                                                                                          {
 
    if( a_construction.parseMode( ) == Construction::ParseMode::outline ) return( nullptr );
    if( ( a_construction.parseMode( ) == Construction::ParseMode::multiGroupOnly ) && ( a_name != GIDI_gridded1dChars ) ) return( nullptr );
 
    return( data1dParse( a_construction, a_node, a_setupInfo, a_parent ) );
}

◆ parseAverageMomentumSuite() [2/2]

Form * GIDI::parseAverageMomentumSuite	(	Construction::Settings const &	a_construction,
		Suite *	parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pop,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::Product::Product().

◆ parseColumnHeaders() [1/2]

Form * GIDI::parseColumnHeaders	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		LUPI_maybeUnused PoPI::Database const &	a_pops,
		LUPI_maybeUnused PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

This function parses a column child node of a columnHeaders node.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Function1d instance.

Definition at line 725 of file GIDI_parseSuites.cc.

                                                                                                                                                                                          {
 
    if( a_name != GIDI_columnChars ) throw Exception( std::string( "Invalid " ) + GIDI_columnHeadersChars + " child node of moniker " + a_name );
 
    Table::Column *column = new Table::Column( a_construction, a_node, a_setupInfo, a_parent );
    column->setKeyName( GIDI_indexChars );
 
    return column;
}

◆ parseColumnHeaders() [2/2]

Form * GIDI::parseColumnHeaders	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::Table::Table::Table().

◆ parseCrossSectionSuite() [1/2]

Form * GIDI::parseCrossSectionSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		LUPI_maybeUnused PoPI::Database const &	a_pops,
		LUPI_maybeUnused PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a node under the <crossSection> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Form or nullptr if the node is not supported.

Definition at line 369 of file GIDI_parseSuites.cc.

                                                                                                                                                                                  {
 
    if( a_construction.parseMode( ) == Construction::ParseMode::outline ) return( nullptr );
    if( ( a_construction.parseMode( ) == Construction::ParseMode::multiGroupOnly ) && ( a_name != GIDI_gridded1dChars ) ) return( nullptr );
    if( ( a_construction.parseMode( ) == Construction::ParseMode::MonteCarloContinuousEnergy ) && ( a_name != GIDI_Ys1dChars ) ) return( nullptr );
 
// Form not parsed is CoulombPlusNuclearElastic.
    Form *form = nullptr;
 
    if( a_name == GIDI_resonancesWithBackgroundChars ) {
        return( new Functions::ResonancesWithBackground1d( a_construction, a_node, a_setupInfo, a_parent ) ); }
    else if( a_name == GIDI_TNSL1dChars ) {
        form = new Functions::ThermalNeutronScatteringLaw1d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_URR_probabilityTables1dChars ) {
        form = new Functions::URR_probabilityTables1d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_CoulombPlusNuclearElasticChars ) {
        }
    else {
        form = data1dParse( a_construction, a_node, a_setupInfo, a_parent );
    }
 
    return( form );
}

◆ parseCrossSectionSuite() [2/2]

Form * GIDI::parseCrossSectionSuite	(	Construction::Settings const &	a_construction,
		Suite *	parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pop,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::Sums::CrossSectionSum::CrossSectionSum(), and GIDI::Reaction::Reaction().

◆ parseDelayedNeutronsSuite()

Form * GIDI::parseDelayedNeutronsSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Function that parses a node under the <DelayedNeutrons> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Form or nullptr if the node is not supported.

Definition at line 409 of file GIDI_parseSuites.cc.

                                                                                                                               {
 
    if( a_name != GIDI_delayedNeutronChars ) throw Exception( std::string( "Invalid " ) + GIDI_delayedNeutronsChars + " child node of moniker " + a_name );
    return( new DelayedNeutron( a_construction, a_node, a_setupInfo, a_pops, a_internalPoPs, a_parent, a_styles ) );
}

Referenced by GIDI::FissionFragmentData::FissionFragmentData().

◆ parseDistributionSuite() [1/2]

Form * GIDI::parseDistributionSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		LUPI_maybeUnused PoPI::Database const &	a_pops,
		LUPI_maybeUnused PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a node under a <distribution> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Form or nullptr if the node is not supported.

Definition at line 579 of file GIDI_parseSuites.cc.

                                                                                                                                                                                  {
 
    if( a_construction.parseMode( ) == Construction::ParseMode::outline ) return( nullptr );
    if( a_name == GIDI_multiGroup3dChars ) {
        if( ( a_construction.parseMode( ) == Construction::ParseMode::MonteCarloContinuousEnergy ) || 
            ( a_construction.parseMode( ) == Construction::ParseMode::excludeProductMatrices ) ) return( nullptr ); }
    else {
        if( a_construction.parseMode( ) == Construction::ParseMode::multiGroupOnly ) return( nullptr );
    }
 
//  Distributions not parsed are GIDI_LLNLLegendreChars.
    Form *form = nullptr;
 
    if( a_name == GIDI_multiGroup3dChars ) {
        form = new Distributions::MultiGroup3d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_angularTwoBodyChars ) {
        form = new Distributions::AngularTwoBody( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_uncorrelatedChars ) {
        form = new Distributions::Uncorrelated( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_KalbachMannChars ) {
        form = new Distributions::KalbachMann( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_energyAngularChars ) {
        form = new Distributions::EnergyAngular( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_energyAngularMCChars ) {
        form = new Distributions::EnergyAngularMC( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_angularEnergyChars ) {
        form = new Distributions::AngularEnergy( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_angularEnergyMCChars ) {
        form = new Distributions::AngularEnergyMC( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_LLNLAngularEnergyChars ) {
        form = new Distributions::LLNLAngularEnergy( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_coherentPhotonScatteringChars ) {
        form = new Distributions::CoherentPhotoAtomicScattering( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_incoherentPhotonScatteringChars ) {
        form = new Distributions::IncoherentPhotoAtomicScattering( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_incoherentBoundToFreePhotonScatteringChars ) {
        form = new Distributions::IncoherentBoundToFreePhotoAtomicScattering( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_thermalNeutronScatteringLawChars ) {
        form = new Distributions::ThermalNeutronScatteringLaw( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_branching3dChars ) {
        form = new Distributions::Branching3d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_referenceChars ) {
        form = new Distributions::Reference3d( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_unspecifiedChars ) {
        form = new Distributions::Unspecified( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_CoulombPlusNuclearElasticChars ) {
        form = new Distributions::CoulombPlusNuclearElastic( a_construction, a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_LLNLLegendreChars ) {
        form = new Distributions::LLNLLegendre( a_construction, a_node, a_setupInfo, a_parent ); }
    else {
        std::cout << "parseDistributionSuite: Ignoring unsupported distribution " << a_node.name( ) << std::endl;
    }
 
    return( form );
}

◆ parseDistributionSuite() [2/2]

Form * GIDI::parseDistributionSuite	(	Construction::Settings const &	a_construction,
		Suite *	parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pop,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::Product::Product().

◆ parseDoubleDifferentialCrossSectionSuite() [1/2]

Form * GIDI::parseDoubleDifferentialCrossSectionSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a node under the <doubleDifferentialCrossSection> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Form or nullptr if the node is not supported.

Definition at line 303 of file GIDI_parseSuites.cc.

                                                       {
 
    if( a_construction.parseMode( ) == Construction::ParseMode::outline ) return( nullptr );
    if( a_construction.parseMode( ) == Construction::ParseMode::multiGroupOnly ) return( nullptr );
 
    Form *form = nullptr;
 
    if( a_name == GIDI_coherentPhotonScatteringChars ) {
        form = new DoubleDifferentialCrossSection::CoherentPhotoAtomicScattering( a_construction, a_node, a_setupInfo, a_pops, a_internalPoPs, a_parent ); }
    else if( a_name == GIDI_incoherentPhotonScatteringChars ) {
        form = new DoubleDifferentialCrossSection::IncoherentPhotoAtomicScattering( a_construction, a_node, a_setupInfo, a_pops, a_internalPoPs, a_parent ); }
    else if( a_name == GIDI_incoherentBoundToFreePhotonScatteringChars ) {
        form = new DoubleDifferentialCrossSection::IncoherentBoundToFreePhotoAtomicScattering( a_construction, a_node, a_setupInfo, a_pops, a_internalPoPs, a_parent ); }
    else if( a_name == GIDI_TNSL_coherentElasticChars ) {
        form = new DoubleDifferentialCrossSection::n_ThermalNeutronScatteringLaw::CoherentElastic( a_construction, a_node, a_setupInfo, a_pops, a_internalPoPs, a_parent ); }
    else if( a_name == GIDI_TNSL_incoherentElasticChars ) {
        form = new DoubleDifferentialCrossSection::n_ThermalNeutronScatteringLaw::IncoherentElastic( a_construction, a_node, a_setupInfo, a_pops, a_internalPoPs, a_parent ); }
    else if( a_name == GIDI_TNSL_incoherentInelasticChars ) {
        form = new DoubleDifferentialCrossSection::n_ThermalNeutronScatteringLaw::IncoherentInelastic( a_construction, a_node, a_setupInfo, a_pops, a_internalPoPs, a_parent ); }
    else if( a_name == GIDI_CoulombPlusNuclearElasticChars ) { 
        }
    else {
        std::cout << "parseDoubleDifferentialCrossSectionSuite: Ignoring unsupported Form '" << a_name << "'." << std::endl;
    }
 
    return( form );
}

◆ parseDoubleDifferentialCrossSectionSuite() [2/2]

Form * GIDI::parseDoubleDifferentialCrossSectionSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::Reaction::Reaction().

◆ parseExternalFilesSuite() [1/2]

Form * GIDI::parseExternalFilesSuite	(	Construction::Settings const &	a_construction,
		Suite *	parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pop,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

◆ parseExternalFilesSuite() [2/2]

Form * GIDI::parseExternalFilesSuite	(	LUPI_maybeUnused Construction::Settings const &	a_construction,
		GIDI::Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		LUPI_maybeUnused PoPI::Database const &	a_pops,
		LUPI_maybeUnused PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a <style> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Form or nullptr if the node is not supported.

Definition at line 32 of file GIDI_parseSuites.cc.

                                                                                                                                                                                  {
 
    Form *form = nullptr;
 
    if( a_name == GIDI_externalFileChars ) {
        form = new ExternalFile( a_node, a_setupInfo, a_parent ); }
    else {
        std::cout << "parseExternalFilesSuite: Ignoring unsupported externalFile = '" << a_name << "'." << std::endl;
    }
 
    return( form );
}

◆ parseFissionComponent()

Form * GIDI::parseFissionComponent	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Function that parses an <orphanProduct> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Reaction instance.

Definition at line 190 of file GIDI_parseSuites.cc.

                                                                                                                               {
 
    return( parseReactionType( GIDI_fissionComponentChars, a_construction, a_parent, a_node, a_setupInfo, a_pops, a_internalPoPs, a_name, a_styles ) );
}

◆ parseFissionEnergyReleasesSuite() [1/2]

Form * GIDI::parseFissionEnergyReleasesSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		LUPI_maybeUnused PoPI::Database const &	a_pops,
		LUPI_maybeUnused PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a node under the <FissionEnergyReleases> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Form or nullptr if the node is not supported.

Definition at line 431 of file GIDI_parseSuites.cc.

                                                                                                                                                                                  {
 
    if( a_name != GIDI_fissionEnergyReleaseChars ) throw Exception( std::string( "Invalid " ) + GIDI_fissionEnergyReleasesChars " child node of moniker " + a_name );
    return( new Functions::FissionEnergyRelease( a_construction, a_node, a_setupInfo, a_parent ) );
}

◆ parseFissionEnergyReleasesSuite() [2/2]

Form * GIDI::parseFissionEnergyReleasesSuite	(	Construction::Settings const &	a_construction,
		Suite *	parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pop,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::FissionFragmentData::FissionFragmentData().

◆ parseFlattened1d()

int GIDI::parseFlattened1d	(	Construction::Settings const &	a_construction,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		Vector &	a_data )

Function to parse a one-d flattened array.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_data	[out] An empty GIDI::Vector that is filled with the data.

Returns: 0 if successfull and 1 otherwise.

Definition at line 209 of file GIDI_arrays.cc.

                                                                                                                                   {
 
    FlattenedArrayData arrayData( a_node, a_setupInfo, 1, a_construction.useSystem_strtod( ) );
 
    std::size_t size = (std::size_t) arrayData.m_shape[0];
    a_data.resize( size );
 
    std::size_t n1 = 0, n2 = size;
    for( std::size_t i1 = 0; i1 < arrayData.m_numberOfStarts; ++i1 ) {
        std::size_t offset = (std::size_t) arrayData.m_starts[i1];
        for( int32_t i2 = 0; i2 < arrayData.m_lengths[i1]; ++i2, ++n1, ++offset ) {
            if( n1 >= arrayData.m_dValues.size( ) ) throw Exception( "Too many values in flattened array." );
            if( offset >= n2 ) throw Exception( "requested size is too small." );
            a_data[offset] = arrayData.m_dValues[n1];
        }
    }
    return( 0 );
}

Referenced by GIDI::Functions::Gridded1d::Gridded1d().

◆ parseFrame() [1/2]

Frame GIDI::parseFrame	(	HAPI::Node const &	a_node,
		LUPI_maybeUnused SetupInfo &	a_setupInfo,
		std::string const &	a_name )

This function returns an frame enum representing a HAPI::Node's attribute with name a_name.

Parameters

a_node	[in] The HAPI::Node node whoses attribute named a_node is to be parsed to determine the frame.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_name	[in] The name of the attribute to parse.

Returns: The frame enum representing the node's frame.

Definition at line 237 of file GIDI_misc.cc.

                                                                                                             {
 
    Frame frame = Frame::lab;
    if( strcmp( a_node.attribute_as_string( a_name.c_str( ) ).c_str( ), GIDI_centerOfMassChars ) == 0 ) frame = Frame::centerOfMass;
    return( frame );
}

◆ parseFrame() [2/2]

Frame GIDI::parseFrame	(	HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		std::string const &	a_name )

Referenced by GIDI::Distributions::Distribution::Distribution().

◆ parseMultiplicitySuite() [1/2]

Form * GIDI::parseMultiplicitySuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		LUPI_maybeUnused PoPI::Database const &	a_pops,
		LUPI_maybeUnused PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a node under a <multiplicity> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Function1d instance.

Definition at line 554 of file GIDI_parseSuites.cc.

                                                                                                                                                                                  {
 
    if( a_construction.parseMode( ) == Construction::ParseMode::outline ) return( nullptr );
 
    if( a_name == GIDI_branching1dChars ) return( new Functions::Branching1d( a_construction, a_node, a_setupInfo, a_parent ) );
 
    return( data1dParse( a_construction, a_node, a_setupInfo, a_parent ) );
}

◆ parseMultiplicitySuite() [2/2]

Form * GIDI::parseMultiplicitySuite	(	Construction::Settings const &	a_construction,
		Suite *	parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pop,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::Sums::MultiplicitySum::MultiplicitySum(), and GIDI::Product::Product().

◆ parseOrphanProduct()

Form * GIDI::parseOrphanProduct	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Function that parses an <orphanProduct> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Reaction instance.

Definition at line 169 of file GIDI_parseSuites.cc.

                                                                                                                               {
 
    return( parseReactionType( GIDI_orphanProductChars, a_construction, a_parent, a_node, a_setupInfo, a_pops, a_internalPoPs, a_name, a_styles ) );
}

◆ parsePhysicalQuantitySuite() [1/2]

Form * GIDI::parsePhysicalQuantitySuite	(	Construction::Settings const &	a_construction,
		Suite *	parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pop,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::DelayedNeutron::DelayedNeutron().

◆ parsePhysicalQuantitySuite() [2/2]

Form * GIDI::parsePhysicalQuantitySuite	(	LUPI_maybeUnused Construction::Settings const &	a_construction,
		LUPI_maybeUnused Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		LUPI_maybeUnused PoPI::Database const &	a_pops,
		LUPI_maybeUnused PoPI::Database const &	a_internalPoPs,
		LUPI_maybeUnused std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a node under the <rate> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Form or nullptr if the node is not supported.

Definition at line 453 of file GIDI_parseSuites.cc.

                                                                                                                                                                                                   {
 
    return( new PhysicalQuantity( a_node, a_setupInfo ) );
}

◆ parseProductSuite()

Form * GIDI::parseProductSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Function that parses a node under a <products> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Product instance.

Definition at line 525 of file GIDI_parseSuites.cc.

                                                                                                                               {
 
    Form *form = nullptr;
 
    if( a_name == GIDI_productChars ) {
        form = new Product( a_construction, a_node, a_setupInfo, a_pops, a_internalPoPs, a_parent, a_styles ); }
    else {
        std::cout << "parseProductSuite: Ignoring unsupported element in products " << a_node.name( ) << std::endl;
    }
 
    return( form );
}

◆ parseQSuite() [1/2]

Form * GIDI::parseQSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		LUPI_maybeUnused PoPI::Database const &	a_pops,
		LUPI_maybeUnused PoPI::Database const &	a_internalPoPs,
		LUPI_maybeUnused std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a node under a <Q> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Function1d instance.

Definition at line 498 of file GIDI_parseSuites.cc.

                                                                                                                                                                                                   {
 
    Form *form = nullptr;
 
    if( a_construction.parseMode( ) == Construction::ParseMode::outline ) return( nullptr );
 
    form = data1dParse( a_construction, a_node, a_setupInfo, a_parent );
 
    return( form );
}

◆ parseQSuite() [2/2]

Form * GIDI::parseQSuite	(	Construction::Settings const &	a_construction,
		Suite *	parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pop,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::Sums::CrossSectionSum::CrossSectionSum().

◆ parseReaction()

Form * GIDI::parseReaction	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Function that parses a <reaction> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Reaction instance.

Definition at line 148 of file GIDI_parseSuites.cc.

                                                                                                                               {
 
    return( parseReactionType( GIDI_reactionChars, a_construction, a_parent, a_node, a_setupInfo, a_pops, a_internalPoPs, a_name, a_styles ) );
}

◆ parseReactionType()

Form * GIDI::parseReactionType	(	std::string const &	a_moniker,
		Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Function that parses a <reaction> or an <orphanProduct> node. Called from a Suite::parse instance.

Parameters

a_moniker	[in] The moniker for the form to parse.
a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Reaction instance.

Definition at line 212 of file GIDI_parseSuites.cc.

                                      {
 
    Form *form = nullptr;
 
    if( a_name == a_moniker ) {
        Protare const &protare( *static_cast<Protare const *>( a_parent->root( ) ) );
        form = new Reaction( a_construction, a_node, a_setupInfo, a_pops, a_internalPoPs, protare, a_styles ); }
    else {                                  // This should never happend.
        std::cout << "parseReactionType: Ignoring '" << a_moniker << "' unsupported form '" << a_name << "'." << std::endl;
    }
 
    return( form );
}

Referenced by parseFissionComponent(), parseOrphanProduct(), and parseReaction().

◆ parseScatteringAtom() [1/2]

Form * GIDI::parseScatteringAtom	(	Construction::Settings const &	a_construction,
		LUPI_maybeUnused Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		LUPI_maybeUnused PoPI::Database const &	a_pops,
		LUPI_maybeUnused PoPI::Database const &	a_internalPoPs,
		LUPI_maybeUnused std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a node under the <doubleDifferentialCrossSection> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Form or nullptr if the node is not supported.

Definition at line 348 of file GIDI_parseSuites.cc.

                                                                                                                                                                                                   {
 
    return( new DoubleDifferentialCrossSection::n_ThermalNeutronScatteringLaw::ScatteringAtom( a_construction, a_node, a_setupInfo ) );
}

◆ parseScatteringAtom() [2/2]

Form * GIDI::parseScatteringAtom	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::DoubleDifferentialCrossSection::n_ThermalNeutronScatteringLaw::IncoherentInelastic::IncoherentInelastic().

◆ parseStylesSuite() [1/2]

Form * GIDI::parseStylesSuite	(	Construction::Settings const &	a_construction,
		GIDI::Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a <style> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Form or nullptr if the node is not supported.

Definition at line 61 of file GIDI_parseSuites.cc.

                                                                                                                                                {
 
    Form *form = nullptr;
 
//  Styles not parsed are angularDistributionReconstructed.
 
    if(      a_name == GIDI_evaluatedStyleChars ) {
        form = new Styles::Evaluated( a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_crossSectionReconstructedStyleChars ) {
        form = new Styles::CrossSectionReconstructed( a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_CoulombPlusNuclearElasticMuCutoffStyleChars ) {
        form = new Styles::CoulombPlusNuclearElasticMuCutoff( a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_realizationChars ) {
        form = new Styles::Realization( a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_averageProductDataStyleChars ) {
        form = new Styles::AverageProductData( a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_MonteCarlo_cdfStyleChars ) {
        form = new Styles::MonteCarlo_cdf( a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_multiGroupStyleChars ) {
        form = new Styles::MultiGroup( a_construction, a_node, a_setupInfo, a_pops, a_internalPoPs, a_parent );
        if( a_setupInfo.m_multiGroup == nullptr ) {
            a_setupInfo.m_multiGroup = static_cast<Styles::MultiGroup *>( form ); }
        else {
            std::cout << "Multiple multiGroup style instances found which is not supported. Ignoring all but first instance." << std::endl;
        } }
    else if( a_name == GIDI_heatedStyleChars ) {
        form = new Styles::Heated( a_node, a_setupInfo, a_parent ); }
    else if( a_name == GIDI_heatedMultiGroupStyleChars ) {
        form = new Styles::HeatedMultiGroup( a_construction, a_node, a_setupInfo, a_pops, a_parent ); }
    else if( a_name == GIDI_SnElasticUpScatterStyleChars ) {
        form = new Styles::SnElasticUpScatter( a_node, a_setupInfo, a_pops, a_parent ); }
    else if( a_name == GIDI_griddedCrossSectionStyleChars ) {
        form = new Styles::GriddedCrossSection( a_construction, a_node, a_setupInfo, a_pops, a_parent ); }
    else if( a_name == GIDI_URR_probabilityTablesStyleChars ) {
        form = new Styles::URR_probabilityTables( a_construction, a_node, a_setupInfo, a_pops, a_parent ); }
    else {
        std::cout << "parseStylesSuite: Ignoring unsupported style = '" << a_name << "'." << std::endl;
    }
 
    return( form );
}

◆ parseStylesSuite() [2/2]

Form * GIDI::parseStylesSuite	(	Construction::Settings const &	a_construction,
		Suite *	parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pop,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

◆ parseSumsCrossSectionsSuite() [1/2]

Form * GIDI::parseSumsCrossSectionsSuite	(	Construction::Settings const &	a_construction,
		LUPI_maybeUnused Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a <crossSectionSum> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::CrossSectionSum instance.

Definition at line 243 of file GIDI_parseSuites.cc.

                                                                                                                                                {
 
    Form *form = nullptr;
 
    if( a_name == GIDI_crossSectionSumChars ) {
        form = new Sums::CrossSectionSum( a_construction, a_node, a_setupInfo, a_pops, a_internalPoPs ); }
    else {                                  // This should never happend.
        std::cout << "parseSumsCrossSectionsSuite: Ignoring unsupported Form '" << a_name << "'." << std::endl;
    }
 
    return( form );
}

◆ parseSumsCrossSectionsSuite() [2/2]

Form * GIDI::parseSumsCrossSectionsSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::Sums::Sums::parse().

◆ parseSumsMultiplicitiesSuite() [1/2]

Form * GIDI::parseSumsMultiplicitiesSuite	(	Construction::Settings const &	a_construction,
		LUPI_maybeUnused Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a <multiplicitySum> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::MultiplicitySum instance.

Definition at line 272 of file GIDI_parseSuites.cc.

                                                                                                                                                {
 
    Form *form = nullptr;
 
    if( a_construction.parseMode( ) == Construction::ParseMode::outline ) return( nullptr );
 
    if( a_name == GIDI_multiplicitySumChars ) {
        form = new Sums::MultiplicitySum( a_construction, a_node, a_setupInfo, a_pops, a_internalPoPs ); }
    else {                                  // This should never happend.
        std::cout << "parseSumsMultiplicitiesSuite: Ignoring unsupported Form '" << a_name << "'." << std::endl;
    }
 
    return( form );
}

◆ parseSumsMultiplicitiesSuite() [2/2]

Form * GIDI::parseSumsMultiplicitiesSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::Sums::Sums::parse().

◆ parseTransportablesSuite() [1/2]

Form * GIDI::parseTransportablesSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		LUPI_maybeUnused PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		LUPI_maybeUnused Styles::Suite const *	a_styles )

Function that parses a <transportable> node. Called from a Suite::parse instance.

Parameters

a_construction	[in] Used to pass user options for parsing.
a_parent	[in] The parent GIDI::Suite that the returned Form will be added to.
a_node	[in] The HAPI::Node to be parsed.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_pops	[in] A PoPs Database instance used to get particle indices and possibly other particle information.
a_internalPoPs	[in] The internal PoPI::Database instance used to get particle indices and possibly other particle information. This is the <PoPs> node under the <reactionSuite> node.
a_name	[in] The moniker for the node to be parsed.
a_styles	[in] A pointer to the <styles> node.

Returns: The parsed and constructed GIDI::Form or nullptr if the node is not supported.

Definition at line 119 of file GIDI_parseSuites.cc.

                                                                                                                                                                 {
 
    Form *form = nullptr;
 
    if( a_name == GIDI_transportableChars ) {
        form = new Transportable( a_construction, a_node, a_setupInfo, a_pops, a_parent ); }
    else {
        std::cout << "parseTransportablesSuite: Ignoring unsupported Form '" << a_name << "'." << std::endl;
    }
 
    return( form );
}

◆ parseTransportablesSuite() [2/2]

Form * GIDI::parseTransportablesSuite	(	Construction::Settings const &	a_construction,
		Suite *	a_parent,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		PoPI::Database const &	a_pops,
		PoPI::Database const &	a_internalPoPs,
		std::string const &	a_name,
		Styles::Suite const *	a_styles )

Referenced by GIDI::Styles::HeatedMultiGroup::HeatedMultiGroup(), and GIDI::Styles::MultiGroup::MultiGroup().

◆ parseValuesOfDoubles() [1/3]

void GIDI::parseValuesOfDoubles	(	Construction::Settings const &	a_construction,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		nf_Buffer< double > &	a_values )

This function converts the text of a HAPI::Node into a list of doubles.

Parameters

a_construction	[in] Used to pass user options to the constructor.
a_node	[in] The HAPI::Node node whose text is to be converted into a list of doubles.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_values	[in] The list to fill with the converted values.

Definition at line 88 of file GIDI_misc.cc.

                                         {
 
    parseValuesOfDoubles( a_node, a_setupInfo, a_values, a_construction.useSystem_strtod( ) );
}

Referenced by GIDI::Array::Array::Array(), GIDI::FlattenedArrayData::FlattenedArrayData(), GIDI::Grid::Grid(), GIDI::Functions::Legendre1d::Legendre1d(), parseValuesOfDoubles(), GIDI::Functions::Polynomial1d::Polynomial1d(), GIDI::Functions::Xs_pdf_cdf1d::Xs_pdf_cdf1d(), GIDI::Functions::XYs1d::XYs1d(), and GIDI::Functions::Ys1d::Ys1d().

◆ parseValuesOfDoubles() [2/3]

void GIDI::parseValuesOfDoubles	(	HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		nf_Buffer< double > &	a_values,
		LUPI_maybeUnused int	a_useSystem_strtod )

This function converts the text of a HAPI::Node into a list of doubles.

Parameters

a_node	[in] The HAPI::Node node whose text is to be converted into a list of doubles.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_values	[in] The list to fill with the converted values.
a_useSystem_strtod	[in] Flag passed to the function nfu_stringToListOfDoubles.

Definition at line 103 of file GIDI_misc.cc.

                                                                                                                                                  {
 
    std::string href = a_node.attribute_as_string( GIDI_hrefChars );
 
    if( href != "" ) {
        std::size_t startIndex = startIndexAttribute( a_node );
        std::size_t count = static_cast<std::size_t>( a_node.attribute_as_long( GIDI_countChars ) );
        if( a_setupInfo.m_protare->dataManager( ) == nullptr )
            throw Exception( "parseValuesOfDoubles: Cannot read from HDF5 file as GIDI+ was compiled without HDF5 support." );
        a_setupInfo.m_protare->dataManager( )->getDoubles( a_values, startIndex, startIndex + count ); }
    else {
        HAPI::Data data = a_node.data( );
        data.getDoubles( a_values ); // FIXME overload getDoubles() to take std::vector argument, avoid extra copy?
    }
/*
    int64_t numberConverted = p1.size( );
    a_values.resize( numberConverted );
    for( int64_t i1 = 0; i1 < numberConverted; ++i1 ) a_values[i1] = p1[i1];
*/
}

◆ parseValuesOfDoubles() [3/3]

void GIDI::parseValuesOfDoubles	(	HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		nf_Buffer< double > &	a_vector,
		int	a_useSystem_strtod )

◆ parseValuesOfInts() [1/3]

void GIDI::parseValuesOfInts	(	Construction::Settings const &	a_construction,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		std::vector< int > &	a_vector )

Referenced by GIDI::Array::Array::Array(), GIDI::FlattenedArrayData::FlattenedArrayData(), and parseValuesOfInts().

◆ parseValuesOfInts() [2/3]

void GIDI::parseValuesOfInts	(	HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		nf_Buffer< int > &	a_values )

This function converts the text of a HAPI::Node into a list of ints.

Parameters

a_node	[in] The HAPI::Node node whoses text is to be converted into a list of ints.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_values	[in] The list to fill with the converted values.

Definition at line 146 of file GIDI_misc.cc.

                                                                                                   {
 
    std::string href = a_node.attribute_as_string( GIDI_hrefChars );
 
    if( href != "" ) {
        std::size_t startIndex = startIndexAttribute( a_node );
        std::size_t count = static_cast<std::size_t>( a_node.attribute_as_long( GIDI_countChars ) );
        if( a_setupInfo.m_protare->dataManager( ) == nullptr )
                throw Exception( "parseValuesOfInts: Cannot read from HDF5 file as GIDI+ was compiled without HDF5 support." );
        a_setupInfo.m_protare->dataManager( )->getInts( a_values, startIndex, startIndex + count ); }
    else {
        HAPI::Data data = a_node.data( );
        data.getInts( a_values ); // FIXME overload getDoubles() to take std::vector argument, avoid extra copy?
    }
 
/*
    int64_t numberConverted = p1.size( );
    a_values.resize( numberConverted );
    for( int64_t i1 = 0; i1 < numberConverted; ++i1 ) a_values[i1] = p1[i1];
*/
//  a_values.swap( p1 );
}

◆ parseValuesOfInts() [3/3]

void GIDI::parseValuesOfInts	(	LUPI_maybeUnused Construction::Settings const &	a_construction,
		HAPI::Node const &	a_node,
		SetupInfo &	a_setupInfo,
		nf_Buffer< int > &	a_values )

This function converts the text of a HAPI::Node into a list of ints.

Parameters

a_construction	[in] Used to pass user options to the constructor.
a_node	[in] The HAPI::Node node whose text is to be converted into a list of ints.
a_setupInfo	[in] Information create my the Protare constructor to help in parsing.
a_values	[in] The list to fill with the converted values.

Definition at line 133 of file GIDI_misc.cc.

                                                                                                                                                               {
 
    parseValuesOfInts( a_node, a_setupInfo, a_values );
}

◆ settingsFluxesFromFunction3d()

std::vector< Transporting::Flux > GIDI::settingsFluxesFromFunction3d ( Functions::Function3dForm const & a_function3d )

Convert a flux in the form of a Function3dForm into those needed by Settings methods. Currently only works for XYs3d which contains a list of XYs2d which each contain a list of Legendre instances.

Parameters

a_function3d [in] A Function3dForm instance.

Returns: The list of Transporting::Flux * instances.

Definition at line 439 of file GIDI_settings_flux.cc.

                                                                                                        {
 
    if( a_function3d.type( ) != FormType::XYs3d ) throw Exception( "Currently, only a 3d function of type XYs3d is supported." );
 
    Functions::XYs3d const &xys3d = static_cast<Functions::XYs3d const &>( a_function3d );
    std::vector<Functions::Function2dForm *> const function2ds = xys3d.function2ds( );
    std::vector<Transporting::Flux> fluxes;
 
    for( std::size_t i1 = 0; i1 < function2ds.size( ); ++i1 ) {
        Functions::Function2dForm const &function2d = *function2ds[i1];
 
        if( function2d.type( ) != FormType::XYs2d ) throw Exception( "Currently, only a 2d function of type XYs2d is supported for flux f(E,mu)." );
 
        Functions::XYs2d const &xys2d = static_cast<Functions::XYs2d const &>( function2d );
        std::vector<Functions::Function1dForm *> const &function1ds = xys2d.function1ds( );
 
        Transporting::Flux flux( a_function3d.label( ), xys2d.outerDomainValue( ) );
        std::size_t maxOrder = 0;
        std::vector<double> energies;
        std::vector< std::vector<double> > fluxMatrix;
 
        for( std::size_t i2 = 0; i2 < function1ds.size( ); ++i2 ) {
            Functions::Function1dForm const &function1d = *function1ds[i2];
 
            if( function1d.type( ) != FormType::Legendre1d ) throw Exception( "Currently, only a 1d function of type Legendre1d is supported for flux f(mu)." );
 
            Functions::Legendre1d const &legendre1d = static_cast<Functions::Legendre1d const &>( function1d );
 
            energies.push_back( legendre1d.outerDomainValue( ) );
            std::vector<double> &coefficients = const_cast< std::vector<double> &>( legendre1d.coefficients( ) );
            if( maxOrder < coefficients.size( ) ) maxOrder = coefficients.size( );
            fluxMatrix.push_back( coefficients );
        }
 
        for( std::size_t order = 0; order < maxOrder; ++order ) {
            std::vector<double> energyFluxAtOrder;
 
            for( std::size_t i2 = 0; i2 < function1ds.size( ); ++i2 ) {
                energyFluxAtOrder.push_back( 0.0 );
                if( order < fluxMatrix[i2].size( ) ) energyFluxAtOrder[i2] = fluxMatrix[i2][order];
            }
 
            Transporting::Flux_order fluxOrder( order, energies, energyFluxAtOrder );
            flux.addFluxOrder( fluxOrder );
        }
 
        fluxes.push_back( flux );
    }
 
    return( fluxes );
}

Referenced by GIDI::Transporting::Particle::Particle().

◆ size_t_ToString()

std::string GIDI::size_t_ToString ( std::size_t a_value )

Returns a string representation of std::size_t a_value.

Parameters

a_value [in] The std::size value to convert to a string.

Returns: A std::string instance.

Definition at line 428 of file GIDI_misc.cc.

                                               {
 
    return( LUPI::Misc::argumentsToString( "%zu", a_value ) );
}

Referenced by doublesToXMLList(), and GIDI::Functions::Gridded1d::toXMLList_func().

◆ sortedListOfStrings()

std::vector< std::string > GIDI::sortedListOfStrings	(	std::vector< std::string > const &	a_strings,
		bool	a_orderIsAscending )

This function returns a sorted instance of the strings in a_strings.

Parameters

a_strings	[in] The string to add to the returned std::vector<std::string> instance.
a_orderIsAscending	[in] If true the strings are sorted in ascending order; otherwise, descending order.

Returns: A std::vector<std::string> instance.

Definition at line 353 of file GIDI_misc.cc.

                                                                                                           {
 
    std::vector<std::string> keys( a_strings );
 
    std::sort( keys.begin( ), keys.end( ) );
 
    if( a_orderIsAscending ) return( keys );
 
    std::vector<std::string> keys2;
 
    for( std::vector<std::string>::reverse_iterator iter = keys.rbegin( ); iter != keys.rend( ); ++iter ) keys2.push_back( *iter );
    return( keys2 );
}

Referenced by GIDI::Transporting::Particles::sortedIDs().

◆ transportCorrect() [1/2]

Matrix GIDI::transportCorrect	(	Matrix const &	a_matrix,
		Vector const &	a_transportCorrection )

Transport correct a Matrix.

Parameters

a_matrix	[in] The Matrix to transport correct.
a_transportCorrection	[in] The Vector that has the transport correction terms.

Returns: Returns the collapsed Matrix.

Definition at line 155 of file GIDI_collapse.cc.

                                                                                       {
 
    std::size_t size = a_transportCorrection.size( );
    Matrix corrected( a_matrix );
 
    if( size == 0 ) return( corrected );
    if( a_matrix.size( ) == 0 ) {
        corrected = Matrix( size, size ); }
    else {
        if( size != a_matrix.size( ) ) throw Exception( "transportCorrect: matrix rows different than vector size." );
    }
 
    for( std::size_t index = 0; index < size; ++index ) corrected[index][index] -= a_transportCorrection[index];
    return( corrected );
}

◆ transportCorrect() [2/2]

Vector GIDI::transportCorrect	(	Vector const &	a_vector,
		Vector const &	a_transportCorrection )

Transport correct a vector.

Parameters

a_vector	[in] The Vector to transport correct.
a_transportCorrection	[in] The Vector that has the transport correction terms.

Returns: Returns the collapsed Matrix.

Definition at line 142 of file GIDI_collapse.cc.

                                                                                       {
 
    return( a_vector - a_transportCorrection );
}

◆ vector2GIDI_Ys1d()

Functions::Ys1d GIDI::vector2GIDI_Ys1d	(	Axes const &	a_axes,
		Vector const &	a_vector )

This function converts the values of a Vector into a Ys1d instance.

Parameters

a_axes	[in] The Axes for the returned Ys1d instance.
a_vector	[in] The Vector whoses values are converted into a Ys1d instance.

Returns: A Ys1d instance of the values.

Definition at line 288 of file GIDI_misc.cc.

                                                                             {
 
    std::size_t start = 0;
    for( ; start < a_vector.size( ); ++start ) {
        if( a_vector[start] != 0 ) break;
    }
 
    std::vector<double> ys;
    Functions::Ys1d ys1d( a_axes, ptwXY_interpolationLinLin, start, ys );
 
    for( std::size_t i1 = start; i1 < a_vector.size( ); ++i1 ) ys1d.push_back( a_vector[i1] );
 
    return( ys1d );
}

◆ vectorOfStrings()

std::vector< std::string > GIDI::vectorOfStrings ( std::string const & a_string )

This function returns an instance of std::vector<std::string> with only a_string as an item.

Parameters

a_string [in] The string to add to the returned std::vector<std::string> instance.

Returns: A std::vector<std::string> instance.

Definition at line 337 of file GIDI_misc.cc.

                                                                  {
    std::vector<std::string> vectorOfStrings1;
 
    vectorOfStrings1.push_back( a_string );
    return( vectorOfStrings1 );
}

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

◆ DelayedNeutronProducts

◆ ExcludeReactionsSet

◆ MapWalkCallBack

◆ parseSuite

◆ ParticleSubstitution

◆ stringAndDoublePair

◆ stringAndDoublePairs

Enumeration Type Documentation

◆ FileType

◆ FormType

◆ Frame

◆ GNDS_FileType

◆ ProtareType

◆ TransportCorrectionType

Function Documentation

◆ binarySearchVector()

◆ calculate1dMultiGroupDataInComponent() [1/2]

◆ calculate1dMultiGroupDataInComponent() [2/2]

◆ calculate1dMultiGroupFissionEnergyRelease()

◆ checkOuterDomainValues1d()

◆ checkOuterDomainValues2d()

◆ checkSequentialDomainLimits1d()

◆ checkSequentialDomainLimits2d()

◆ collapse() [1/2]

◆ collapse() [2/2]

◆ data1dListParse()

◆ data1dParse()

◆ data1dParseAllowEmpty()

◆ data2dListParse()

◆ data2dParse()

◆ data3dParse()

◆ doublesToXMLList()

◆ ENDL_CFromENDF_MT()

◆ energy2dToXMLList()

◆ excludeReactionsSetAdjust()

◆ frameToString()

◆ GNDS_fileType()

◆ gridded1d2GIDI_Ys1d()

◆ intsToXMLList()

◆ intToString()

◆ LLNL_fidToLabel()

◆ LLNL_gidToLabel()

◆ multiGroupTwoXYs1ds()

◆ multiGroupXYs1d()

◆ nodeWithValuesToDoubles()

◆ operator<<()

◆ parseACE_URR_probabilityTables() [1/2]

◆ parseACE_URR_probabilityTables() [2/2]

◆ parseAvailableSuite() [1/2]

◆ parseAvailableSuite() [2/2]

◆ parseAverageEnergySuite() [1/2]

◆ parseAverageEnergySuite() [2/2]

◆ parseAverageMomentumSuite() [1/2]

◆ parseAverageMomentumSuite() [2/2]

◆ parseColumnHeaders() [1/2]

◆ parseColumnHeaders() [2/2]

◆ parseCrossSectionSuite() [1/2]

◆ parseCrossSectionSuite() [2/2]

◆ parseDelayedNeutronsSuite()

◆ parseDistributionSuite() [1/2]

◆ parseDistributionSuite() [2/2]

◆ parseDoubleDifferentialCrossSectionSuite() [1/2]

◆ parseDoubleDifferentialCrossSectionSuite() [2/2]

◆ parseExternalFilesSuite() [1/2]

◆ parseExternalFilesSuite() [2/2]

◆ parseFissionComponent()

◆ parseFissionEnergyReleasesSuite() [1/2]

◆ parseFissionEnergyReleasesSuite() [2/2]

◆ parseFlattened1d()

◆ parseFrame() [1/2]

◆ parseFrame() [2/2]

◆ parseMultiplicitySuite() [1/2]

◆ parseMultiplicitySuite() [2/2]

◆ parseOrphanProduct()