MCGIDI.h File Reference

#include <GIDI_settings.hh>
#include <map>
#include <vector>
#include <statusMessageReporting.h>
#include <ptwXY.h>
#include <xDataTOM.h>
#include "MCGIDI_mass.h"
#include "MCGIDI_map.h"

Go to the source code of this file.

Classes
class	MCGIDI_quantitiesLookupModes
struct	MCGIDI_samplingMultiplicityBias_s
class	MCGIDI_samplingMethods
class	MCGIDI_samplingSettings
struct	MCGIDI_GammaBranching_s
struct	MCGIDI_POP_s
struct	MCGIDI_POPs_s
struct	MCGIDI_particle_s
struct	MCGIDI_decaySamplingInfo_s
struct	MCGIDI_productInfo_s
struct	MCGIDI_productsInfo_s
struct	MCGIDI_sampledProductsData_s
struct	MCGIDI_sampledProductsDatas_s
struct	MCGIDI_pdfOfX_s
struct	MCGIDI_pdfsOfXGivenW_s
struct	MCGIDI_pdfsOfXGivenW_sampled_s
struct	MCGIDI_angular_s
struct	MCGIDI_energyWeightedFunctional_s
struct	MCGIDI_energyWeightedFunctionals_s
struct	MCGIDI_energyNBodyPhaseSpace_s
struct	MCGIDI_energy_s
struct	MCGIDI_energyAngular_s
struct	MCGIDI_angularEnergy_s
struct	MCGIDI_KalbachMann_ras_s
struct	MCGIDI_KalbachMann_s
struct	MCGIDI_distribution_s
struct	MCGIDI_outputChannel_s
struct	MCGIDI_product_s
struct	MCGIDI_reaction_s
struct	MCGIDI_target_heated_s
struct	MCGIDI_target_heated_info_s
struct	MCGIDI_target_s

Macros
#define	MCGIDI_VERSION_MAJOR   1
#define	MCGIDI_VERSION_MINOR   0
#define	MCGIDI_VERSION_PATCHLEVEL   0
#define	MCGIDI_crossSectionType_grouped   1
#define	MCGIDI_crossSectionType_pointwise   2
#define	MCGIDI_nullReaction   -10001
#define	MCGIDI_speedOfLight_cm_sec   2.99792458e10
#define	MCGIDI_AMU2MeV   931.494028
#define	MCGIDI_particleLevel_continuum   -1
#define	MCGIDI_particleLevel_sum   -2

Typedefs
typedef struct MCGIDI_GammaBranching_s	MCGIDI_GammaBranching
typedef struct MCGIDI_POP_s	MCGIDI_POP
typedef struct MCGIDI_POPs_s	MCGIDI_POPs
typedef struct MCGIDI_particle_s	MCGIDI_particle
typedef struct MCGIDI_target_s	MCGIDI_target
typedef struct MCGIDI_target_heated_info_s	MCGIDI_target_heated_info
typedef struct MCGIDI_target_heated_sorted_s	MCGIDI_target_heated_sorted
typedef struct MCGIDI_target_heated_s	MCGIDI_target_heated
typedef struct MCGIDI_reaction_s	MCGIDI_reaction
typedef struct MCGIDI_outputChannel_s	MCGIDI_outputChannel
typedef struct MCGIDI_product_s	MCGIDI_product
typedef struct MCGIDI_distribution_s	MCGIDI_distribution
typedef struct MCGIDI_KalbachMann_s	MCGIDI_KalbachMann
typedef struct MCGIDI_KalbachMann_ras_s	MCGIDI_KalbachMann_ras
typedef struct MCGIDI_pdfOfX_s	MCGIDI_pdfOfX
typedef struct MCGIDI_pdfsOfXGivenW_s	MCGIDI_pdfsOfXGivenW
typedef struct MCGIDI_pdfsOfXGivenW_sampled_s	MCGIDI_pdfsOfXGivenW_sampled
typedef struct MCGIDI_angular_s	MCGIDI_angular
typedef struct MCGIDI_energyWeightedFunctional_s	MCGIDI_energyWeightedFunctional
typedef struct MCGIDI_energyWeightedFunctionals_s	MCGIDI_energyWeightedFunctionals
typedef struct MCGIDI_energyNBodyPhaseSpace_s	MCGIDI_energyNBodyPhaseSpace
typedef struct MCGIDI_energy_s	MCGIDI_energy
typedef struct MCGIDI_energyAngular_s	MCGIDI_energyAngular
typedef struct MCGIDI_angularEnergy_s	MCGIDI_angularEnergy
typedef struct MCGIDI_decaySamplingInfo_s	MCGIDI_decaySamplingInfo
typedef struct MCGIDI_productsInfo_s	MCGIDI_productsInfo
typedef struct MCGIDI_productInfo_s	MCGIDI_productInfo
typedef struct MCGIDI_sampledProductsData_s	MCGIDI_sampledProductsData
typedef struct MCGIDI_sampledProductsDatas_s	MCGIDI_sampledProductsDatas
typedef struct MCGIDI_samplingMultiplicityBias_s	MCGIDI_samplingMultiplicityBias
typedef std::map< int, enum GIDI::MCGIDI_transportability >	transportabilitiesMap

Enumerations
enum	MCGIDI_quantityLookupMode { MCGIDI_quantityLookupMode_pointwise , MCGIDI_quantityLookupMode_grouped }
enum	MCGIDI_transportability { MCGIDI_transportability_unknown , MCGIDI_transportability_none , MCGIDI_transportability_partial , MCGIDI_transportability_full }
enum	MCGIDI_reactionType {   MCGIDI_reactionType_unknown_e , MCGIDI_reactionType_null_e , MCGIDI_reactionType_elastic_e , MCGIDI_reactionType_scattering_e ,   MCGIDI_reactionType_nuclearIsomerTransmutation_e , MCGIDI_reactionType_nuclearLevelTransition_e , MCGIDI_reactionType_capture_e , MCGIDI_reactionType_fission_e ,   MCGIDI_reactionType_sumOfRemainingOutputChannels_e , MCGIDI_reactionType_atomic_e }
enum	MCGIDI_channelGenre {   MCGIDI_channelGenre_undefined_e , MCGIDI_channelGenre_twoBody_e , MCGIDI_channelGenre_uncorrelated_e , MCGIDI_channelGenre_sumOfRemaining_e ,   MCGIDI_channelGenre_twoBodyDecay_e , MCGIDI_channelGenre_uncorrelatedDecay_e }
enum	MCGIDI_productMultiplicityType {   MCGIDI_productMultiplicityType_invalid_e , MCGIDI_productMultiplicityType_unknown_e , MCGIDI_productMultiplicityType_integer_e , MCGIDI_productMultiplicityType_energyDependent_e ,   MCGIDI_productMultiplicityType_gammaBranching_e , MCGIDI_productMultiplicityType_mixed_e }
enum	MCGIDI_distributionType {   MCGIDI_distributionType_none_e , MCGIDI_distributionType_unknown_e , MCGIDI_distributionType_angular_e , MCGIDI_distributionType_KalbachMann_e ,   MCGIDI_distributionType_uncorrelated_e , MCGIDI_distributionType_energyAngular_e , MCGIDI_distributionType_angularEnergy_e }
enum	MCGIDI_angularType { MCGIDI_angularType_isotropic , MCGIDI_angularType_recoil , MCGIDI_angularType_linear }
enum	MCGIDI_energyType {   MCGIDI_energyType_unknown , MCGIDI_energyType_primaryGamma , MCGIDI_energyType_discreteGamma , MCGIDI_energyType_linear ,   MCGIDI_energyType_generalEvaporation , MCGIDI_energyType_simpleMaxwellianFission , MCGIDI_energyType_evaporation , MCGIDI_energyType_Watt ,   MCGIDI_energyType_MadlandNix , MCGIDI_energyType_NBodyPhaseSpace , MCGIDI_energyType_weightedFunctional }

Functions
char const *	MCGIDI_version (void)
int	MCGIDI_versionMajor (void)
int	MCGIDI_versionMinor (void)
int	MCGIDI_versionPatchLevel (void)
MCGIDI_target *	MCGIDI_target_new (statusMessageReporting *smr)
int	MCGIDI_target_initialize (statusMessageReporting *smr, MCGIDI_target *target)
MCGIDI_target *	MCGIDI_target_newRead (statusMessageReporting *smr, const char *fileName)
int	MCGIDI_target_readFromMapViaPoPIDs (statusMessageReporting *smr, MCGIDI_target *target, MCGIDI_map *map, const char *evaluation, int projectile_PoPID, int target_PoPID)
int	MCGIDI_target_readFromMap (statusMessageReporting *smr, MCGIDI_target *target, MCGIDI_map *map, const char *evaluation, const char *projectileName, const char *targetName)
MCGIDI_target *	MCGIDI_target_newReadFromMapViaPoPIDs (statusMessageReporting *smr, MCGIDI_map *map, const char *evaluation, int projectile_PoPID, int target_PoPID)
MCGIDI_target *	MCGIDI_target_newReadFromMap (statusMessageReporting *smr, MCGIDI_map *map, const char *evaluation, const char *projectileName, const char *targetName)
MCGIDI_target *	MCGIDI_target_free (statusMessageReporting *smr, MCGIDI_target *target)
int	MCGIDI_target_release (statusMessageReporting *smr, MCGIDI_target *target)
int	MCGIDI_target_read (statusMessageReporting *smr, MCGIDI_target *target, const char *fileName)
char const *	MCGIDI_target_getAttributesValue (statusMessageReporting *smr, MCGIDI_target *target, char const *name)
int	MCGIDI_target_getTemperatures (statusMessageReporting *smr, MCGIDI_target *target, double *temperatures)
int	MCGIDI_target_readHeatedTarget (statusMessageReporting *smr, MCGIDI_target *target, int index)
MCGIDI_target_heated *	MCGIDI_target_getHeatedTargetAtIndex_ReadIfNeeded (statusMessageReporting *smr, MCGIDI_target *target, int index)
MCGIDI_target_heated *	MCGIDI_target_getHeatedTargetAtTIndex (statusMessageReporting *smr, MCGIDI_target *target, int index)
int	MCGIDI_target_numberOfReactions (statusMessageReporting *smr, MCGIDI_target *target)
enum MCGIDI_reactionType	MCGIDI_target_getReactionTypeAtIndex (statusMessageReporting *smr, MCGIDI_target *target, int index)
MCGIDI_reaction *	MCGIDI_target_getReactionAtIndex (MCGIDI_target *target, int index)
MCGIDI_reaction *	MCGIDI_target_getReactionAtIndex_smr (statusMessageReporting *smr, MCGIDI_target *target, int index)
int	MCGIDI_target_numberOfProductionReactions (statusMessageReporting *smr, MCGIDI_target *target)
transportabilitiesMap const *	MCGIDI_target_getUniqueProducts (statusMessageReporting *smr, MCGIDI_target *target)
int	MCGIDI_target_recast (statusMessageReporting *smr, MCGIDI_target *target, GIDI_settings &settings)
int	MCGIDI_target_getDomain (statusMessageReporting *smr, MCGIDI_target *target, double *EMin, double *EMax)
double	MCGIDI_target_getTotalCrossSectionAtTAndE (statusMessageReporting *smr, MCGIDI_target *target, MCGIDI_quantitiesLookupModes &modes, bool sampling)
double	MCGIDI_target_getIndexReactionCrossSectionAtE (statusMessageReporting *smr, MCGIDI_target *target, int index, MCGIDI_quantitiesLookupModes &modes, bool sampling)
int	MCGIDI_target_sampleReaction (statusMessageReporting *smr, MCGIDI_target *target, MCGIDI_quantitiesLookupModes &modes, double totalXSec, double(*userrng)(void *), void *rngState)
int	MCGIDI_target_sampleNullReactionProductsAtE (statusMessageReporting *smr, MCGIDI_target *target, MCGIDI_quantitiesLookupModes &modes, MCGIDI_decaySamplingInfo *decaySamplingInfo, MCGIDI_sampledProductsDatas *productDatas)
int	MCGIDI_target_sampleIndexReactionProductsAtE (statusMessageReporting *smr, MCGIDI_target *target, int index, MCGIDI_quantitiesLookupModes &modes, MCGIDI_decaySamplingInfo *decaySamplingInfo, MCGIDI_sampledProductsDatas *productData)
double	MCGIDI_target_getIndexReactionFinalQ (statusMessageReporting *smr, MCGIDI_target *target, int index, MCGIDI_quantitiesLookupModes &modes)
MCGIDI_target_heated *	MCGIDI_target_heated_new (statusMessageReporting *smr)
int	MCGIDI_target_heated_initialize (statusMessageReporting *smr, MCGIDI_target_heated *target)
MCGIDI_target_heated *	MCGIDI_target_heated_newRead (statusMessageReporting *smr, const char *fileName)
MCGIDI_target_heated *	MCGIDI_target_heated_free (statusMessageReporting *smr, MCGIDI_target_heated *target)
int	MCGIDI_target_heated_release (statusMessageReporting *smr, MCGIDI_target_heated *target)
int	MCGIDI_target_heated_read (statusMessageReporting *smr, MCGIDI_target_heated *target, const char *fileName)
int	MCGIDI_target_heated_numberOfReactions (statusMessageReporting *smr, MCGIDI_target_heated *target)
int	MCGIDI_target_heated_numberOfProductionReactions (statusMessageReporting *smr, MCGIDI_target_heated *target)
MCGIDI_reaction *	MCGIDI_target_heated_getReactionAtIndex (MCGIDI_target_heated *target, int index)
MCGIDI_reaction *	MCGIDI_target_heated_getReactionAtIndex_smr (statusMessageReporting *smr, MCGIDI_target_heated *target, int index)
MCGIDI_POP *	MCGIDI_target_heated_getPOPForProjectile (statusMessageReporting *smr, MCGIDI_target_heated *target)
MCGIDI_POP *	MCGIDI_target_heated_getPOPForTarget (statusMessageReporting *smr, MCGIDI_target_heated *target)
double	MCGIDI_target_heated_getProjectileMass_MeV (statusMessageReporting *smr, MCGIDI_target_heated *target)
double	MCGIDI_target_heated_getTargetMass_MeV (statusMessageReporting *smr, MCGIDI_target_heated *target)
int	MCGIDI_target_heated_getEnergyGrid (statusMessageReporting *smr, MCGIDI_target_heated *target, double **energyGrid)
double	MCGIDI_target_heated_getTotalCrossSectionAtE (statusMessageReporting *smr, MCGIDI_target_heated *target, MCGIDI_quantitiesLookupModes &modes, bool sampling)
double	MCGIDI_target_heated_getIndexReactionCrossSectionAtE (statusMessageReporting *smr, MCGIDI_target_heated *target, int index, MCGIDI_quantitiesLookupModes &modes, bool sampling)
int	MCGIDI_target_heated_sampleIndexReactionProductsAtE (statusMessageReporting *smr, MCGIDI_target_heated *target, int index, MCGIDI_quantitiesLookupModes &modes, MCGIDI_decaySamplingInfo *decaySamplingInfo, MCGIDI_sampledProductsDatas *productData)
double	MCGIDI_target_heated_getReactionsThreshold (statusMessageReporting *smr, MCGIDI_target_heated *target, int index)
int	MCGIDI_target_heated_getReactionsDomain (statusMessageReporting *smr, MCGIDI_target_heated *target, int index, double *EMin, double *EMax)
double	MCGIDI_target_heated_getIndexReactionFinalQ (statusMessageReporting *smr, MCGIDI_target_heated *target, int index, MCGIDI_quantitiesLookupModes &modes)
transportabilitiesMap const *	MCGIDI_target_heated_getUniqueProducts (statusMessageReporting *smr, MCGIDI_target_heated *target)
int	MCGIDI_target_heated_recast (statusMessageReporting *smr, MCGIDI_target_heated *target, GIDI_settings &settings)
MCGIDI_reaction *	MCGIDI_reaction_new (statusMessageReporting *smr)
int	MCGIDI_reaction_initialize (statusMessageReporting *smr, MCGIDI_reaction *reaction)
MCGIDI_reaction *	MCGIDI_reaction_free (statusMessageReporting *smr, MCGIDI_reaction *reaction)
int	MCGIDI_reaction_release (statusMessageReporting *smr, MCGIDI_reaction *reaction)
int	MCGIDI_reaction_parseFromTOM (statusMessageReporting *smr, xDataTOM_element *element, MCGIDI_target_heated *target, MCGIDI_POPs *pops, MCGIDI_reaction *reaction)
enum MCGIDI_reactionType	MCGIDI_reaction_getReactionType (statusMessageReporting *smr, MCGIDI_reaction *reaction)
MCGIDI_target_heated *	MCGIDI_reaction_getTargetHeated (statusMessageReporting *smr, MCGIDI_reaction *reaction)
double	MCGIDI_reaction_getProjectileMass_MeV (statusMessageReporting *smr, MCGIDI_reaction *reaction)
double	MCGIDI_reaction_getTargetMass_MeV (statusMessageReporting *smr, MCGIDI_reaction *reaction)
int	MCGIDI_reaction_getDomain (statusMessageReporting *smr, MCGIDI_reaction *reaction, double *EMin, double *EMax)
int	MCGIDI_reaction_fixDomains (statusMessageReporting *smr, MCGIDI_reaction *reaction, double EMin, double EMax, nfu_status *status)
double	MCGIDI_reaction_getCrossSectionAtE (statusMessageReporting *smr, MCGIDI_reaction *reaction, MCGIDI_quantitiesLookupModes &modes, bool sampling)
double	MCGIDI_reaction_getFinalQ (statusMessageReporting *smr, MCGIDI_reaction *reaction, MCGIDI_quantitiesLookupModes &modes)
int	MCGIDI_reaction_getENDF_MTNumber (MCGIDI_reaction *reaction)
int	MCGIDI_reaction_getENDL_CSNumbers (MCGIDI_reaction *reaction, int *S)
int	MCGIDI_reaction_recast (statusMessageReporting *smr, MCGIDI_reaction *reaction, GIDI_settings &settings, GIDI_settings_particle const *projectileSettings, double temperature_MeV, ptwXPoints *totalGroupedCrossSection)
MCGIDI_productsInfo *	MCGIDI_reaction_getProductsInfo (MCGIDI_reaction *reaction)
int	MCGIDI_productsInfo_getNumberOfUniqueProducts (MCGIDI_productsInfo *productsInfo)
int	MCGIDI_productsInfo_getPoPsIndexAtIndex (MCGIDI_productsInfo *productsInfo, int index)
enum MCGIDI_productMultiplicityType	MCGIDI_productsInfo_getMultiplicityTypeAtIndex (MCGIDI_productsInfo *productsInfo, int index)
int	MCGIDI_productsInfo_getIntegerMultiplicityAtIndex (MCGIDI_productsInfo *productsInfo, int index)
int	MCGIDI_productsInfo_getTransportableAtIndex (MCGIDI_productsInfo *productsInfo, int index)
MCGIDI_POPs *	MCGIDI_POPs_new (statusMessageReporting *smr, int size)
int	MCGIDI_POPs_initial (statusMessageReporting *smr, MCGIDI_POPs *pops, int size)
void *	MCGIDI_POPs_free (MCGIDI_POPs *pops)
int	MCGIDI_POPs_release (MCGIDI_POPs *pops)
MCGIDI_POP *	MCGIDI_POPs_addParticleIfNeeded (statusMessageReporting *smr, MCGIDI_POPs *pops, char const *name, double mass_MeV, double level_MeV, MCGIDI_POP *parent, int globalParticle)
int	MCGIDI_POPs_findParticleIndex (MCGIDI_POPs *pops, char const *name)
MCGIDI_POP *	MCGIDI_POPs_findParticle (MCGIDI_POPs *pops, char const *name)
void	MCGIDI_POPs_writeSortedList (MCGIDI_POPs *pops, FILE *f)
void	MCGIDI_POPs_printSortedList (MCGIDI_POPs *pops)
MCGIDI_POP *	MCGIDI_POP_new (statusMessageReporting *smr, char const *name, double mass_MeV, double level_MeV, MCGIDI_POP *parent)
MCGIDI_POP *	MCGIDI_POP_free (MCGIDI_POP *pop)
MCGIDI_POP *	MCGIDI_POP_release (MCGIDI_POP *pop)
double	MCGIDI_POP_getMass_MeV (MCGIDI_POP *pop)
MCGIDI_particle *	MCGIDI_particle_new (statusMessageReporting *smr)
int	MCGIDI_particle_initialize (statusMessageReporting *smr, MCGIDI_particle *particle)
MCGIDI_particle *	MCGIDI_particle_free (statusMessageReporting *smr, MCGIDI_particle *particle)
int	MCGIDI_particle_release (statusMessageReporting *smr, MCGIDI_particle *particle)
int	MCGIDI_particle_freeInternalList (statusMessageReporting *smr)
MCGIDI_particle *	MCGIDI_particle_getInternalID (statusMessageReporting *smr, const char *const name, MCGIDI_POPs *pops)
int	MCGIDI_particle_printInternalSortedList (statusMessageReporting *smr)
MCGIDI_outputChannel *	MCGIDI_outputChannel_new (statusMessageReporting *smr)
int	MCGIDI_outputChannel_initialize (statusMessageReporting *smr, MCGIDI_outputChannel *outputChannel)
MCGIDI_outputChannel *	MCGIDI_outputChannel_free (statusMessageReporting *smr, MCGIDI_outputChannel *outputChannel)
int	MCGIDI_outputChannel_release (statusMessageReporting *smr, MCGIDI_outputChannel *outputChannel)
int	MCGIDI_outputChannel_parseFromTOM (statusMessageReporting *smr, xDataTOM_element *element, MCGIDI_POPs *pops, MCGIDI_outputChannel *outputChannel, MCGIDI_reaction *reaction, MCGIDI_product *parent)
int	MCGIDI_outputChannel_numberOfProducts (MCGIDI_outputChannel *outputChannel)
MCGIDI_product *	MCGIDI_outputChannel_getProductAtIndex (statusMessageReporting *smr, MCGIDI_outputChannel *outputChannel, int i)
int	MCGIDI_outputChannel_getDomain (statusMessageReporting *smr, MCGIDI_outputChannel *outputChannel, double *EMin, double *EMax)
MCGIDI_target_heated *	MCGIDI_outputChannel_getTargetHeated (statusMessageReporting *smr, MCGIDI_outputChannel *outputChannel)
double	MCGIDI_outputChannel_getProjectileMass_MeV (statusMessageReporting *smr, MCGIDI_outputChannel *outputChannel)
double	MCGIDI_outputChannel_getTargetMass_MeV (statusMessageReporting *smr, MCGIDI_outputChannel *outputChannel)
double	MCGIDI_outputChannel_getQ_MeV (statusMessageReporting *smr, MCGIDI_outputChannel *outputChannel, double e_in)
double	MCGIDI_outputChannel_getFinalQ (statusMessageReporting *smr, MCGIDI_outputChannel *outputChannel, double e_in)
int	MCGIDI_outputChannel_sampleProductsAtE (statusMessageReporting *smr, MCGIDI_outputChannel *outputChannel, MCGIDI_quantitiesLookupModes &modes, MCGIDI_decaySamplingInfo *decaySamplingInfo, MCGIDI_sampledProductsDatas *productDatas, double *masses)
MCGIDI_product *	MCGIDI_product_new (statusMessageReporting *smr)
int	MCGIDI_product_initialize (statusMessageReporting *smr, MCGIDI_product *product)
MCGIDI_product *	MCGIDI_product_free (statusMessageReporting *smr, MCGIDI_product *product)
int	MCGIDI_product_release (statusMessageReporting *smr, MCGIDI_product *product)
int	MCGIDI_product_parseFromTOM (statusMessageReporting *smr, xDataTOM_element *element, MCGIDI_outputChannel *outputChannel, MCGIDI_POPs *pops, MCGIDI_product *product, int *delayedNeutronIndex)
int	MCGIDI_product_getDomain (statusMessageReporting *smr, MCGIDI_product *product, double *EMin, double *EMax)
int	MCGIDI_product_setTwoBodyMasses (statusMessageReporting *smr, MCGIDI_product *product, double projectileMass_MeV, double targetMass_MeV, double productMass_MeV, double residualMass_MeV)
double	MCGIDI_product_getMass_MeV (statusMessageReporting *smr, MCGIDI_product *product)
MCGIDI_target_heated *	MCGIDI_product_getTargetHeated (statusMessageReporting *smr, MCGIDI_product *product)
double	MCGIDI_product_getProjectileMass_MeV (statusMessageReporting *smr, MCGIDI_product *product)
double	MCGIDI_product_getTargetMass_MeV (statusMessageReporting *smr, MCGIDI_product *product)
int	MCGIDI_product_sampleMultiplicity (statusMessageReporting *smr, MCGIDI_product *product, double e_in, double r)
int	MCGIDI_product_sampleMu (statusMessageReporting *smr, MCGIDI_product *product, MCGIDI_quantitiesLookupModes &modes, MCGIDI_decaySamplingInfo *decaySamplingInfo)
int	MCGIDI_sampledProducts_initialize (statusMessageReporting *smr, MCGIDI_sampledProductsDatas *sampledProductsDatas, int incrementSize)
int	MCGIDI_sampledProducts_release (statusMessageReporting *smr, MCGIDI_sampledProductsDatas *sampledProductsDatas)
int	MCGIDI_sampledProducts_remalloc (statusMessageReporting *smr, MCGIDI_sampledProductsDatas *sampledProductsDatas)
int	MCGIDI_sampledProducts_addProduct (statusMessageReporting *smr, MCGIDI_sampledProductsDatas *sampledProductsDatas, MCGIDI_sampledProductsData *sampledProductsData)
int	MCGIDI_sampledProducts_number (MCGIDI_sampledProductsDatas *sampledProductsDatas)
MCGIDI_sampledProductsData *	MCGIDI_sampledProducts_getProductAtIndex (MCGIDI_sampledProductsDatas *sampledProductsDatas, int index)
MCGIDI_distribution *	MCGIDI_distribution_new (statusMessageReporting *smr)
int	MCGIDI_distribution_initialize (statusMessageReporting *smr, MCGIDI_distribution *distribution)
MCGIDI_distribution *	MCGIDI_distribution_free (statusMessageReporting *smr, MCGIDI_distribution *distribution)
int	MCGIDI_distribution_release (statusMessageReporting *smr, MCGIDI_distribution *distribution)
int	MCGIDI_distribution_parseFromTOM (statusMessageReporting *smr, xDataTOM_element *element, MCGIDI_product *product, MCGIDI_POPs *pops, ptwXYPoints *norms)
MCGIDI_angular *	MCGIDI_angular_new (statusMessageReporting *smr)
int	MCGIDI_angular_initialize (statusMessageReporting *smr, MCGIDI_angular *angular)
MCGIDI_angular *	MCGIDI_angular_free (statusMessageReporting *smr, MCGIDI_angular *angular)
int	MCGIDI_angular_release (statusMessageReporting *smr, MCGIDI_angular *angular)
int	MCGIDI_angular_setTwoBodyMasses (statusMessageReporting *smr, MCGIDI_angular *angular, double projectileMass_MeV, double targetMass_MeV, double productMass_MeV, double residualMass_MeV)
int	MCGIDI_angular_parseFromTOM (statusMessageReporting *smr, xDataTOM_element *element, MCGIDI_distribution *distribution, ptwXYPoints *norms)
int	MCGIDI_angular_sampleMu (statusMessageReporting *smr, MCGIDI_angular *angular, MCGIDI_quantitiesLookupModes &modes, MCGIDI_decaySamplingInfo *decaySamplingInfo)
MCGIDI_energy *	MCGIDI_energy_new (statusMessageReporting *smr)
int	MCGIDI_energy_initialize (statusMessageReporting *smr, MCGIDI_energy *energy)
MCGIDI_energy *	MCGIDI_energy_free (statusMessageReporting *smr, MCGIDI_energy *energy)
int	MCGIDI_energy_release (statusMessageReporting *smr, MCGIDI_energy *energy)
int	MCGIDI_energy_parseFromTOM (statusMessageReporting *smr, xDataTOM_element *element, MCGIDI_distribution *distribution, ptwXYPoints *norms, enum MCGIDI_energyType energyType, double gammaEnergy_MeV)
int	MCGIDI_energy_sampleEnergy (statusMessageReporting *smr, MCGIDI_energy *energy, MCGIDI_quantitiesLookupModes &modes, MCGIDI_decaySamplingInfo *decaySamplingInfo)
int	MCGIDI_energyAngular_parseFromTOM (statusMessageReporting *smr, xDataTOM_element *element, MCGIDI_distribution *distribution)
MCGIDI_energyAngular *	MCGIDI_energyAngular_new (statusMessageReporting *smr)
int	MCGIDI_energyAngular_initialize (statusMessageReporting *smr, MCGIDI_energyAngular *energyAngular)
MCGIDI_energyAngular *	MCGIDI_energyAngular_free (statusMessageReporting *smr, MCGIDI_energyAngular *energyAngular)
int	MCGIDI_energyAngular_release (statusMessageReporting *smr, MCGIDI_energyAngular *energyAngular)
int	MCGIDI_energyAngular_sampleDistribution (statusMessageReporting *smr, MCGIDI_distribution *distribution, MCGIDI_quantitiesLookupModes &modes, MCGIDI_decaySamplingInfo *decaySamplingInfo)
MCGIDI_angularEnergy *	MCGIDI_angularEnergy_new (statusMessageReporting *smr)
int	MCGIDI_angularEnergy_initialize (statusMessageReporting *smr, MCGIDI_angularEnergy *energyAngular)
MCGIDI_angularEnergy *	MCGIDI_angularEnergy_free (statusMessageReporting *smr, MCGIDI_angularEnergy *energyAngular)
int	MCGIDI_angularEnergy_release (statusMessageReporting *smr, MCGIDI_angularEnergy *energyAngular)
int	MCGIDI_angularEnergy_parseFromTOM (statusMessageReporting *smr, xDataTOM_element *element, MCGIDI_distribution *distribution)
int	MCGIDI_angularEnergy_sampleDistribution (statusMessageReporting *smr, MCGIDI_angularEnergy *angularEnergy, MCGIDI_quantitiesLookupModes &modes, MCGIDI_decaySamplingInfo *decaySamplingInfo)
MCGIDI_KalbachMann *	MCGIDI_KalbachMann_new (statusMessageReporting *smr, ptwXY_interpolation interpolationWY, ptwXY_interpolation interpolationXY)
int	MCGIDI_KalbachMann_initialize (statusMessageReporting *smr, MCGIDI_KalbachMann *KalbachMann, ptwXY_interpolation interpolationWY, ptwXY_interpolation interpolationXY)
MCGIDI_KalbachMann *	MCGIDI_KalbachMann_free (statusMessageReporting *smr, MCGIDI_KalbachMann *KalbachMann)
int	MCGIDI_KalbachMann_release (statusMessageReporting *smr, MCGIDI_KalbachMann *KalbachMann)
int	MCGIDI_KalbachMann_parseFromTOM (statusMessageReporting *smr, xDataTOM_element *element, MCGIDI_distribution *distribution)
int	MCGIDI_KalbachMann_sampleEp (statusMessageReporting *smr, MCGIDI_KalbachMann *KalbachMann, MCGIDI_quantitiesLookupModes &modes, MCGIDI_decaySamplingInfo *decaySamplingInfo)
int	MCGIDI_uncorrelated_parseFromTOM (statusMessageReporting *smr, xDataTOM_element *element, MCGIDI_distribution *distribution, ptwXYPoints *norms, enum MCGIDI_energyType energyType, double gammaEnergy_MeV)
int	MCGIDI_uncorrelated_sampleDistribution (statusMessageReporting *smr, MCGIDI_distribution *distribution, MCGIDI_quantitiesLookupModes &modes, MCGIDI_decaySamplingInfo *decaySamplingInfo)
int	MCGIDI_LLNLAngular_angularEnergy_parseFromTOM (statusMessageReporting *smr, xDataTOM_element *element, MCGIDI_distribution *distribution)
int	MCGIDI_kinetics_2BodyReaction (statusMessageReporting *smr, MCGIDI_angular *angular, double K, double mu, double phi, MCGIDI_sampledProductsData *outgoingData)
int	MCGIDI_kinetics_COMKineticEnergy2LabEnergyAndMomentum (statusMessageReporting *smr, double beta, double e_kinetic_com, double mu, double phi, double m3cc, double m4cc, MCGIDI_sampledProductsData *outgoingData)
int	MCGIDI_kinetics_COM2Lab (statusMessageReporting *smr, MCGIDI_quantitiesLookupModes &modes, MCGIDI_decaySamplingInfo *decaySamplingInfo, double masses[3])
int	MCGIDI_sampling_pdfsOfXGivenW_initialize (statusMessageReporting *smr, MCGIDI_pdfsOfXGivenW *dists)
int	MCGIDI_sampling_pdfsOfXGivenW_release (statusMessageReporting *smr, MCGIDI_pdfsOfXGivenW *dists)
int	MCGIDI_sampling_pdfsOfX_release (statusMessageReporting *smr, MCGIDI_pdfOfX *dist)
int	MCGIDI_sampling_sampleX_from_pdfsOfXGivenW (MCGIDI_pdfsOfXGivenW *dists, MCGIDI_pdfsOfXGivenW_sampled *sampled, double r)
int	MCGIDI_sampling_sampleX_from_pdfOfX (MCGIDI_pdfOfX *dist, MCGIDI_pdfsOfXGivenW_sampled *sampled, double r)
int	MCGIDI_sampling_doubleDistribution (statusMessageReporting *smr, MCGIDI_pdfsOfXGivenW *pdfOfWGivenV, MCGIDI_pdfsOfXGivenW *pdfOfXGivenVAndW, MCGIDI_quantitiesLookupModes &modes, MCGIDI_decaySamplingInfo *decaySamplingInfo)
int	MCGIDI_sampling_interpolationValues (statusMessageReporting *smr, ptwXY_interpolation interpolation, double *ws, double y1, double y2, double *y)
double	MCGIDI_sampling_ptwXY_getValueAtX (ptwXYPoints *ptwXY, double x1)
int	MCGIDI_misc_NumberOfZSymbols (void)
const char *	MCGIDI_misc_ZToSymbol (int iZ)
int	MCGIDI_misc_symbolToZ (const char *Z)
int	MCGIDI_miscNameToZAm (statusMessageReporting *smr, const char *name, int *Z, int *A, int *m, int *level)
xDataTOM_Int	MCGIDI_misc_binarySearch (xDataTOM_Int n, double *ds, double d)
int	MCGIDI_misc_PQUStringToDouble (statusMessageReporting *smr, char const *str, char const *unit, double conversion, double *value)
int	MCGIDI_misc_PQUStringToDoubleInUnitOf (statusMessageReporting *smr, char const *str, char const *toUnit, double *value)
void	MCGIDI_misc_updateTransportabilitiesMap (transportabilitiesMap *transportabilities, int PoPID, enum MCGIDI_transportability transportability)
void	MCGIDI_misc_updateTransportabilitiesMap2 (transportabilitiesMap *transportabilities, int PoPID, int transportable)

Variables
const char *	MCGIDI_productGenre_unknown
const char *	MCGIDI_productGenre_twoBody_angular
const char *	MCGIDI_productGenre_twoBody_formFactor
const char *	MCGIDI_productGenre_NBody_angular_energy
const char *	MCGIDI_productGenre_NBody_pairProduction

Macro Definition Documentation

MCGIDI_AMU2MeV

#define MCGIDI_AMU2MeV   931.494028

Definition at line 184 of file MCGIDI.h.

MCGIDI_crossSectionType_grouped

#define MCGIDI_crossSectionType_grouped   1

Definition at line 178 of file MCGIDI.h.

MCGIDI_crossSectionType_pointwise

#define MCGIDI_crossSectionType_pointwise   2

Definition at line 179 of file MCGIDI.h.

MCGIDI_nullReaction

#define MCGIDI_nullReaction   -10001

Definition at line 181 of file MCGIDI.h.

MCGIDI_particleLevel_continuum

#define MCGIDI_particleLevel_continuum   -1

Definition at line 221 of file MCGIDI.h.

MCGIDI_particleLevel_sum

#define MCGIDI_particleLevel_sum   -2

Definition at line 222 of file MCGIDI.h.

MCGIDI_speedOfLight_cm_sec

#define MCGIDI_speedOfLight_cm_sec   2.99792458e10

Definition at line 183 of file MCGIDI.h.

MCGIDI_VERSION_MAJOR

#define MCGIDI_VERSION_MAJOR   1

Definition at line 8 of file MCGIDI.h.

MCGIDI_VERSION_MINOR

#define MCGIDI_VERSION_MINOR   0

Definition at line 9 of file MCGIDI.h.

MCGIDI_VERSION_PATCHLEVEL

#define MCGIDI_VERSION_PATCHLEVEL   0

Definition at line 10 of file MCGIDI.h.

Typedef Documentation

MCGIDI_angular

typedef struct MCGIDI_angular_s MCGIDI_angular

Definition at line 58 of file MCGIDI.h.

MCGIDI_angularEnergy

typedef struct MCGIDI_angularEnergy_s MCGIDI_angularEnergy

Definition at line 64 of file MCGIDI.h.

MCGIDI_decaySamplingInfo

typedef struct MCGIDI_decaySamplingInfo_s MCGIDI_decaySamplingInfo

Definition at line 66 of file MCGIDI.h.

MCGIDI_distribution

typedef struct MCGIDI_distribution_s MCGIDI_distribution

Definition at line 52 of file MCGIDI.h.

MCGIDI_energy

typedef struct MCGIDI_energy_s MCGIDI_energy

Definition at line 62 of file MCGIDI.h.

MCGIDI_energyAngular

typedef struct MCGIDI_energyAngular_s MCGIDI_energyAngular

Definition at line 63 of file MCGIDI.h.

MCGIDI_energyNBodyPhaseSpace

typedef struct MCGIDI_energyNBodyPhaseSpace_s MCGIDI_energyNBodyPhaseSpace

Definition at line 61 of file MCGIDI.h.

MCGIDI_energyWeightedFunctional

typedef struct MCGIDI_energyWeightedFunctional_s MCGIDI_energyWeightedFunctional

Definition at line 59 of file MCGIDI.h.

MCGIDI_energyWeightedFunctionals

typedef struct MCGIDI_energyWeightedFunctionals_s MCGIDI_energyWeightedFunctionals

Definition at line 60 of file MCGIDI.h.

MCGIDI_GammaBranching

typedef struct MCGIDI_GammaBranching_s MCGIDI_GammaBranching

Definition at line 41 of file MCGIDI.h.

MCGIDI_KalbachMann

typedef struct MCGIDI_KalbachMann_s MCGIDI_KalbachMann

Definition at line 53 of file MCGIDI.h.

MCGIDI_KalbachMann_ras

typedef struct MCGIDI_KalbachMann_ras_s MCGIDI_KalbachMann_ras

Definition at line 54 of file MCGIDI.h.

MCGIDI_outputChannel

typedef struct MCGIDI_outputChannel_s MCGIDI_outputChannel

Definition at line 50 of file MCGIDI.h.

MCGIDI_particle

typedef struct MCGIDI_particle_s MCGIDI_particle

Definition at line 44 of file MCGIDI.h.

MCGIDI_pdfOfX

typedef struct MCGIDI_pdfOfX_s MCGIDI_pdfOfX

Definition at line 55 of file MCGIDI.h.

MCGIDI_pdfsOfXGivenW

typedef struct MCGIDI_pdfsOfXGivenW_s MCGIDI_pdfsOfXGivenW

Definition at line 56 of file MCGIDI.h.

MCGIDI_pdfsOfXGivenW_sampled

typedef struct MCGIDI_pdfsOfXGivenW_sampled_s MCGIDI_pdfsOfXGivenW_sampled

Definition at line 57 of file MCGIDI.h.

MCGIDI_POP

typedef struct MCGIDI_POP_s MCGIDI_POP

Definition at line 42 of file MCGIDI.h.

MCGIDI_POPs

typedef struct MCGIDI_POPs_s MCGIDI_POPs

Definition at line 43 of file MCGIDI.h.

MCGIDI_product

typedef struct MCGIDI_product_s MCGIDI_product

Definition at line 51 of file MCGIDI.h.

MCGIDI_productInfo

typedef struct MCGIDI_productInfo_s MCGIDI_productInfo

Definition at line 68 of file MCGIDI.h.

MCGIDI_productsInfo

typedef struct MCGIDI_productsInfo_s MCGIDI_productsInfo

Definition at line 67 of file MCGIDI.h.

MCGIDI_reaction

typedef struct MCGIDI_reaction_s MCGIDI_reaction

Definition at line 49 of file MCGIDI.h.

MCGIDI_sampledProductsData

typedef struct MCGIDI_sampledProductsData_s MCGIDI_sampledProductsData

Definition at line 69 of file MCGIDI.h.

MCGIDI_sampledProductsDatas

typedef struct MCGIDI_sampledProductsDatas_s MCGIDI_sampledProductsDatas

Definition at line 70 of file MCGIDI.h.

MCGIDI_samplingMultiplicityBias

typedef struct MCGIDI_samplingMultiplicityBias_s MCGIDI_samplingMultiplicityBias

Definition at line 114 of file MCGIDI.h.

MCGIDI_target

typedef struct MCGIDI_target_s MCGIDI_target

Definition at line 45 of file MCGIDI.h.

MCGIDI_target_heated

typedef struct MCGIDI_target_heated_s MCGIDI_target_heated

Definition at line 48 of file MCGIDI.h.

MCGIDI_target_heated_info

typedef struct MCGIDI_target_heated_info_s MCGIDI_target_heated_info

Definition at line 46 of file MCGIDI.h.

MCGIDI_target_heated_sorted

typedef struct MCGIDI_target_heated_sorted_s MCGIDI_target_heated_sorted

Definition at line 47 of file MCGIDI.h.

transportabilitiesMap

typedef std::map<int, enum GIDI::MCGIDI_transportability> transportabilitiesMap

Definition at line 171 of file MCGIDI.h.

Enumeration Type Documentation

MCGIDI_angularType

enum MCGIDI_angularType

Enumerator
MCGIDI_angularType_isotropic
MCGIDI_angularType_recoil
MCGIDI_angularType_linear

Definition at line 212 of file MCGIDI.h.

{ MCGIDI_angularType_isotropic, MCGIDI_angularType_recoil, MCGIDI_angularType_linear };

MCGIDI_channelGenre

enum MCGIDI_channelGenre

Enumerator
MCGIDI_channelGenre_undefined_e
MCGIDI_channelGenre_twoBody_e
MCGIDI_channelGenre_uncorrelated_e
MCGIDI_channelGenre_sumOfRemaining_e
MCGIDI_channelGenre_twoBodyDecay_e
MCGIDI_channelGenre_uncorrelatedDecay_e

Definition at line 202 of file MCGIDI.h.

                         { MCGIDI_channelGenre_undefined_e, MCGIDI_channelGenre_twoBody_e, MCGIDI_channelGenre_uncorrelated_e, 
    MCGIDI_channelGenre_sumOfRemaining_e, MCGIDI_channelGenre_twoBodyDecay_e, MCGIDI_channelGenre_uncorrelatedDecay_e };

MCGIDI_distributionType

enum MCGIDI_distributionType

Enumerator
MCGIDI_distributionType_none_e
MCGIDI_distributionType_unknown_e
MCGIDI_distributionType_angular_e
MCGIDI_distributionType_KalbachMann_e
MCGIDI_distributionType_uncorrelated_e
MCGIDI_distributionType_energyAngular_e
MCGIDI_distributionType_angularEnergy_e

Definition at line 208 of file MCGIDI.h.

                             { MCGIDI_distributionType_none_e, MCGIDI_distributionType_unknown_e, MCGIDI_distributionType_angular_e, 
    MCGIDI_distributionType_KalbachMann_e, MCGIDI_distributionType_uncorrelated_e, MCGIDI_distributionType_energyAngular_e, 
    MCGIDI_distributionType_angularEnergy_e };

MCGIDI_energyType

enum MCGIDI_energyType

Enumerator
MCGIDI_energyType_unknown
MCGIDI_energyType_primaryGamma
MCGIDI_energyType_discreteGamma
MCGIDI_energyType_linear
MCGIDI_energyType_generalEvaporation
MCGIDI_energyType_simpleMaxwellianFission
MCGIDI_energyType_evaporation
MCGIDI_energyType_Watt
MCGIDI_energyType_MadlandNix
MCGIDI_energyType_NBodyPhaseSpace
MCGIDI_energyType_weightedFunctional

Definition at line 214 of file MCGIDI.h.

                       { MCGIDI_energyType_unknown, MCGIDI_energyType_primaryGamma, MCGIDI_energyType_discreteGamma, 
    MCGIDI_energyType_linear, MCGIDI_energyType_generalEvaporation, MCGIDI_energyType_simpleMaxwellianFission, MCGIDI_energyType_evaporation, 
        MCGIDI_energyType_Watt, MCGIDI_energyType_MadlandNix, MCGIDI_energyType_NBodyPhaseSpace, MCGIDI_energyType_weightedFunctional };

MCGIDI_productMultiplicityType

enum MCGIDI_productMultiplicityType

Enumerator
MCGIDI_productMultiplicityType_invalid_e
MCGIDI_productMultiplicityType_unknown_e
MCGIDI_productMultiplicityType_integer_e
MCGIDI_productMultiplicityType_energyDependent_e
MCGIDI_productMultiplicityType_gammaBranching_e
MCGIDI_productMultiplicityType_mixed_e

Definition at line 205 of file MCGIDI.h.

                                    { MCGIDI_productMultiplicityType_invalid_e, MCGIDI_productMultiplicityType_unknown_e, MCGIDI_productMultiplicityType_integer_e,
    MCGIDI_productMultiplicityType_energyDependent_e, MCGIDI_productMultiplicityType_gammaBranching_e, MCGIDI_productMultiplicityType_mixed_e };

MCGIDI_quantityLookupMode

enum MCGIDI_quantityLookupMode

Enumerator
MCGIDI_quantityLookupMode_pointwise	Pointwise data are used to determine a quantity's value an energy E.
MCGIDI_quantityLookupMode_grouped	Grouped data are used to determine a quantity's value an energy E.

Definition at line 77 of file MCGIDI.h.

                               {      
    MCGIDI_quantityLookupMode_pointwise     /**< Pointwise data are used to determine a quantity's value an energy E. */,
    MCGIDI_quantityLookupMode_grouped       /**< Grouped data are used to determine a quantity's value an energy E. */
};

MCGIDI_reactionType

enum MCGIDI_reactionType

Enumerator
MCGIDI_reactionType_unknown_e
MCGIDI_reactionType_null_e
MCGIDI_reactionType_elastic_e
MCGIDI_reactionType_scattering_e
MCGIDI_reactionType_nuclearIsomerTransmutation_e
MCGIDI_reactionType_nuclearLevelTransition_e
MCGIDI_reactionType_capture_e
MCGIDI_reactionType_fission_e
MCGIDI_reactionType_sumOfRemainingOutputChannels_e
MCGIDI_reactionType_atomic_e

Definition at line 186 of file MCGIDI.h.

                         { 
    MCGIDI_reactionType_unknown_e,                      /* This should never happen. */
    MCGIDI_reactionType_null_e,                         /* Only occurs when sampling with from grouped cross sections and the projectile is below threshold. */
    MCGIDI_reactionType_elastic_e,                      /* A nuclear elastic reaction. */
    MCGIDI_reactionType_scattering_e,                   /* A nuclear reaction where the projectile and target are products as well as gammas, 
                                                            excluding reactions that are MCGIDI_reactionType_elastic_e and 
                                                            MCGIDI_reactionType_nuclearLevelTransition_e. */
    MCGIDI_reactionType_nuclearIsomerTransmutation_e,   /* A nuclear that changes N or Z and is not one of the others.*/
    MCGIDI_reactionType_nuclearLevelTransition_e,       /* Reaction in which the residual is the same isotope as the target but in a
                                                            different nuclear level. Mainly for meta-stables. */
    MCGIDI_reactionType_capture_e,                      /* A nuclear capture reaction. */
    MCGIDI_reactionType_fission_e,                      /* A nuclear fission reaction. */
    MCGIDI_reactionType_sumOfRemainingOutputChannels_e, /* ENDF MT 5 reactions. */
    MCGIDI_reactionType_atomic_e                        
};

MCGIDI_transportability

enum MCGIDI_transportability

Enumerator
MCGIDI_transportability_unknown	This enum is used to give the transportability status for a particle in a reaction or target. Particle is not a product of this reaction or target.
MCGIDI_transportability_none	Particle is a product but has not distribution data.
MCGIDI_transportability_partial	Particle is a product and has some distribution data.
MCGIDI_transportability_full

Definition at line 160 of file MCGIDI.h.

                             {                          /**< This enum is used to give the transportability status for a particle in a reaction or target. */
    MCGIDI_transportability_unknown,                    /**< Particle is not a product of this reaction or target. */
    MCGIDI_transportability_none,                       /**< Particle is a product but has not distribution data. */
    MCGIDI_transportability_partial,                    /**< Particle is a product and has some distribution data. */
    MCGIDI_transportability_full };                     /**< Particle is a product and all needed distribution data. */

Function Documentation

MCGIDI_angular_free()

MCGIDI_angular * MCGIDI_angular_free	(	statusMessageReporting *	smr,
		MCGIDI_angular *	angular
	)

Definition at line 39 of file MCGIDI_angular.cc.

                                                                                            {
 
    MCGIDI_angular_release( smr, angular );
    smr_freeMemory( (void **) &angular );
    return( NULL );
}

Referenced by MCGIDI_angular_new(), MCGIDI_angular_parseFromTOM(), MCGIDI_distribution_release(), and MCGIDI_LLNLAngular_angularEnergy_parseFromTOM().

MCGIDI_angular_initialize()

int MCGIDI_angular_initialize	(	statusMessageReporting *	smr,
		MCGIDI_angular *	angular
	)

Definition at line 31 of file MCGIDI_angular.cc.

                                                                                     {
 
    memset( angular, 0, sizeof( MCGIDI_angular ) );
    return( 0 );
}

Referenced by MCGIDI_angular_new(), and MCGIDI_angular_release().

MCGIDI_angular_new()

MCGIDI_angular * MCGIDI_angular_new

(

statusMessageReporting *

smr

)

Definition at line 20 of file MCGIDI_angular.cc.

                                                                  {
 
    MCGIDI_angular *angular;
 
    if( ( angular = (MCGIDI_angular *) smr_malloc2( smr, sizeof( MCGIDI_angular ), 0, "angular" ) ) == NULL ) return( NULL );
    if( MCGIDI_angular_initialize( smr, angular ) ) angular = MCGIDI_angular_free( smr, angular );
    return( angular );
}

Referenced by MCGIDI_angular_parseFromTOM().

MCGIDI_angular_parseFromTOM()

int MCGIDI_angular_parseFromTOM	(	statusMessageReporting *	smr,
		xDataTOM_element *	element,
		MCGIDI_distribution *	distribution,
		ptwXYPoints *	norms
	)

Definition at line 72 of file MCGIDI_angular.cc.

                                                                                                                                                 {
 
    MCGIDI_angular *angular = NULL;
    xDataTOM_element *angularElement, *linearElement, *frameElement = NULL;
    char const *nativeData;
    ptwXYPoints *pdfXY = NULL;
    ptwXPoints *cdfX = NULL;
    ptwXY_interpolation interpolationXY, interpolationWY;
 
    if( ( angularElement = xDataTOME_getOneElementByName( smr, element, "angular", 1 ) ) == NULL ) goto err;
    if( ( angular = MCGIDI_angular_new( smr ) ) == NULL ) goto err;
 
    if( ( nativeData = xDataTOM_getAttributesValueInElement( angularElement, "nativeData" ) ) == NULL ) goto err;
    if( strcmp( nativeData, "isotropic" ) == 0 ) {
        if( ( frameElement = xDataTOME_getOneElementByName( smr, angularElement, "isotropic", 1 ) ) == NULL ) {
            smr_setReportError2( smr, smr_unknownID, 1, "angular type missing for nativeData = '%s'", nativeData );
            goto err;
        }
        angular->type = MCGIDI_angularType_isotropic; }
    else if( strcmp( nativeData, "recoil" ) == 0 ) {            /* BRB. Needs work to get referenced product data?????? */
        angular->type = MCGIDI_angularType_recoil; }
    else {
        int i, j, n;
        double norm, energyFactor;
        nfu_status status;
        xDataTOM_XYs *XYs;
        xDataTOM_W_XYs *W_XYs;
        ptwXYPoint *point;
        MCGIDI_pdfsOfXGivenW *dists = &(angular->dists);
        MCGIDI_pdfOfX *dist;
        char const *energyUnit, *multiplicityProbabilityUnits[2] = { "", "" };
 
        if( ( linearElement = xDataTOME_getOneElementByName( NULL, angularElement, "linear", 0 ) ) == NULL ) {
            if( ( linearElement = xDataTOME_getOneElementByName( smr, angularElement, "pointwise", 1 ) ) == NULL ) {
                smr_setReportError2( smr, smr_unknownID, 1, "unsupported angular type: nativeData = '%s'", nativeData );
                goto err;
            }
        }
        frameElement = linearElement;
 
        if( MCGIDI_fromTOM_interpolation( smr, linearElement, 0, &interpolationWY ) ) goto err;
        if( MCGIDI_fromTOM_interpolation( smr, linearElement, 1, &interpolationXY ) ) goto err;
        dists->interpolationWY = interpolationWY;
        dists->interpolationXY = interpolationXY;
 
        if( ( W_XYs = (xDataTOM_W_XYs *) xDataTOME_getXDataIfID( smr, linearElement, "W_XYs" ) ) == NULL ) goto err;
        if( ( dists->Ws = (double *) smr_malloc2( smr, W_XYs->length * sizeof( double ), 1, "dists->Ws" ) ) == NULL ) goto err;
        if( ( dists->dist = (MCGIDI_pdfOfX *) smr_malloc2( smr, W_XYs->length * sizeof( MCGIDI_pdfOfX ), 0, "dists->dist" ) ) == NULL ) goto err;
 
        energyUnit = xDataTOM_subAxes_getUnit( smr, &(W_XYs->subAxes), 0 );
        if( !smr_isOk( smr ) ) goto err;
        energyFactor = MCGIDI_misc_getUnitConversionFactor( smr, energyUnit, "MeV" );
        if( !smr_isOk( smr ) ) goto err;
 
        for( i = 0; i < W_XYs->length; i++ ) {
            XYs = &(W_XYs->XYs[i]);
            dist = &(dists->dist[i]);
            dists->Ws[i] = XYs->value * energyFactor;
            if( ( pdfXY = MCGIDI_misc_dataFromXYs2ptwXYPointsInUnitsOf( smr, XYs, interpolationXY, multiplicityProbabilityUnits ) ) == NULL ) goto err;
            if( ptwXY_simpleCoalescePoints( pdfXY ) != nfu_Okay ) goto err;
            dist->numberOfXs = n = (int) ptwXY_length( pdfXY );
 
            if( ( dist->Xs = (double *) smr_malloc2( smr, 3 * n * sizeof( double ), 0, "dist->Xs" ) ) == NULL ) goto err;
            dists->numberOfWs++;
            dist->pdf = &(dist->Xs[n]);
            dist->cdf = &(dist->pdf[n]);
 
            for( j = 0; j < n; j++ ) {
                point = ptwXY_getPointAtIndex_Unsafely( pdfXY, j );
                dist->Xs[j] = point->x;
                dist->pdf[j] = point->y;
            }
 
            if( ( cdfX = ptwXY_runningIntegral( pdfXY, &status ) ) == NULL ) {
                smr_setReportError2( smr, smr_unknownID, 1, "ptwXY_runningIntegral err = %d: %s\n", status, nfu_statusMessage( status ) );
                goto err;
            }
            norm = ptwX_getPointAtIndex_Unsafely( cdfX, n - 1 );
            if( norms != NULL ) {
                ptwXY_setValueAtX( norms, XYs->value, norm ); }
            else if( std::fabs( 1. - norm ) > 0.99 ) {
                smr_setReportError2( smr, smr_unknownID, 1, "bad norm = %e for angular.linear data", norm );
                goto err;
            }
            for( j = 0; j < n; j++ ) dist->cdf[j] = ptwX_getPointAtIndex_Unsafely( cdfX, j ) / norm;
            for( j = 0; j < n; j++ ) dist->pdf[j] /= norm;
            pdfXY = ptwXY_free( pdfXY );
            cdfX = ptwX_free( cdfX );
        }
        angular->type = MCGIDI_angularType_linear;
    }
 
    if( frameElement != NULL ) {
        if( ( angular->frame = MCGIDI_misc_getProductFrame( smr, frameElement ) ) == xDataTOM_frame_invalid ) goto err;
    }
 
    distribution->angular = angular;
    distribution->type = MCGIDI_distributionType_angular_e;
 
    return( 0 );
 
err:
    if( pdfXY != NULL ) ptwXY_free( pdfXY );
    if( cdfX != NULL ) cdfX = ptwX_free( cdfX );
    if ( angular != NULL ) MCGIDI_angular_free( smr, angular );
    return( 1 );
}

Referenced by MCGIDI_distribution_parseFromTOM(), MCGIDI_LLNLAngular_angularEnergy_parseFromTOM(), and MCGIDI_uncorrelated_parseFromTOM().

MCGIDI_angular_release()

int MCGIDI_angular_release	(	statusMessageReporting *	smr,
		MCGIDI_angular *	angular
	)

Definition at line 48 of file MCGIDI_angular.cc.

                                                                                   {
 
 
    MCGIDI_sampling_pdfsOfXGivenW_release( smr, &(angular->dists) );
 
    MCGIDI_angular_initialize( smr, angular );
    return( 0 );
}

Referenced by MCGIDI_angular_free().

MCGIDI_angular_sampleMu()

int MCGIDI_angular_sampleMu	(	statusMessageReporting *	smr,
		MCGIDI_angular *	angular,
		MCGIDI_quantitiesLookupModes &	modes,
		MCGIDI_decaySamplingInfo *	decaySamplingInfo
	)

Definition at line 182 of file MCGIDI_angular.cc.

                                                      {
 
    double randomMu = decaySamplingInfo->rng( decaySamplingInfo->rngState );
    MCGIDI_pdfsOfXGivenW_sampled sampled;
 
    switch( angular->type ) {
    case MCGIDI_angularType_isotropic :
        decaySamplingInfo->frame = angular->frame;
        decaySamplingInfo->mu = 1. - 2. * decaySamplingInfo->rng( decaySamplingInfo->rngState );
        break;
    case MCGIDI_angularType_linear :
        decaySamplingInfo->frame = angular->frame;
        sampled.smr = smr;
        sampled.w = modes.getProjectileEnergy( );
        MCGIDI_sampling_sampleX_from_pdfsOfXGivenW( &(angular->dists), &sampled, randomMu );
        decaySamplingInfo->mu = sampled.x;
        break;
    case MCGIDI_angularType_recoil :
    default :
        smr_setReportError2( smr, smr_unknownID, 1, "angular type = %d not supported", angular->type );
    }
    return( !smr_isOk( smr ) );
}

Referenced by MCGIDI_outputChannel_sampleProductsAtE(), MCGIDI_product_sampleMu(), and MCGIDI_uncorrelated_sampleDistribution().

MCGIDI_angular_setTwoBodyMasses()

int MCGIDI_angular_setTwoBodyMasses	(	statusMessageReporting *	smr,
		MCGIDI_angular *	angular,
		double	projectileMass_MeV,
		double	targetMass_MeV,
		double	productMass_MeV,
		double	residualMass_MeV
	)

Definition at line 59 of file MCGIDI_angular.cc.

                                                      {
 
    if( angular == NULL ) return( 0 );         /* ???????? This needs work. Happens when first product of a two-body reaction as no distribution. */
    angular->projectileMass_MeV = projectileMass_MeV;
    angular->targetMass_MeV = targetMass_MeV;
    angular->productMass_MeV = productMass_MeV;
    angular->residualMass_MeV = residualMass_MeV;
    return( 0 );
}

Referenced by MCGIDI_product_setTwoBodyMasses().

MCGIDI_angularEnergy_free()

MCGIDI_angularEnergy * MCGIDI_angularEnergy_free	(	statusMessageReporting *	smr,
		MCGIDI_angularEnergy *	energyAngular
	)

Definition at line 40 of file MCGIDI_angularEnergy.cc.

                                                                                                                    {
 
    MCGIDI_angularEnergy_release( smr, angularEnergy );
    smr_freeMemory( (void **) &angularEnergy );
    return( NULL );
}

Referenced by MCGIDI_angularEnergy_new(), and MCGIDI_distribution_release().

MCGIDI_angularEnergy_initialize()

int MCGIDI_angularEnergy_initialize	(	statusMessageReporting *	smr,
		MCGIDI_angularEnergy *	energyAngular
	)

Definition at line 32 of file MCGIDI_angularEnergy.cc.

                                                                                                       {
 
    memset( angularEnergy, 0, sizeof( MCGIDI_angularEnergy ) );
    return( 0 );
}

Referenced by MCGIDI_angularEnergy_new(), and MCGIDI_angularEnergy_release().

MCGIDI_angularEnergy_new()

MCGIDI_angularEnergy * MCGIDI_angularEnergy_new

(

statusMessageReporting *

smr

)

Definition at line 21 of file MCGIDI_angularEnergy.cc.

                                                                              {
 
    MCGIDI_angularEnergy *angularEnergy;
 
    if( ( angularEnergy = (MCGIDI_angularEnergy *) smr_malloc2( smr, sizeof( MCGIDI_angularEnergy ), 0, "angularEnergy" ) ) == NULL ) return( NULL );
    if( MCGIDI_angularEnergy_initialize( smr, angularEnergy ) ) angularEnergy = MCGIDI_angularEnergy_free( smr, angularEnergy );
    return( angularEnergy );
}

MCGIDI_angularEnergy_parseFromTOM()

int MCGIDI_angularEnergy_parseFromTOM	(	statusMessageReporting *	smr,
		xDataTOM_element *	element,
		MCGIDI_distribution *	distribution
	)

Definition at line 65 of file MCGIDI_angularEnergy.cc.

                                                                                                                                   {
 
    xDataTOM_element *angularEnergyElement, *pointwise = NULL;
    char const *nativeData;
 
    if( ( angularEnergyElement = xDataTOME_getOneElementByName( smr, element, "angularEnergy", 1 ) ) == NULL ) goto err;
 
    if( ( nativeData = xDataTOM_getAttributesValueInElement( angularEnergyElement, "nativeData" ) ) == NULL ) goto err;
    if( strcmp( nativeData, "pointwise" ) == 0 ) {
        if( ( pointwise = xDataTOME_getOneElementByName( smr, angularEnergyElement, "pointwise", 1 ) ) == NULL ) goto err; }
    else if( strcmp( nativeData, "linear" ) == 0 ) {
        if( ( pointwise = xDataTOME_getOneElementByName( smr, angularEnergyElement, "linear", 1 ) ) == NULL ) goto err; }
    else {
        smr_setReportError2( smr, smr_unknownID, 1, "angularEnergy nativeData = '%s' not supported", nativeData );
        goto err;
    }
    if( pointwise != NULL ) return( MCGIDI_angularEnergy_parsePointwiseFromTOM( smr, pointwise, distribution ) );
 
    return( 0 );
 
err:
    return( 1 );
}

Referenced by MCGIDI_distribution_parseFromTOM().

MCGIDI_angularEnergy_release()

int MCGIDI_angularEnergy_release	(	statusMessageReporting *	smr,
		MCGIDI_angularEnergy *	energyAngular
	)

Definition at line 49 of file MCGIDI_angularEnergy.cc.

                                                                                                     {
 
    int i;
 
    for( i = 0; i < angularEnergy->pdfOfMuGivenE.numberOfWs; i++ ) {
        MCGIDI_sampling_pdfsOfXGivenW_release( smr, &(angularEnergy->pdfOfEpGivenEAndMu[i]) );
    }
    smr_freeMemory( (void **) &(angularEnergy->pdfOfEpGivenEAndMu) );
    MCGIDI_sampling_pdfsOfXGivenW_release( smr, &(angularEnergy->pdfOfMuGivenE) );
    MCGIDI_angularEnergy_initialize( smr, angularEnergy );
 
    return( 0 );
}

Referenced by MCGIDI_angularEnergy_free().

MCGIDI_angularEnergy_sampleDistribution()

int MCGIDI_angularEnergy_sampleDistribution	(	statusMessageReporting *	smr,
		MCGIDI_angularEnergy *	angularEnergy,
		MCGIDI_quantitiesLookupModes &	modes,
		MCGIDI_decaySamplingInfo *	decaySamplingInfo
	)

Definition at line 175 of file MCGIDI_angularEnergy.cc.

                                                      {
 
    int status = MCGIDI_sampling_doubleDistribution( smr, &(angularEnergy->pdfOfMuGivenE), angularEnergy->pdfOfEpGivenEAndMu, modes, decaySamplingInfo );
 
    decaySamplingInfo->frame = angularEnergy->frame;
    return( status );
}

Referenced by MCGIDI_outputChannel_sampleProductsAtE().

MCGIDI_distribution_free()

MCGIDI_distribution * MCGIDI_distribution_free	(	statusMessageReporting *	smr,
		MCGIDI_distribution *	distribution
	)

Definition at line 38 of file MCGIDI_distribution.cc.

                                                                                                                {
 
    MCGIDI_distribution_release( smr, distribution );
    smr_freeMemory( (void **) &distribution );
    return( NULL );
}

Referenced by MCGIDI_distribution_new().

MCGIDI_distribution_initialize()

int MCGIDI_distribution_initialize	(	statusMessageReporting *	smr,
		MCGIDI_distribution *	distribution
	)

Definition at line 30 of file MCGIDI_distribution.cc.

                                                                                                    {
 
    memset( distribution, 0, sizeof( MCGIDI_distribution ) );
    return( 0 );
}

Referenced by MCGIDI_distribution_new(), MCGIDI_distribution_parseFromTOM(), and MCGIDI_distribution_release().

MCGIDI_distribution_new()

MCGIDI_distribution * MCGIDI_distribution_new

(

statusMessageReporting *

smr

)

Definition at line 19 of file MCGIDI_distribution.cc.

                                                                            {
 
    MCGIDI_distribution *distribution;
 
    if( ( distribution = (MCGIDI_distribution *) smr_malloc2( smr, sizeof( MCGIDI_distribution ), 0, "distribution" ) ) == NULL ) return( NULL );
    if( MCGIDI_distribution_initialize( smr, distribution ) ) distribution = MCGIDI_distribution_free( smr, distribution );
    return( distribution );
}

MCGIDI_distribution_parseFromTOM()

int MCGIDI_distribution_parseFromTOM	(	statusMessageReporting *	smr,
		xDataTOM_element *	element,
		MCGIDI_product *	product,
		MCGIDI_POPs *	pops,
		ptwXYPoints *	norms
	)

Definition at line 61 of file MCGIDI_distribution.cc.

                                                                                                                                                             {
 
    char const *nativeData, *gammaEnergy;
    double gammaEnergy_MeV;
    MCGIDI_distribution *distribution = &(product->distribution);
    xDataTOM_element *distributionElement;
    enum MCGIDI_energyType energyType = MCGIDI_energyType_unknown;
 
    MCGIDI_distribution_initialize( smr, distribution );
 
    distribution->product = product;
    if( ( distributionElement = xDataTOME_getOneElementByName( smr, element, "distributions", 1 ) ) == NULL ) goto err;
    if( ( nativeData = xDataTOM_getAttributesValueInElement( distributionElement, "nativeData" ) ) == NULL ) goto err;
 
    if( strcmp( product->pop->name, "gamma" ) == 0 ) {
        if( ( gammaEnergy = xDataTOM_getAttributesValueInElement( element, "discrete" ) ) != NULL ) {
            if( MCGIDI_misc_PQUStringToDoubleInUnitOf( smr, gammaEnergy, "MeV", &gammaEnergy_MeV ) ) goto err;
            energyType = MCGIDI_energyType_discreteGamma; }
        else if( ( gammaEnergy = xDataTOM_getAttributesValueInElement( element, "primary" ) ) != NULL ) {
            if( MCGIDI_misc_PQUStringToDoubleInUnitOf( smr, gammaEnergy, "MeV", &gammaEnergy_MeV ) ) goto err;
            energyType = MCGIDI_energyType_primaryGamma;
        }
        if( gammaEnergy != NULL ) {
            if( strcmp( nativeData, "angular" ) ) {
                smr_setReportError2( smr, smr_unknownID, 1, "%s gamma can only have a distribution with 'nativeData' = 'angular' and not '%s'",
                    gammaEnergy, nativeData );
                goto err;
            }
            nativeData = "uncorrelated";
        }
    }
 
    if( strcmp( nativeData, "angular" ) == 0 ) {
        if( MCGIDI_angular_parseFromTOM( smr, distributionElement, distribution, norms ) ) goto err; }
    else if( strcmp( nativeData, "uncorrelated" ) == 0 ) {
        if( MCGIDI_uncorrelated_parseFromTOM( smr, distributionElement, distribution, norms, energyType, gammaEnergy_MeV ) ) goto err; }
    else if( strcmp( nativeData, "energyAngular" ) == 0 ) {
        if( MCGIDI_energyAngular_parseFromTOM( smr, distributionElement, distribution ) ) goto err; }
    else if( strcmp( nativeData, "angularEnergy" ) == 0 ) {
        if( MCGIDI_angularEnergy_parseFromTOM( smr, distributionElement, distribution ) ) goto err; }
    else if( strcmp( nativeData, "Legendre" ) == 0 ) {
        if( MCGIDI_energyAngular_parseFromTOM( smr, distributionElement, distribution ) ) goto err; }
    else if( strcmp( nativeData, "LLNLAngular_angularEnergy" ) == 0 ) {
        if( MCGIDI_LLNLAngular_angularEnergy_parseFromTOM( smr, distributionElement, distribution ) ) goto err; }
    else if( strcmp( nativeData, "none" ) == 0 ) {
        distribution->type = MCGIDI_distributionType_none_e; }
    else if( strcmp( nativeData, "unknown" ) == 0 ) {
        distribution->type = MCGIDI_distributionType_unknown_e; }
    else {
        smr_setReportError2( smr, smr_unknownID, 1, "Unsupported distribution = '%s'\n", nativeData );
        goto err;
    }
 
    return( 0 );
 
err:
    MCGIDI_distribution_release( smr, distribution );
    return( 1 );
}

Referenced by MCGIDI_product_parseFromTOM().

MCGIDI_distribution_release()

int MCGIDI_distribution_release	(	statusMessageReporting *	smr,
		MCGIDI_distribution *	distribution
	)

Definition at line 47 of file MCGIDI_distribution.cc.

                                                                                                  {
 
    if( distribution->angular ) distribution->angular = MCGIDI_angular_free( smr, distribution->angular );
    if( distribution->energy ) distribution->energy = MCGIDI_energy_free( smr, distribution->energy );
    if( distribution->KalbachMann ) distribution->KalbachMann = MCGIDI_KalbachMann_free( smr, distribution->KalbachMann );    
    if( distribution->energyAngular ) distribution->energyAngular = MCGIDI_energyAngular_free( smr, distribution->energyAngular );
    if( distribution->angularEnergy ) distribution->angularEnergy = MCGIDI_angularEnergy_free( smr, distribution->angularEnergy );
 
    MCGIDI_distribution_initialize( smr, distribution );
    return( 0 );
}

Referenced by MCGIDI_distribution_free(), MCGIDI_distribution_parseFromTOM(), and MCGIDI_product_release().

MCGIDI_energy_free()

MCGIDI_energy * MCGIDI_energy_free	(	statusMessageReporting *	smr,
		MCGIDI_energy *	energy
	)

Definition at line 65 of file MCGIDI_energy.cc.

                                                                                        {
 
    MCGIDI_energy_release( smr, energy );
    smr_freeMemory( (void **) &energy );
    return( NULL );
}

Referenced by MCGIDI_distribution_release(), MCGIDI_energy_new(), MCGIDI_energy_parseFromTOM(), and MCGIDI_energy_release().

MCGIDI_energy_initialize()

int MCGIDI_energy_initialize	(	statusMessageReporting *	smr,
		MCGIDI_energy *	energy
	)

Definition at line 57 of file MCGIDI_energy.cc.

                                                                                  {
 
    memset( energy, 0, sizeof( MCGIDI_energy ) );
    return( 0 );
}

Referenced by MCGIDI_energy_new(), and MCGIDI_energy_release().

MCGIDI_energy_new()

MCGIDI_energy * MCGIDI_energy_new

(

statusMessageReporting *

smr

)

Definition at line 46 of file MCGIDI_energy.cc.

                                                                {
 
    MCGIDI_energy *energy;
 
    if( ( energy = (MCGIDI_energy *) smr_malloc2( smr, sizeof( MCGIDI_energy ), 0, "energy" ) ) == NULL ) return( NULL );
    if( MCGIDI_energy_initialize( smr, energy ) ) energy = MCGIDI_energy_free( smr, energy );
    return( energy );
}

Referenced by MCGIDI_energy_parseFromTOM().

MCGIDI_energy_parseFromTOM()

int MCGIDI_energy_parseFromTOM	(	statusMessageReporting *	smr,
		xDataTOM_element *	element,
		MCGIDI_distribution *	distribution,
		ptwXYPoints *	norms,
		enum MCGIDI_energyType	energyType,
		double	gammaEnergy_MeV
	)

Definition at line 97 of file MCGIDI_energy.cc.

                                                                    {
 
    MCGIDI_energy *energy = NULL;
    xDataTOM_element *energyElement, *linearElement, *functional, *frameElement;
    char const *nativeData;
    double projectileMass_MeV, targetMass_MeV;
 
    if( ( energy = MCGIDI_energy_new( smr ) ) == NULL ) goto err;
 
    projectileMass_MeV = MCGIDI_product_getProjectileMass_MeV( smr, distribution->product );
    targetMass_MeV = MCGIDI_product_getTargetMass_MeV( smr, distribution->product );
    energy->e_inCOMFactor = targetMass_MeV / ( projectileMass_MeV + targetMass_MeV );
 
    if( ( energyType == MCGIDI_energyType_primaryGamma ) || ( energyType == MCGIDI_energyType_discreteGamma ) ) {
        energy->type = energyType;
        energy->gammaEnergy_MeV = gammaEnergy_MeV;
        energy->frame = xDataTOM_frame_lab;            /* BRB. This should not be hardwired?????? Probably needs to be changed in GND also. */
        if( energyType == MCGIDI_energyType_primaryGamma ) energy->primaryGammaMassFactor = energy->e_inCOMFactor; }
    else {
        if( ( energyElement = xDataTOME_getOneElementByName( smr, element, "energy", 1 ) ) == NULL ) goto err;
        if( ( nativeData = xDataTOM_getAttributesValueInElement( energyElement, "nativeData" ) ) == NULL ) goto err;
        if( ( linearElement = xDataTOME_getOneElementByName( NULL, energyElement, "linear", 0 ) ) == NULL ) 
            linearElement = xDataTOME_getOneElementByName( NULL, energyElement, "pointwise", 0 );
        if( linearElement == NULL ) {
            if( ( functional = xDataTOME_getOneElementByName( NULL, energyElement, "generalEvaporation", 0 ) ) != NULL ) {
                if( MCGIDI_energy_parseGeneralEvaporationFromTOM( smr, functional, energy ) ) goto err; }
            else if( ( functional = xDataTOME_getOneElementByName( NULL, energyElement, "simpleMaxwellianFission", 0 ) ) != NULL ) {
                if( MCGIDI_energy_parseSimpleMaxwellianFissionFromTOM( smr, functional, energy ) ) goto err; }
            else if( ( functional = xDataTOME_getOneElementByName( NULL, energyElement, "evaporation", 0 ) ) != NULL ) {
                if( MCGIDI_energy_parseEvaporationFromTOM( smr, functional, energy ) ) goto err; }
            else if( ( functional = xDataTOME_getOneElementByName( NULL, energyElement, "Watt", 0 ) ) != NULL ) {
                if( MCGIDI_energy_parseWattFromTOM( smr, functional, energy ) ) goto err; }
            else if( ( functional = xDataTOME_getOneElementByName( NULL, energyElement, "MadlandNix", 0 ) ) != NULL ) {
                if( MCGIDI_energy_parseMadlandNixFromTOM( smr, functional, energy ) ) goto err; }
            else if( ( functional = xDataTOME_getOneElementByName( NULL, energyElement, "NBodyPhaseSpace", 0 ) ) != NULL ) {
                if( MCGIDI_energy_parseNBodyPhaseSpaceFromTOM( smr, functional, energy, distribution ) ) goto err; }
            else if( ( functional = xDataTOME_getOneElementByName( NULL, energyElement, "weightedFunctionals", 0 ) ) != NULL ) {
                if( MCGIDI_energy_parseWeightedFunctionalsFromTOM( smr, functional, energy ) ) goto err; }
            else {
                smr_setReportError2( smr, smr_unknownID, 1, "unsupported energy type: nativeData = '%s'", nativeData );
                goto err;
            }
            frameElement = functional; }
        else {
            char const *toUnits[3] = { "MeV", "MeV", "1/MeV" };
 
            frameElement = linearElement;
            if( MCGIDI_fromTOM_pdfsOfXGivenW( smr, linearElement, &(energy->dists), norms, toUnits ) ) goto err;
            energy->type = MCGIDI_energyType_linear;
        }
        if( ( energy->frame = MCGIDI_misc_getProductFrame( smr, frameElement ) ) == xDataTOM_frame_invalid ) goto err;
    }
    distribution->energy = energy;
 
    return( 0 );
 
err:
    if( energy != NULL ) MCGIDI_energy_free( smr, energy );
    return( 1 );
}

Referenced by MCGIDI_uncorrelated_parseFromTOM().

MCGIDI_energy_release()

int MCGIDI_energy_release	(	statusMessageReporting *	smr,
		MCGIDI_energy *	energy
	)

Definition at line 74 of file MCGIDI_energy.cc.

                                                                                {
 
    int i;
 
    MCGIDI_sampling_pdfsOfXGivenW_release( smr, &(energy->dists) );
    if( energy->theta ) energy->theta = ptwXY_free( energy->theta );
    if( energy->Watt_a ) energy->Watt_a = ptwXY_free( energy->Watt_a );
    if( energy->Watt_b ) energy->Watt_b = ptwXY_free( energy->Watt_b );
    if( ( energy->type == MCGIDI_energyType_generalEvaporation ) || ( energy->type == MCGIDI_energyType_NBodyPhaseSpace ) ) {
        MCGIDI_sampling_pdfsOfX_release( smr, &(energy->g) ); }
    else if( energy->type == MCGIDI_energyType_weightedFunctional ) {
        for( i = 0; i < energy->weightedFunctionals.numberOfWeights; i++ ) {
            ptwXY_free( energy->weightedFunctionals.weightedFunctional[i].weight );
            MCGIDI_energy_free( smr, energy->weightedFunctionals.weightedFunctional[i].energy );
        }
    }
 
    MCGIDI_energy_initialize( smr, energy );
    return( 0 );
}

Referenced by MCGIDI_energy_free().

MCGIDI_energy_sampleEnergy()

int MCGIDI_energy_sampleEnergy	(	statusMessageReporting *	smr,
		MCGIDI_energy *	energy,
		MCGIDI_quantitiesLookupModes &	modes,
		MCGIDI_decaySamplingInfo *	decaySamplingInfo
	)

Definition at line 498 of file MCGIDI_energy.cc.

                                                      {
/*
*   This function must be called before angular sampling as it sets the frame but does not test it.
*/
    double theta, randomEp, Watt_a, Watt_b, e_in = modes.getProjectileEnergy( );
    MCGIDI_pdfsOfXGivenW_sampled sampled;
 
    decaySamplingInfo->frame = energy->frame;
    switch( energy->type ) {
    case MCGIDI_energyType_primaryGamma :
        decaySamplingInfo->Ep = energy->gammaEnergy_MeV + e_in * energy->primaryGammaMassFactor;
        break;
    case MCGIDI_energyType_discreteGamma :
        decaySamplingInfo->Ep = energy->gammaEnergy_MeV;
        break;
    case MCGIDI_energyType_linear :
        randomEp = decaySamplingInfo->rng( decaySamplingInfo->rngState );
        sampled.smr = smr;
        sampled.w = e_in;
        MCGIDI_sampling_sampleX_from_pdfsOfXGivenW( &(energy->dists), &sampled, randomEp );
        decaySamplingInfo->Ep = sampled.x;
        break;
    case MCGIDI_energyType_generalEvaporation :
        sampled.interpolationXY = energy->gInterpolation;
        MCGIDI_sampling_sampleX_from_pdfOfX( &(energy->g), &sampled, decaySamplingInfo->rng( decaySamplingInfo->rngState ) );
        theta = MCGIDI_sampling_ptwXY_getValueAtX( energy->theta, e_in );
        decaySamplingInfo->Ep = theta * sampled.x;
        break;
    case MCGIDI_energyType_simpleMaxwellianFission :
        theta = MCGIDI_sampling_ptwXY_getValueAtX( energy->theta, e_in );
        MCGIDI_energy_sampleSimpleMaxwellianFission( smr, ( e_in - energy->U ) / theta, decaySamplingInfo );
        decaySamplingInfo->Ep *= theta;
        break;
    case MCGIDI_energyType_evaporation :
        theta = MCGIDI_sampling_ptwXY_getValueAtX( energy->theta, e_in );
        MCGIDI_energy_sampleEvaporation( smr, ( e_in - energy->U ) / theta, decaySamplingInfo );
        decaySamplingInfo->Ep *= theta;
        break;
    case MCGIDI_energyType_Watt :
        Watt_a = MCGIDI_sampling_ptwXY_getValueAtX( energy->Watt_a, e_in );
        Watt_b = MCGIDI_sampling_ptwXY_getValueAtX( energy->Watt_b, e_in );
        MCGIDI_energy_sampleWatt( smr, e_in - energy->U, Watt_a, Watt_b, decaySamplingInfo );
        break;
    case MCGIDI_energyType_MadlandNix :
        MCGIDI_sampling_sampleX_from_pdfsOfXGivenW( &(energy->dists), &sampled, decaySamplingInfo->rng( decaySamplingInfo->rngState ) );
        decaySamplingInfo->Ep = sampled.x;
        break;
    case MCGIDI_energyType_NBodyPhaseSpace :
        MCGIDI_sampling_sampleX_from_pdfOfX( &(energy->g), &sampled, decaySamplingInfo->rng( decaySamplingInfo->rngState ) );
        decaySamplingInfo->Ep = ( energy->e_inCOMFactor * e_in + energy->NBodyPhaseSpace.Q_MeV ) * energy->NBodyPhaseSpace.massFactor * sampled.x;
        break;
    case MCGIDI_energyType_weightedFunctional :
        MCGIDI_energy_sampleWeightedFunctional( smr, energy, modes, decaySamplingInfo );
        break;
    default :
        smr_setReportError2( smr, smr_unknownID, 1, "energy type = %d not supported", energy->type );
    }
 
    return( !smr_isOk( smr ) );
}

Referenced by MCGIDI_uncorrelated_sampleDistribution().

MCGIDI_energyAngular_free()

MCGIDI_energyAngular * MCGIDI_energyAngular_free	(	statusMessageReporting *	smr,
		MCGIDI_energyAngular *	energyAngular
	)

Definition at line 39 of file MCGIDI_energyAngular.cc.

                                                                                                                    {
 
    MCGIDI_energyAngular_release( smr, energyAngular );
    smr_freeMemory( (void **) &energyAngular );
    return( NULL );
}

Referenced by MCGIDI_distribution_release(), and MCGIDI_energyAngular_new().

MCGIDI_energyAngular_initialize()

int MCGIDI_energyAngular_initialize	(	statusMessageReporting *	smr,
		MCGIDI_energyAngular *	energyAngular
	)

Definition at line 31 of file MCGIDI_energyAngular.cc.

                                                                                                       {
 
    memset( energyAngular, 0, sizeof( MCGIDI_energyAngular ) );
    return( 0 );
}

Referenced by MCGIDI_energyAngular_new(), and MCGIDI_energyAngular_release().

MCGIDI_energyAngular_new()

MCGIDI_energyAngular * MCGIDI_energyAngular_new

(

statusMessageReporting *

smr

)

Definition at line 20 of file MCGIDI_energyAngular.cc.

                                                                              {
 
    MCGIDI_energyAngular *energyAngular;
 
    if( ( energyAngular = (MCGIDI_energyAngular *) smr_malloc2( smr, sizeof( MCGIDI_energyAngular ), 0, "energyAngular" ) ) == NULL ) return( NULL );
    if( MCGIDI_energyAngular_initialize( smr, energyAngular ) ) energyAngular = MCGIDI_energyAngular_free( smr, energyAngular );
    return( energyAngular );
}

MCGIDI_energyAngular_parseFromTOM()

int MCGIDI_energyAngular_parseFromTOM	(	statusMessageReporting *	smr,
		xDataTOM_element *	element,
		MCGIDI_distribution *	distribution
	)

Definition at line 64 of file MCGIDI_energyAngular.cc.

                                                                                                                                   {
 
    xDataTOM_element *energyAngularElement;
    char const *nativeData;
 
    if( ( energyAngularElement = xDataTOME_getOneElementByName( smr, element, "energyAngular", 1 ) ) == NULL ) goto err;
 
    if( ( nativeData = xDataTOM_getAttributesValueInElement( energyAngularElement, "nativeData" ) ) == NULL ) goto err;
    if( strcmp( nativeData, "KalbachMann" ) == 0 ) {
        return( MCGIDI_KalbachMann_parseFromTOM( smr, energyAngularElement, distribution ) ); }
    else if( strcmp( nativeData, "linear" ) == 0 ) {
        return( MCGIDI_energyAngular_linear_parseFromTOM( smr, energyAngularElement, distribution ) ); }
    else {
        smr_setReportError2( smr, smr_unknownID, 1, "energyAngular nativeData = '%s' not supported", nativeData );
        goto err;
    }
 
    return( 0 );
 
err:
    return( 1 );
}

Referenced by MCGIDI_distribution_parseFromTOM().

MCGIDI_energyAngular_release()

int MCGIDI_energyAngular_release	(	statusMessageReporting *	smr,
		MCGIDI_energyAngular *	energyAngular
	)

Definition at line 48 of file MCGIDI_energyAngular.cc.

                                                                                                     {
 
    int i;
 
    for( i = 0; i < energyAngular->pdfOfEpGivenE.numberOfWs; i++ ) {
        MCGIDI_sampling_pdfsOfXGivenW_release( smr, &(energyAngular->pdfOfMuGivenEAndEp[i]) );
    }
    smr_freeMemory( (void **) &(energyAngular->pdfOfMuGivenEAndEp) );
    MCGIDI_sampling_pdfsOfXGivenW_release( smr, &(energyAngular->pdfOfEpGivenE) );
    MCGIDI_energyAngular_initialize( smr, energyAngular );
 
    return( 0 );
}

Referenced by MCGIDI_energyAngular_free().

MCGIDI_energyAngular_sampleDistribution()

int MCGIDI_energyAngular_sampleDistribution	(	statusMessageReporting *	smr,
		MCGIDI_distribution *	distribution,
		MCGIDI_quantitiesLookupModes &	modes,
		MCGIDI_decaySamplingInfo *	decaySamplingInfo
	)

Definition at line 180 of file MCGIDI_energyAngular.cc.

                                                      {
 
    double Ep;
    MCGIDI_energyAngular *energyAngular = distribution->energyAngular;
 
    MCGIDI_sampling_doubleDistribution( smr, &(energyAngular->pdfOfEpGivenE), energyAngular->pdfOfMuGivenEAndEp, modes, decaySamplingInfo );
    Ep = decaySamplingInfo->mu;
    decaySamplingInfo->mu = decaySamplingInfo->Ep;
    decaySamplingInfo->Ep = Ep;
    decaySamplingInfo->frame = energyAngular->frame;
 
    return( 0 );
}

Referenced by MCGIDI_outputChannel_sampleProductsAtE().

MCGIDI_KalbachMann_free()

MCGIDI_KalbachMann * MCGIDI_KalbachMann_free	(	statusMessageReporting *	smr,
		MCGIDI_KalbachMann *	KalbachMann
	)

Definition at line 61 of file MCGIDI_KalbachMann.cc.

                                                                                                            {
 
    MCGIDI_KalbachMann_release( smr, KalbachMann );
    smr_freeMemory( (void **) &KalbachMann );
    return( NULL );
}

Referenced by MCGIDI_distribution_release(), MCGIDI_KalbachMann_new(), and MCGIDI_KalbachMann_parseFromTOM().

MCGIDI_KalbachMann_initialize()

int MCGIDI_KalbachMann_initialize	(	statusMessageReporting *	smr,
		MCGIDI_KalbachMann *	KalbachMann,
		ptwXY_interpolation	interpolationWY,
		ptwXY_interpolation	interpolationXY
	)

Definition at line 51 of file MCGIDI_KalbachMann.cc.

                                                                                                                                                                           {
 
    memset( KalbachMann, 0, sizeof( MCGIDI_KalbachMann ) );
    KalbachMann->dists.interpolationWY = interpolationWY;
    KalbachMann->dists.interpolationXY = interpolationXY;
    return( 0 );
}

Referenced by MCGIDI_KalbachMann_new(), and MCGIDI_KalbachMann_release().

MCGIDI_KalbachMann_new()

MCGIDI_KalbachMann * MCGIDI_KalbachMann_new	(	statusMessageReporting *	smr,
		ptwXY_interpolation	interpolationWY,
		ptwXY_interpolation	interpolationXY
	)

Definition at line 39 of file MCGIDI_KalbachMann.cc.

                                              {
 
    MCGIDI_KalbachMann *KalbachMann;
 
    if( ( KalbachMann = (MCGIDI_KalbachMann *) smr_malloc2( smr, sizeof( MCGIDI_KalbachMann ), 0, "KalbachMann" ) ) == NULL ) return( NULL );
    if( MCGIDI_KalbachMann_initialize( smr, KalbachMann, interpolationWY, interpolationXY ) ) KalbachMann = MCGIDI_KalbachMann_free( smr, KalbachMann );
    return( KalbachMann );
}

Referenced by MCGIDI_KalbachMann_parseFromTOM().

MCGIDI_KalbachMann_parseFromTOM()

int MCGIDI_KalbachMann_parseFromTOM	(	statusMessageReporting *	smr,
		xDataTOM_element *	element,
		MCGIDI_distribution *	distribution
	)

Definition at line 89 of file MCGIDI_KalbachMann.cc.

                                                                                                                                 {
 
    MCGIDI_KalbachMann *KalbachMann = NULL;
    xDataTOM_element *KalbachMannElement;
    int index, dataPerEout = 3;
    double energyInFactor, energyOutFactor;
    xDataTOM_xDataInfo *xDataInfo;
    xDataTOM_KalbachMann *KalbachMannXData;
    ptwXY_interpolation interpolationXY, interpolationWY;
    char const *energyFromUnit, *energyToUnit = "MeV";
 
    MCGIDI_POP *productPOP = distribution->product->pop;
    double productZ = productPOP->Z, productA = productPOP->A, productN = productA - productZ;
    MCGIDI_target_heated *targetHeated = MCGIDI_product_getTargetHeated( smr, distribution->product );
    MCGIDI_POP *projectilePOP = MCGIDI_target_heated_getPOPForProjectile( smr, targetHeated );
    double projectileZ = projectilePOP->Z, projectileA = projectilePOP->A, projectileN = projectileA - projectileZ;
    MCGIDI_POP *targetPOP = MCGIDI_target_heated_getPOPForTarget( smr, targetHeated );
    double targetZ = targetPOP->Z, targetA = targetPOP->A, targetN = targetA - targetZ;
    double Ia = 0., Ib = 0., Ma = -1, mb = -1;
 
    if( ( targetA == 0 ) && ( targetZ == 6 ) ) {    /* Special case for C_000 evaluation. */
        targetN = 6;
        targetA = 12;
    }
    if( ( KalbachMannElement = xDataTOME_getOneElementByName( smr, element, "KalbachMann", 1 ) ) == NULL ) goto err;
 
    if( MCGIDI_fromTOM_interpolation( smr, KalbachMannElement, 0, &interpolationWY ) ) goto err;
    if( MCGIDI_fromTOM_interpolation( smr, KalbachMannElement, 1, &interpolationXY ) ) goto err;
 
    xDataInfo = &(KalbachMannElement->xDataInfo);
    KalbachMannXData = (xDataTOM_KalbachMann *) xDataInfo->data;
    if( KalbachMannXData->type == xDataTOM_KalbachMannType_fra ) dataPerEout = 4;
 
    energyFromUnit = xDataTOM_axes_getUnit( smr, &(xDataInfo->axes), 0 );
    if( !smr_isOk( smr ) ) goto err;
    energyInFactor = MCGIDI_misc_getUnitConversionFactor( smr, energyFromUnit, energyToUnit );
    if( !smr_isOk( smr ) ) goto err;
 
    energyFromUnit = xDataTOM_axes_getUnit( smr, &(xDataInfo->axes), 1 );
    if( !smr_isOk( smr ) ) goto err;
    energyOutFactor = MCGIDI_misc_getUnitConversionFactor( smr, energyFromUnit, energyToUnit );
    if( !smr_isOk( smr ) ) goto err;
 
    if( ( KalbachMann = distribution->KalbachMann = MCGIDI_KalbachMann_new( smr, interpolationWY, interpolationXY ) ) == NULL ) goto err;
 
/*
    double productMass MCGIDI_product_getMass_MeV( smr, distribution->product ), residualMass;
*/
    KalbachMann->energyToMeVFactor = MCGIDI_misc_getUnitConversionFactor( smr, energyToUnit, "MeV" );
    KalbachMann->massFactor = (double) productZ + productN;     /* This is not correct as masses are needed not Z and N. */
    KalbachMann->massFactor /= projectileN + projectileZ + targetZ + targetN - productZ + productN;
    KalbachMann->massFactor += 1.;
 
    if( projectileZ == 0 ) {
        if( projectileN == 1 ) Ma = 1; }
    else if( projectileZ == 1 ) {
        if( projectileN == 1 ) {
            Ma = 1; }
        else if( projectileN == 2 ) {
            Ia = 2.22;
            Ma = 1; } }
    else if( projectileZ == 2 ) {
        if( projectileN == 2 ) {
            Ia = 28.3;
            Ma = 0;
        }
    }
        
    if( productZ == 0 ) {
        if( productN == 1 ) mb = 0.5; }
    else if( productZ == 1 ) {
        if( productN == 1 ) {
            mb = 1; }
        else if( productN == 2 ) {
            Ia = 2.22;
            mb = 1; }
        else if( productN == 3 ) {
            Ib = 8.48;
            mb = 1; } }
    else if( productZ == 2 ) {
        if( productN == 1 ) {
            Ib = 7.72;
            mb = 1; }
        else if( productN == 2 ) {
            Ib = 28.3;
            mb = 2;
        }
    }
        
    KalbachMann->Ma = Ma;
    KalbachMann->mb = mb;
 
    KalbachMann->Sa = MCGIDI_KalbachMann_S_a_or_b( targetZ, targetN, targetZ + projectileZ, targetN + projectileN, Ia );
    KalbachMann->Sb = MCGIDI_KalbachMann_S_a_or_b( projectileZ + targetZ - productZ, projectileN + targetN - productN, 
        targetZ + projectileZ, targetN + projectileN, Ib );
 
    KalbachMann->dists.numberOfWs = 0;
    if( ( KalbachMann->dists.Ws = (double *) smr_malloc2( smr, KalbachMannXData->numberOfEnergies * sizeof( double ), 0, "KalbachMann->dists->Ws" ) ) == NULL ) goto err;
    if( ( KalbachMann->dists.dist = (MCGIDI_pdfOfX *) smr_malloc2( smr, KalbachMannXData->numberOfEnergies * sizeof( MCGIDI_pdfOfX ), 0, "KalbachMann->dists->dist" ) ) == NULL ) goto err;
    if( ( KalbachMann->ras = (MCGIDI_KalbachMann_ras *) smr_malloc2( smr, KalbachMannXData->numberOfEnergies * sizeof( MCGIDI_KalbachMann_ras ), 0, "KalbachMann->ras" ) ) == NULL ) goto err;
 
    for( index = 0; index < KalbachMannXData->numberOfEnergies; index++ ) {
        if( MCGIDI_KalbachMann_parseFromTOM2( smr, dataPerEout, index, &(KalbachMannXData->coefficients[index]), 
            energyInFactor, energyOutFactor, KalbachMann ) ) goto err;
    }
 
    if( ( KalbachMann->frame = MCGIDI_misc_getProductFrame( smr, KalbachMannElement ) ) == xDataTOM_frame_invalid ) goto err;
    distribution->type = MCGIDI_distributionType_KalbachMann_e;
 
    return( 0 );
 
err:
    if( KalbachMann != NULL ) MCGIDI_KalbachMann_free( smr, KalbachMann );
    return( 1 );
}

Referenced by MCGIDI_energyAngular_parseFromTOM().

MCGIDI_KalbachMann_release()

int MCGIDI_KalbachMann_release	(	statusMessageReporting *	smr,
		MCGIDI_KalbachMann *	KalbachMann
	)

Definition at line 70 of file MCGIDI_KalbachMann.cc.

                                                                                               {
 
    int i;
    MCGIDI_pdfsOfXGivenW *dists = &(KalbachMann->dists);
 
    for( i = 0; i < dists->numberOfWs; i++ ) {
        smr_freeMemory( (void **) &(KalbachMann->ras[i].rs) );
        smr_freeMemory( (void **) &(dists->dist[i].Xs) );
    }
    smr_freeMemory( (void **) &(KalbachMann->ras) );
    smr_freeMemory( (void **) &(dists->Ws) );
    smr_freeMemory( (void **) &(dists->dist) );
 
    MCGIDI_KalbachMann_initialize( smr, KalbachMann, ptwXY_interpolationLinLin, ptwXY_interpolationLinLin );
    return( 0 );
}

Referenced by MCGIDI_KalbachMann_free().

MCGIDI_KalbachMann_sampleEp()

int MCGIDI_KalbachMann_sampleEp	(	statusMessageReporting *	smr,
		MCGIDI_KalbachMann *	KalbachMann,
		MCGIDI_quantitiesLookupModes &	modes,
		MCGIDI_decaySamplingInfo *	decaySamplingInfo
	)

Definition at line 294 of file MCGIDI_KalbachMann.cc.

                                                      {
 
    double Epl, Epu, Ep, r, r2, rl, ru, a, a2, al, au, mu, randomEp = decaySamplingInfo->rng( decaySamplingInfo->rngState );
    MCGIDI_pdfsOfXGivenW_sampled sampled;
    MCGIDI_pdfsOfXGivenW *dists = &(KalbachMann->dists);
    ptwXY_interpolation interpolationWY;
 
    sampled.smr = smr;
    sampled.w = modes.getProjectileEnergy( );
    MCGIDI_sampling_sampleX_from_pdfsOfXGivenW( dists, &sampled, randomEp );
 
    interpolationWY = sampled.interpolationWY;
    if( sampled.iW < 0 ) {
        interpolationWY = ptwXY_interpolationFlat;
        if( sampled.iW == -2 ) {        /* ???????????? This should probably report a warning. */
            sampled.iW = 0; }
        else if( sampled.iW == -1 ) {
            sampled.iW = dists->numberOfWs - 1;
        }
    }
 
    Ep = sampled.x;                                                 /* Sampled Ep. */
    if( sampled.interpolationXY == ptwXY_interpolationFlat ) {      /* Now sample r. */
        r = KalbachMann->ras[sampled.iW].rs[sampled.iX1]; }
    else {
        Epl = dists->dist[sampled.iW].Xs[sampled.iX1];
        Epu = dists->dist[sampled.iW].Xs[sampled.iX1+1];
        rl = KalbachMann->ras[sampled.iW].rs[sampled.iX1];
        ru = KalbachMann->ras[sampled.iW].rs[sampled.iX1+1];
        r = ( ru - rl ) / ( Epu - Epl ) * ( Ep - Epl ) + rl;
    }
    if( interpolationWY == ptwXY_interpolationLinLin ) {
        if( sampled.interpolationXY == ptwXY_interpolationFlat ) {
            r2 = KalbachMann->ras[sampled.iW+1].rs[sampled.iX2]; }
        else {
            Epl = dists->dist[sampled.iW+1].Xs[sampled.iX2];
            Epu = dists->dist[sampled.iW+1].Xs[sampled.iX2+1];
            rl = KalbachMann->ras[sampled.iW+1].rs[sampled.iX2];
            ru = KalbachMann->ras[sampled.iW+1].rs[sampled.iX2+1];
            r2 = ( ru - rl ) / ( Epu - Epl ) * ( Ep - Epl ) + rl;
        }
        r = sampled.frac * r + ( 1. - sampled.frac ) * r2;
    }
 
    if( KalbachMann->ras[0].as == NULL ) {                          /* Now determine a. */
        double X1, X3_2;
        double eb = KalbachMann->massFactor * KalbachMann->energyToMeVFactor * Ep + KalbachMann->Sb;
 
        X1 = eb;             /* Not valid for ea > Et1. */
        X3_2 = eb * eb;       /* Not valid for ea > Et3. */
        a = X1 * ( C1 + C2 * X1 * X1 ) + C2 * KalbachMann->Ma * KalbachMann->mb * X3_2 * X3_2; }
    else {
        if( sampled.interpolationXY == ptwXY_interpolationFlat ) {
            a = KalbachMann->ras[sampled.iW].as[sampled.iX1]; }
        else {
            Epl = dists->dist[sampled.iW].Xs[sampled.iX1];
            Epu = dists->dist[sampled.iW].Xs[sampled.iX1+1];
            al = KalbachMann->ras[sampled.iW].as[sampled.iX1];
            au = KalbachMann->ras[sampled.iW].as[sampled.iX1+1];
            a = ( au - al ) / ( Epu - Epl ) * ( Ep - Epl ) + al;
        }
        a2 = 0.;
        if( interpolationWY == ptwXY_interpolationLinLin ) {
            if( sampled.interpolationXY == ptwXY_interpolationFlat ) {
                a2 = KalbachMann->ras[sampled.iW+1].as[sampled.iX2]; }
            else {
                Epl = dists->dist[sampled.iW+1].Xs[sampled.iX2];
                Epu = dists->dist[sampled.iW+1].Xs[sampled.iX2+1];
                al = KalbachMann->ras[sampled.iW+1].as[sampled.iX2];
                au = KalbachMann->ras[sampled.iW+1].as[sampled.iX2+1];
                a2 = ( au - al ) / ( Epu - Epl ) * ( Ep - Epl ) + al;
            }
        }
        a = sampled.frac * a + ( 1. - sampled.frac ) * a2;
    }
 
        /* In the following: Cosh[ a mu ] + r Sinh[ a mu ] = ( 1 - r ) Cosh[ a mu ] + r ( Cosh[ a mu ] + Sinh[ a mu ] ). */
    if( decaySamplingInfo->rng( decaySamplingInfo->rngState ) >= r ) {   /* Sample the '( 1 - r ) Cosh[ a mu ]' term. */
        double T = ( 2. * decaySamplingInfo->rng( decaySamplingInfo->rngState ) - 1. ) * std::sinh( a );
 
        mu = G4Log( T + std::sqrt( T * T + 1. ) ) / a; }
    else {                                                              /* Sample the 'r ( Cosh[ a mu ] + Sinh[ a mu ]' term. */
        double rng1 = decaySamplingInfo->rng( decaySamplingInfo->rngState ), exp_a = G4Exp( a );
 
        mu = G4Log( rng1 * exp_a + ( 1. - rng1 ) / exp_a ) / a;
    }
    if( mu < -1 ) {
        mu = -1;}
    else if( mu >  1 ) {
        mu = 1;
    }
 
    decaySamplingInfo->frame = KalbachMann->frame;
    decaySamplingInfo->Ep = Ep;
    decaySamplingInfo->mu = mu;
    return( !smr_isOk( smr ) );
}

Referenced by MCGIDI_outputChannel_sampleProductsAtE().

MCGIDI_kinetics_2BodyReaction()

int MCGIDI_kinetics_2BodyReaction	(	statusMessageReporting *	smr,
		MCGIDI_angular *	angular,
		double	K,
		double	mu,
		double	phi,
		MCGIDI_sampledProductsData *	outgoingData
	)

Definition at line 18 of file MCGIDI_kinetics.cc.

                                                   {
 
    double m1 = angular->projectileMass_MeV, m2 = angular->targetMass_MeV, m3 = angular->productMass_MeV, m4 = angular->residualMass_MeV, mi, mf, Kp, x, beta;
 
    mi = m1 + m2;
    mf = m3 + m4;
    beta = std::sqrt( K * ( K + 2. * m1 ) ) / ( K + mi );
    x = K * m2 / ( mi * mi );
    if( x < 2e-5 ) {                                        /* Kp is the total kinetic energy for m3 and m4 in the COM frame. */
        Kp = mi - mf + K * m2 / mi * ( 1 - 0.5 * x * ( 1 - x ) ); }
    else {
        Kp = std::sqrt( mi * mi + 2 * K * m2 ) - mf;
    }
    if( Kp < 0 ) Kp = 0.;           /* ???? There needs to be a better test here. */
    return( MCGIDI_kinetics_COMKineticEnergy2LabEnergyAndMomentum( smr, beta, Kp, mu, phi, m3, m4, outgoingData ) );
}

Referenced by MCGIDI_outputChannel_sampleProductsAtE().

MCGIDI_kinetics_COM2Lab()

int MCGIDI_kinetics_COM2Lab	(	statusMessageReporting *	smr,
		MCGIDI_quantitiesLookupModes &	modes,
		MCGIDI_decaySamplingInfo *	decaySamplingInfo,
		double	masses[3]
	)

Definition at line 105 of file MCGIDI_kinetics.cc.

                                                                                                                                                               {
/*      
*       massProjectile = masses[0], massTarget = masses[1], massProduct = masses[2];
*/
    double a = masses[0] + masses[1], b, e_in = modes.getProjectileEnergy( ) * masses[0] * masses[2] / ( a * a ), Ep;
 
    if( decaySamplingInfo->frame != xDataTOM_frame_centerOfMass ) {
        smr_setReportError2( smr, smr_unknownID, 1, "bad frame = %d for COM to lab conversion of mu/energy", decaySamplingInfo->frame );
        return( 1 );
    }
    a = std::sqrt( e_in );
    b = std::sqrt( decaySamplingInfo->Ep );
    Ep = decaySamplingInfo->Ep + e_in + 2. * decaySamplingInfo->mu * a * b;
    if( Ep != 0 ) {
        decaySamplingInfo->mu = ( a + decaySamplingInfo->mu * b ) / std::sqrt( Ep );
    }
    decaySamplingInfo->Ep = Ep;
    decaySamplingInfo->frame = xDataTOM_frame_lab;
    return( 0 );
}

Referenced by MCGIDI_outputChannel_sampleProductsAtE().

MCGIDI_kinetics_COMKineticEnergy2LabEnergyAndMomentum()

int MCGIDI_kinetics_COMKineticEnergy2LabEnergyAndMomentum	(	statusMessageReporting *	smr,
		double	beta,
		double	e_kinetic_com,
		double	mu,
		double	phi,
		double	m3cc,
		double	m4cc,
		MCGIDI_sampledProductsData *	outgoingData
	)

Definition at line 38 of file MCGIDI_kinetics.cc.

                                                                             {
/*
*   beta            the velocity/speedOflight of the com frame relative to the lab frame.
*   e_kinetic_com   Total kinetic energy (K1 + K2) in the COM frame.
*   mu              cos( theta ) in the COM frame.
*/
    double x, v_p, p, pp3, pp4, px3, py3, pz3, pz4, pz, p_perp2, E3, E4, gamma, m3cc2 = m3cc * m3cc, m4cc2 = m4cc * m4cc;
 
    p = std::sqrt( e_kinetic_com * ( e_kinetic_com + 2. * m3cc ) * ( e_kinetic_com + 2. * m4cc )  * ( e_kinetic_com + 2. * ( m3cc + m4cc ) ) ) /
            ( 2. * ( e_kinetic_com + m3cc + m4cc ) );
    py3 = p * std::sqrt( 1 - mu * mu );
    px3 = py3 * std::cos( phi );
    py3 *= std::sin( phi );
    pz = p * mu;
    if( 1 ) {                           /* ????????? Assuming the answer is wanted in the lab frame for now. */
        E3 = std::sqrt( p * p + m3cc2 );
        E4 = std::sqrt( p * p + m4cc2 );
        gamma = std::sqrt( 1. / ( 1. - beta * beta ) );
        pz3 = gamma * (  pz + beta * E3 );
        pz4 = gamma * ( -pz + beta * E4 ); }
    else {                              /* COM frame. */
        pz3 = pz;
        pz4 = -pz;
    }
    outgoingData[1].isVelocity = outgoingData[0].isVelocity;
 
    p_perp2 = px3 * px3 + py3 * py3;
 
    outgoingData[0].px_vx = px3;
    outgoingData[0].py_vy = py3;
    outgoingData[0].pz_vz = pz3;
    pp3 = p_perp2 + pz3 * pz3;
    x = ( m3cc > 0 ) ? pp3 / ( 2 * m3cc2 ) : 1.;
    if( x < 1e-5 ) {
        outgoingData[0].kineticEnergy = m3cc * x  * ( 1 - 0.5 * x * ( 1 - x ) ); }
    else {
        outgoingData[0].kineticEnergy = std::sqrt( m3cc2 + pp3 ) - m3cc;
    }
    outgoingData[1].px_vx = -px3;
    outgoingData[1].py_vy = -py3;
    outgoingData[1].pz_vz = pz4;
    pp4 = p_perp2 + pz4 * pz4;
    x = ( m4cc > 0 ) ? pp4 / ( 2 * m4cc2 ) : 1.;
    if( x < 1e-5 ) {
        outgoingData[1].kineticEnergy = m4cc * x  * ( 1 - 0.5 * x * ( 1 - x ) ); }
    else {
        outgoingData[1].kineticEnergy = std::sqrt( m4cc2 + pp4 ) - m4cc;
    }
 
    if( outgoingData[0].isVelocity ) {
        v_p = MCGIDI_speedOfLight_cm_sec / std::sqrt( pp3 + m3cc2 );
        outgoingData[0].px_vx *= v_p;
        outgoingData[0].py_vy *= v_p;
        outgoingData[0].pz_vz *= v_p;
 
        v_p = MCGIDI_speedOfLight_cm_sec / std::sqrt( pp4 + m4cc2 );
        outgoingData[1].px_vx *= v_p;
        outgoingData[1].py_vy *= v_p;
        outgoingData[1].pz_vz *= v_p;
    }
 
    return( 0 );
}

Referenced by MCGIDI_kinetics_2BodyReaction().

MCGIDI_LLNLAngular_angularEnergy_parseFromTOM()

int MCGIDI_LLNLAngular_angularEnergy_parseFromTOM	(	statusMessageReporting *	smr,
		xDataTOM_element *	element,
		MCGIDI_distribution *	distribution
	)

Definition at line 22 of file MCGIDI_LLNLAngular_angularEnergy.cc.

                                                                                                                                               {
 
    xDataTOM_element *angularEnergyElement;
 
    if( ( angularEnergyElement = xDataTOME_getOneElementByName( smr, element, "LLNLAngular_angularEnergy", 1 ) ) == NULL ) return( 1 );
 
    if( MCGIDI_angular_parseFromTOM( smr, angularEnergyElement, distribution, NULL ) ) goto err;
    if( MCGIDI_LLNL_angularEnergy_parseFromTOM( smr, angularEnergyElement, distribution ) ) goto err;
 
    return( 0 );
 
err:
    if( distribution->angular ) distribution->angular = MCGIDI_angular_free( smr, distribution->angular );
    return( 1 );
}

Referenced by MCGIDI_distribution_parseFromTOM().

MCGIDI_misc_binarySearch()

xDataTOM_Int MCGIDI_misc_binarySearch	(	xDataTOM_Int	n,
		double *	ds,
		double	d
	)

Definition at line 228 of file MCGIDI_misc.cc.

                                                                              {
/*
*   Returns -2 is d < first point of ds, -1 if > last point of ds and the lower index of ds otherwise.
*/
    xDataTOM_Int imin = 0, imid, imax = n - 1;
 
    if( d < ds[0] ) return( -2 );
    if( d > ds[n-1] ) return( -1 );
    while( 1 ) { // Loop checking, 11.06.2015, T. Koi
        imid = ( imin + imax ) >> 1;
        if( imid == imin ) break;
        if( d < ds[imid] ) {
            imax = imid; }
        else {
            imin = imid;
        }
    }
    return( imin );
}

Referenced by MCGIDI_sampling_doubleDistribution(), MCGIDI_sampling_sampleX_from_pdfOfX(), and MCGIDI_sampling_sampleX_from_pdfsOfXGivenW().

MCGIDI_misc_NumberOfZSymbols()

int MCGIDI_misc_NumberOfZSymbols

(

void

)

Definition at line 54 of file MCGIDI_misc.cc.

                                         {
 
    return( sizeof( ZSymbols ) / sizeof( struct ZSymbol ) );
}

Referenced by MCGIDI_misc_symbolToZ(), and MCGIDI_misc_ZToSymbol().

MCGIDI_misc_PQUStringToDouble()

int MCGIDI_misc_PQUStringToDouble	(	statusMessageReporting *	smr,
		char const *	str,
		char const *	unit,
		double	conversion,
		double *	value
	)

Definition at line 330 of file MCGIDI_misc.cc.

                                                                                                                                      {
/*
*   Currently, white spaces are not allowed after the unit.
*
*   Examples of allowed strings are: "2.39e6 eV", " 2.39e6eV" and " 2.39e6 eV".
*/
    char const *s = str;
    char *e;
 
 
    while( isspace( *s ) ) s++; // Loop checking, 11.06.2015, T. Koi
    *value = strtod( s, &e ) * conversion;
    if( e == s ) {
        smr_setReportError2( smr, smr_unknownID, 1, "no number at start of string = <%s>", str );
        return( 1 );
    }
    while( isspace( *e ) ) e++; // Loop checking, 11.06.2015, T. Koi
    if( strcmp( e, unit ) != 0 ) {
        smr_setReportError2( smr, smr_unknownID, 1, "unit = '%s' not '%s' in '%s'", e, unit, str );
        return( 1 );
    }
    return( 0 );
}

MCGIDI_misc_PQUStringToDoubleInUnitOf()

int MCGIDI_misc_PQUStringToDoubleInUnitOf	(	statusMessageReporting *	smr,
		char const *	str,
		char const *	toUnit,
		double *	value
	)

Definition at line 356 of file MCGIDI_misc.cc.

                                                                                                                             {
/*
*   Currently, white spaces are not allowed after the unit.
*
*   Examples of allowed strings are: "2.39e6 eV", " 2.39e6eV" and " 2.39e6 eV".
*/
    char const *s1 = str;
    char *e1;
    double factor;
 
    while( isspace( *s1 ) ) s1++; // Loop checking, 11.06.2015, T. Koi
    *value = strtod( s1, &e1 );
    if( e1 == s1 ) {
        smr_setReportError2( smr, smr_unknownID, 1, "no number at start of string = <%s>", str );
        return( 1 );
    }
    while( isspace( *e1 ) ) e1++; // Loop checking, 11.06.2015, T. Koi
 
    factor = MCGIDI_misc_getUnitConversionFactor( smr, e1, toUnit );
    *value *= factor;
    return( !smr_isOk( smr ) );
}

Referenced by MCGIDI_distribution_parseFromTOM(), MCGIDI_outputChannel_parseFromTOM(), and MCGIDI_product_parseFromTOM().

MCGIDI_misc_symbolToZ()

int MCGIDI_misc_symbolToZ

(

const char *

Z

)

Definition at line 69 of file MCGIDI_misc.cc.

                                           {
 
    int i, n = MCGIDI_misc_NumberOfZSymbols( );
 
    for( i = 0; i < n; i++ ) {
        if( strcmp( Z, ZSymbols[i].symbol ) == 0 ) return( ZSymbols[i].Z );
    }
    return( -1 );
}

Referenced by MCGIDI_miscNameToZAm().

MCGIDI_misc_updateTransportabilitiesMap()

void MCGIDI_misc_updateTransportabilitiesMap	(	transportabilitiesMap *	transportabilities,
		int	PoPID,
		enum MCGIDI_transportability	transportability
	)

Definition at line 482 of file MCGIDI_misc.cc.

                                                                                                                                                    {
 
    transportabilitiesMap::iterator iter = transportabilities->find( PoPID );
 
    if( iter != transportabilities->end( ) ) {
        switch ( iter->second ) {
        case MCGIDI_transportability_unknown :
            break;
        case MCGIDI_transportability_none :
            switch( transportability ) {
                case MCGIDI_transportability_unknown :
                case MCGIDI_transportability_none :
                    transportability = MCGIDI_transportability_none;
                    break;
                case MCGIDI_transportability_partial :
                    break;
                case MCGIDI_transportability_full :
                    transportability = MCGIDI_transportability_partial;
                    break;
            }
            break;
        case MCGIDI_transportability_partial :
            transportability = MCGIDI_transportability_partial;
            break;
        case MCGIDI_transportability_full :
            switch( transportability ) {
                case MCGIDI_transportability_none :
                case MCGIDI_transportability_partial :
                    transportability = MCGIDI_transportability_partial;
                    break;
                case MCGIDI_transportability_unknown :
                case MCGIDI_transportability_full :
                    break;
            }
            break;
        }
    }
    (*transportabilities)[PoPID] = transportability;
}

Referenced by MCGIDI_misc_updateTransportabilitiesMap2(), and MCGIDI_target_heated_read().

MCGIDI_misc_updateTransportabilitiesMap2()

void MCGIDI_misc_updateTransportabilitiesMap2	(	transportabilitiesMap *	transportabilities,
		int	PoPID,
		int	transportable
	)

Definition at line 524 of file MCGIDI_misc.cc.

                                                                                                                         {
 
    MCGIDI_misc_updateTransportabilitiesMap( transportabilities, PoPID, ( transportable ? MCGIDI_transportability_full : MCGIDI_transportability_none ) );
}

MCGIDI_misc_ZToSymbol()

const char * MCGIDI_misc_ZToSymbol

(

int

iZ

)

Definition at line 61 of file MCGIDI_misc.cc.

                                            {
 
    if( ( iZ < 0 ) || ( iZ >= MCGIDI_misc_NumberOfZSymbols( ) ) ) return( NULL );
    return( ZSymbols[iZ].symbol );
}

Referenced by G4GIDI_Misc_Z_A_m_ToName().

MCGIDI_miscNameToZAm()

int MCGIDI_miscNameToZAm	(	statusMessageReporting *	smr,
		const char *	name,
		int *	Z,
		int *	A,
		int *	m,
		int *	level
	)

Definition at line 81 of file MCGIDI_misc.cc.

                                                                                                              {
 
    const char *p;
    char s[1024] = "", *q, *e;   /* Note 1) routine will fail when parts of a particle name can be longer than 1024. */
 
    if( strlen( name ) >= ( sizeof( s ) - 1 ) ) {
        smr_setReportError2( smr, smr_unknownID, 0, "particle name too long: '%s'", name );
        return( 1 );
    }
 
    *Z = *A = *m = *level = 0;
    if( ( !strncmp( "FissionProduct", name, 14 ) ) || !strncmp( "99120", name, 5 ) ) {
        *Z = 99;
        *A = 120;
        return( 0 );
    }
    if( strcmp( "gamma", name ) == 0 ) return( 0 );
    if( strcmp( "n", name ) == 0 ) { *A = 1; return( 0 ); }
 
    for( p = name, q = s; ( *p != 0 ) && !isdigit( *p ) && ( *p != '_' ); p++, q++ ) *q = *p;   /* '_' only for "natural". */
    if( *p == 0 ) {
        smr_setReportError2( smr, smr_unknownID, 0, "unsupported particle name = '%s'", name );
        return( 1 );
    }
    *q = 0;
    if( ( *Z = MCGIDI_misc_symbolToZ( s ) ) < 0 ) {
        smr_setReportError2( smr, smr_unknownID, 1, "Particle %s's symbol = '%s' not found", name, s ); }
    else {                  /* Getting here implies that *p is a digit. */
        if( *p == '_' ) {
            if( strncmp( p, "_natural", 8 ) == 0 ) {
                p += 8;
                if( *p ) *level = MCGIDI_miscNameToZAm_getLevel( smr, name, p ); }
            else {
                smr_setReportError2( smr, smr_unknownID, 0, "expecting 'natural': %s", name );
            } }
        else {
            for( q = s; isdigit( *p ); p++, q++ ) *q = *p;
            *q = 0;
            if( strcmp( s, "natural" ) == 0 ) {
                e = s;
                while( *e ) e++; /* Loop checking, 11.06.2015, T. Koi*/ }
            else {
                *A = (int) strtol( s, &e, 10 );
            }
            if( *e != 0 ) {
                smr_setReportError2( smr, smr_unknownID, 1, "Failed to convert A to integer in particle name %s", name ); }
            else {          /* Getting here implies that *p == '_' or 0. */
                if( *p ) *level = MCGIDI_miscNameToZAm_getLevel( smr, name, p );
            }
        }
    }
 
    return( !smr_isOk( smr ) );
}

Referenced by G4GIDI_Misc_channelCompound(), MCGIDI_particle_getInternalID(), and MCGIDI_POP_new().

MCGIDI_outputChannel_free()

MCGIDI_outputChannel * MCGIDI_outputChannel_free	(	statusMessageReporting *	smr,
		MCGIDI_outputChannel *	outputChannel
	)

Definition at line 39 of file MCGIDI_outputChannel.cc.

                                                                                                                    {
 
    MCGIDI_outputChannel_release( smr, outputChannel );
    smr_freeMemory( (void **) &outputChannel );
    return( NULL );
}

Referenced by MCGIDI_outputChannel_new().

MCGIDI_outputChannel_getDomain()

int MCGIDI_outputChannel_getDomain	(	statusMessageReporting *	smr,
		MCGIDI_outputChannel *	outputChannel,
		double *	EMin,
		double *	EMax
	)

Definition at line 153 of file MCGIDI_outputChannel.cc.

                                                                                                                                   {
 
    if( outputChannel->reaction != NULL ) return( MCGIDI_reaction_getDomain( smr, outputChannel->reaction, EMin, EMax ) );
    return( MCGIDI_product_getDomain( smr, outputChannel->parent, EMin, EMax ) );
}

Referenced by MCGIDI_product_getDomain().

MCGIDI_outputChannel_getFinalQ()

double MCGIDI_outputChannel_getFinalQ	(	statusMessageReporting *	smr,
		MCGIDI_outputChannel *	outputChannel,
		double	e_in
	)

Definition at line 192 of file MCGIDI_outputChannel.cc.

                                                                                                                       {
 
    int iProduct;
    double Q = outputChannel->Q;
    MCGIDI_product *product;
 
    for( iProduct = 0; iProduct < outputChannel->numberOfProducts; iProduct++ ) {
        product = &(outputChannel->products[iProduct]);
        if( product->decayChannel.genre != MCGIDI_channelGenre_undefined_e ) Q += MCGIDI_outputChannel_getFinalQ( smr, &(product->decayChannel), e_in );
        if( !smr_isOk( smr ) ) break;
    }
    return( Q );
}

Referenced by MCGIDI_outputChannel_getFinalQ().

MCGIDI_outputChannel_getProductAtIndex()

MCGIDI_product * MCGIDI_outputChannel_getProductAtIndex	(	statusMessageReporting *	smr,
		MCGIDI_outputChannel *	outputChannel,
		int	i
	)

Definition at line 142 of file MCGIDI_outputChannel.cc.

                                                                                                                                  {
 
    if( ( i < 0 ) || ( i >= outputChannel->numberOfProducts ) ) {
        smr_setReportError2( smr, smr_unknownID, 1, "bad product index = %d: outputChannel as only %d products", i, outputChannel->numberOfProducts );
        return( NULL );
    }
    return( &(outputChannel->products[i]) );
}

Referenced by G4GIDI_target::getElasticFinalState().

MCGIDI_outputChannel_getProjectileMass_MeV()

double MCGIDI_outputChannel_getProjectileMass_MeV	(	statusMessageReporting *	smr,
		MCGIDI_outputChannel *	outputChannel
	)

Definition at line 169 of file MCGIDI_outputChannel.cc.

                                                                                                                      {
 
    if( outputChannel->reaction != NULL ) return( MCGIDI_reaction_getProjectileMass_MeV( smr, outputChannel->reaction ) );
    return( MCGIDI_product_getProjectileMass_MeV( smr, outputChannel->parent ) );
}

Referenced by MCGIDI_product_getProjectileMass_MeV().

MCGIDI_outputChannel_getQ_MeV()

double MCGIDI_outputChannel_getQ_MeV	(	statusMessageReporting *	smr,
		MCGIDI_outputChannel *	outputChannel,
		double	e_in
	)

Definition at line 185 of file MCGIDI_outputChannel.cc.

                                                                                                                  {
 
    return( outputChannel->Q );
}

MCGIDI_outputChannel_getTargetHeated()

MCGIDI_target_heated * MCGIDI_outputChannel_getTargetHeated	(	statusMessageReporting *	smr,
		MCGIDI_outputChannel *	outputChannel
	)

Definition at line 161 of file MCGIDI_outputChannel.cc.

                                                                                                                               {
 
    if( outputChannel->reaction != NULL ) return( MCGIDI_reaction_getTargetHeated( smr, outputChannel->reaction ) );
    return( MCGIDI_product_getTargetHeated( smr, outputChannel->parent ) );
}

Referenced by MCGIDI_product_getTargetHeated().

MCGIDI_outputChannel_getTargetMass_MeV()

double MCGIDI_outputChannel_getTargetMass_MeV	(	statusMessageReporting *	smr,
		MCGIDI_outputChannel *	outputChannel
	)

Definition at line 177 of file MCGIDI_outputChannel.cc.

                                                                                                                  {
 
    if( outputChannel->reaction != NULL ) return( MCGIDI_reaction_getTargetMass_MeV( smr, outputChannel->reaction ) );
    return( MCGIDI_product_getTargetMass_MeV( smr, outputChannel->parent ) );
}

Referenced by MCGIDI_product_getTargetMass_MeV().

MCGIDI_outputChannel_initialize()

int MCGIDI_outputChannel_initialize	(	statusMessageReporting *	smr,
		MCGIDI_outputChannel *	outputChannel
	)

Definition at line 31 of file MCGIDI_outputChannel.cc.

                                                                                                       {
 
    memset( outputChannel, 0, sizeof( MCGIDI_outputChannel ) );
    return( 0 );
}

Referenced by MCGIDI_outputChannel_new(), MCGIDI_outputChannel_parseFromTOM(), and MCGIDI_outputChannel_release().

MCGIDI_outputChannel_new()

MCGIDI_outputChannel * MCGIDI_outputChannel_new

(

statusMessageReporting *

smr

)

Definition at line 20 of file MCGIDI_outputChannel.cc.

                                                                              {
 
    MCGIDI_outputChannel *outputChannel;
 
    if( ( outputChannel = (MCGIDI_outputChannel *) smr_malloc2( smr, sizeof( MCGIDI_outputChannel ), 0, "outputChannel" ) ) == NULL ) return( NULL );
    if( MCGIDI_outputChannel_initialize( smr, outputChannel ) ) outputChannel = MCGIDI_outputChannel_free( smr, outputChannel );
    return( outputChannel );
}

MCGIDI_outputChannel_numberOfProducts()

int MCGIDI_outputChannel_numberOfProducts

(

MCGIDI_outputChannel *

outputChannel

)

Definition at line 135 of file MCGIDI_outputChannel.cc.

                                                                                 {
 
    return( outputChannel->numberOfProducts );
}

MCGIDI_outputChannel_parseFromTOM()

int MCGIDI_outputChannel_parseFromTOM	(	statusMessageReporting *	smr,
		xDataTOM_element *	element,
		MCGIDI_POPs *	pops,
		MCGIDI_outputChannel *	outputChannel,
		MCGIDI_reaction *	reaction,
		MCGIDI_product *	parent
	)

Definition at line 61 of file MCGIDI_outputChannel.cc.

                                                            {
 
    int n, delayedNeutronIndex = 0;
    char const *genre, *Q;
    xDataTOM_element *child;
 
    MCGIDI_outputChannel_initialize( smr, outputChannel );
 
    outputChannel->reaction = reaction;
    outputChannel->parent = parent;
    if( ( genre = xDataTOM_getAttributesValueInElement( element, "genre" ) ) == NULL ) goto err;
    if( ( parent != NULL ) && ( strcmp( genre, "NBody" ) ) ) {
        smr_setReportError2( smr, smr_unknownID, 1, "decay channel's genre can only be 'uncorreclated' (a.k.a. 'NBody') and not '%s'", genre );
        goto err;
    }
    if( strcmp( genre, "twoBody" ) == 0 ) {
        outputChannel->genre = MCGIDI_channelGenre_twoBody_e; }
    else if( strcmp( genre, "NBody" ) == 0 ) {
        outputChannel->genre = MCGIDI_channelGenre_uncorrelated_e; }
    else if( strcmp( genre, "sumOfRemainingOutputChannels" ) == 0 ) {
        outputChannel->genre = MCGIDI_channelGenre_sumOfRemaining_e; }
    else {
        smr_setReportError2( smr, smr_unknownID, 1, "unsupported genre = '%s'", genre );
        goto err;
    }
    if( ( Q = xDataTOM_getAttributesValueInElement( element, "Q" ) ) == NULL ) goto err;
    outputChannel->QIsFloat = !MCGIDI_misc_PQUStringToDoubleInUnitOf( smr, Q, "MeV", &(outputChannel->Q) );
 
    if( ( n = xDataTOM_numberOfElementsByName( smr, element, "product" ) ) == 0 ) {
        smr_setReportError2p( smr, smr_unknownID, 1, "outputChannel does not have any products" );
        goto err;
    }
    if( ( outputChannel->products = (MCGIDI_product *) smr_malloc2( smr, n * sizeof( MCGIDI_product ), 0, "outputChannel->products" ) ) == NULL ) goto err;
 
    for( child = xDataTOME_getFirstElement( element ); child != NULL; child = xDataTOME_getNextElement( child ) ) {
        if( strcmp( child->name, "product" ) == 0 ) {
            if( MCGIDI_product_parseFromTOM( smr, child, outputChannel, pops, &(outputChannel->products[outputChannel->numberOfProducts]),
                &delayedNeutronIndex ) ) goto err;
            outputChannel->numberOfProducts++; }
        else if( strcmp( child->name, "fissionEnergyReleased" ) == 0 ) {     /* ????????? Need to support. */
            continue; }
        else {
            printf( "outputChannel child not currently supported = %s\n", child->name );
        }
    }
    if( outputChannel->genre == MCGIDI_channelGenre_twoBody_e ) {
        double projectileMass_MeV, targetMass_MeV, productMass_MeV, residualMass_MeV;
 
        projectileMass_MeV = MCGIDI_reaction_getProjectileMass_MeV( smr, reaction );
        targetMass_MeV = MCGIDI_reaction_getTargetMass_MeV( smr, reaction );
        productMass_MeV = MCGIDI_product_getMass_MeV( smr, &(outputChannel->products[0]) );
        residualMass_MeV = MCGIDI_product_getMass_MeV( smr, &(outputChannel->products[1]) );
 
        //TK 17-11-10 for v1.3
        //A temporary fix for emission of gamma(2.2MeV) from n captured by H
        //                  capture                     gamma                        D 
        if ( reaction->ENDF_MT == 102 && productMass_MeV == 0 && ( outputChannel->products[1].pop->A == 2 && outputChannel->products[1].pop->Z == 1 ) ) {
           //include/PoPs_data.h:#define e_Mass 5.4857990943e-4 /* electron mass in AMU */
           residualMass_MeV += 5.4857990943e-4*MCGIDI_AMU2MeV;
        }
 
        MCGIDI_product_setTwoBodyMasses( smr, &(outputChannel->products[0]), projectileMass_MeV, targetMass_MeV, productMass_MeV, residualMass_MeV );
    }
 
    return( 0 );
 
err:
    MCGIDI_outputChannel_release( smr, outputChannel );
    return( 1 );
}

Referenced by MCGIDI_product_parseFromTOM(), and MCGIDI_reaction_parseFromTOM().

MCGIDI_outputChannel_release()

int MCGIDI_outputChannel_release	(	statusMessageReporting *	smr,
		MCGIDI_outputChannel *	outputChannel
	)

Definition at line 48 of file MCGIDI_outputChannel.cc.

                                                                                                     {
 
    int i;
 
    for( i = 0; i < outputChannel->numberOfProducts; i++ ) MCGIDI_product_release( smr, &(outputChannel->products[i]) );
    smr_freeMemory( (void **) &(outputChannel->products) );
    MCGIDI_outputChannel_initialize( smr, outputChannel );
 
    return( 0 );
}

Referenced by MCGIDI_outputChannel_free(), MCGIDI_outputChannel_parseFromTOM(), MCGIDI_product_release(), and MCGIDI_reaction_release().

MCGIDI_outputChannel_sampleProductsAtE()

int MCGIDI_outputChannel_sampleProductsAtE	(	statusMessageReporting *	smr,
		MCGIDI_outputChannel *	outputChannel,
		MCGIDI_quantitiesLookupModes &	modes,
		MCGIDI_decaySamplingInfo *	decaySamplingInfo,
		MCGIDI_sampledProductsDatas *	productDatas,
		double *	masses
	)

Definition at line 208 of file MCGIDI_outputChannel.cc.

{
  int i1;
  int multiplicity(0);
  int secondTwoBody = 0, isDecayChannel = ( outputChannel->reaction == NULL );
  double e_in = modes.getProjectileEnergy( );
  MCGIDI_product *product;
  double phi, p, masses[3];
  MCGIDI_distribution *distribution;
  MCGIDI_sampledProductsData productData[2];
 
  if (isDecayChannel) {
    masses[0] = masses_[0];              /* More work may be needed here. */
    masses[1] = masses_[1];
  } else {
    masses[0] = MCGIDI_reaction_getProjectileMass_MeV( smr, outputChannel->reaction );
    masses[1] = MCGIDI_reaction_getTargetMass_MeV( smr, outputChannel->reaction );
  }
 
  // Loop over all possible final state particles reachable from initial state
  // List of these particles (products) was read in from GIDI
  // Note: all particles satifying the sampling criteria are included in the 
  // final state, regardless of charge, energy or baryon number conservation
 
  for (i1 = 0; i1 < outputChannel->numberOfProducts; i1++) {
    product = &(outputChannel->products[i1]);
    if (product->decayChannel.genre != MCGIDI_channelGenre_undefined_e ) {
      if( MCGIDI_outputChannel_sampleProductsAtE(smr, &(product->decayChannel),
                                                 modes, decaySamplingInfo,
                                                 productDatas, masses ) < 0 ) return( -1 );
    } else {
      distribution = &(product->distribution);
      if( distribution->type == MCGIDI_distributionType_none_e ) continue;
 
      if (!secondTwoBody) {
        // Sample multiplicity of final state particle at kinetic energy of projectile
        // The multiplicity stored in GIDI is a real number whose fractional part is
        // compared to a random number to decide what integer value is returned   
        if ((multiplicity = product->multiplicity) == 0) multiplicity =
                               MCGIDI_product_sampleMultiplicity(smr, product, e_in,
                                  decaySamplingInfo->rng( decaySamplingInfo->rngState ) );
        while (multiplicity > 0) { 
 
          multiplicity--;
          decaySamplingInfo->pop = product->pop;
          decaySamplingInfo->mu = 0;
          decaySamplingInfo->Ep = 0;
          productData[0].isVelocity = decaySamplingInfo->isVelocity;
          productData[0].pop = product->pop;
          productData[0].delayedNeutronIndex = product->delayedNeutronIndex;
          productData[0].delayedNeutronRate = product->delayedNeutronRate;
          productData[0].birthTimeSec = 0;
          if (product->delayedNeutronRate > 0) {
            productData[0].birthTimeSec =
                 -G4Log( decaySamplingInfo->rng( decaySamplingInfo->rngState ) ) / product->delayedNeutronRate;
          }
 
          switch( outputChannel->genre ) {
 
          case MCGIDI_channelGenre_twoBody_e :
            secondTwoBody = 1;
            MCGIDI_angular_sampleMu( smr, distribution->angular, modes, decaySamplingInfo );
            if (smr_isOk(smr) ) {
              phi = 2. * M_PI * decaySamplingInfo->rng( decaySamplingInfo->rngState );
              MCGIDI_kinetics_2BodyReaction( smr, distribution->angular, e_in, decaySamplingInfo->mu, phi, productData );
              if (!smr_isOk(smr) ) return( -1 );
              productData[1].pop = product[1].pop;
              productData[1].delayedNeutronIndex = product[1].delayedNeutronIndex;
              productData[1].delayedNeutronRate = product->delayedNeutronRate;
              productData[1].birthTimeSec = 0;
              MCGIDI_sampledProducts_addProduct( smr, productDatas, productData );
              if( !smr_isOk( smr ) ) return( -1 );
              MCGIDI_sampledProducts_addProduct( smr, productDatas, &(productData[1]) );
              if( !smr_isOk( smr ) ) return( -1 );
            }
            break;
 
          case MCGIDI_channelGenre_uncorrelated_e :
 
          case MCGIDI_channelGenre_sumOfRemaining_e :
            // Get mass of final state particle, then get its distribution
            // masses[0] and masses[1] are incident and target masses
            masses[2] = MCGIDI_product_getMass_MeV( smr, product );
            switch( distribution->type ) {
            case MCGIDI_distributionType_uncorrelated_e :
              MCGIDI_uncorrelated_sampleDistribution( smr, distribution, modes, decaySamplingInfo );
              break;
            case MCGIDI_distributionType_energyAngular_e :
              MCGIDI_energyAngular_sampleDistribution( smr, distribution, modes, decaySamplingInfo );
              break;
            case MCGIDI_distributionType_KalbachMann_e :
              MCGIDI_KalbachMann_sampleEp( smr, distribution->KalbachMann, modes, decaySamplingInfo );
              break;
            case MCGIDI_distributionType_angularEnergy_e :
              MCGIDI_angularEnergy_sampleDistribution( smr, distribution->angularEnergy, modes, decaySamplingInfo );
              break;
            default :
              printf( "Unknown spectral data form product name = %s, channel genre = %d\n", product->pop->name, outputChannel->genre );
              break;
            }
            break;
 
          case MCGIDI_channelGenre_undefined_e :
            printf( "Channel is undefined\n" );
            break;
 
          case MCGIDI_channelGenre_twoBodyDecay_e :
            printf( "Channel is twoBodyDecay\n" );
            break;
 
          case MCGIDI_channelGenre_uncorrelatedDecay_e :
            printf( "Channel is uncorrelatedDecay\n" );
            break;
 
          default :
            printf( "Unsupported channel genre = %d\n", outputChannel->genre );
            break;
          }
 
          if (!smr_isOk(smr) ) return( -1 );
          if (!secondTwoBody) {
            if (decaySamplingInfo->frame == xDataTOM_frame_centerOfMass) {
              if (MCGIDI_kinetics_COM2Lab( smr, modes, decaySamplingInfo, masses) != 0 ) return( -1 );
            }
 
            // Assign kinematics to final state product
            productData[0].kineticEnergy = decaySamplingInfo->Ep;
            p = std::sqrt( decaySamplingInfo->Ep * ( decaySamplingInfo->Ep + 2. * product->pop->mass_MeV ) );
            if (productData[0].isVelocity) p *= MCGIDI_speedOfLight_cm_sec / std::sqrt( p * p + product->pop->mass_MeV * product->pop->mass_MeV );
            productData[0].pz_vz = p * decaySamplingInfo->mu;
            p = std::sqrt( 1. - decaySamplingInfo->mu * decaySamplingInfo->mu ) * p;
            phi = 2. * M_PI * decaySamplingInfo->rng( decaySamplingInfo->rngState );
            productData[0].px_vx = p * std::sin( phi );
            productData[0].py_vy = p * std::cos( phi );
            MCGIDI_sampledProducts_addProduct( smr, productDatas, productData );
            if (!smr_isOk(smr) ) return( -1 );
          }
        } // while multiplicity
 
      }  // if !secondTwoBody
    }  // if decay channel genre
 
  }  // loop over possible final state products
  return( productDatas->numberOfProducts );
 
}

Referenced by MCGIDI_outputChannel_sampleProductsAtE(), and MCGIDI_target_heated_sampleIndexReactionProductsAtE().

MCGIDI_particle_free()

MCGIDI_particle * MCGIDI_particle_free	(	statusMessageReporting *	smr,
		MCGIDI_particle *	particle
	)

Definition at line 39 of file MCGIDI_particle.cc.

                                                                                                {
 
    int i, j;
    MCGIDI_particle **p;
 
    for( i = 0, p = particleSortedList; i < numberOfParticles; i++, p++ ) {
        if( *p == particle ) {
            numberOfParticles--;
            for( j = i; j < numberOfParticles; j++, p++ ) *p = p[1];
            break;
        }
    }
    if( particle == particleListEnd ) particleListEnd = particle->prior;
    if( particle == particleList ) particleList = particle->next;
    if( particle->prior != NULL ) particle->prior->next = particle->next;
    if( particle->next != NULL ) particle->next->prior = particle->prior;
    MCGIDI_particle_release( smr, particle );
    smr_freeMemory( (void **) &particle );
    return( NULL );
}

Referenced by MCGIDI_particle_freeInternalList(), and MCGIDI_particle_getInternalID().

MCGIDI_particle_freeInternalList()

int MCGIDI_particle_freeInternalList

(

statusMessageReporting *

smr

)

Definition at line 70 of file MCGIDI_particle.cc.

                                                                    {
 
    while( particleList != NULL ) MCGIDI_particle_free( smr, particleList );  // Loop checking, 11.06.2015, T. Koi
    particleSortedList = (MCGIDI_particle **) smr_freeMemory( (void **) &particleSortedList );
    return( 0 );
}

MCGIDI_particle_getInternalID()

MCGIDI_particle * MCGIDI_particle_getInternalID	(	statusMessageReporting *	smr,
		const char *const	name,
		MCGIDI_POPs *	pops
	)

Definition at line 79 of file MCGIDI_particle.cc.

                                                                                                                          {
 
    int i, iCmp, min, mid, max, Z, A, m, level;
    MCGIDI_particle *particle;
    MCGIDI_POP *pop;
 
    iCmp = 0;
    min = mid = 0;
    max = numberOfParticles;
    while( min != max ) {  // Loop checking, 11.06.2015, T. Koi
        mid = ( min + max ) / 2;
        iCmp = strcmp( name, particleSortedList[mid]->name );
        if( iCmp == 0 ) return( particleSortedList[mid] );
        if( iCmp < 0 ) {
            max = mid - 1;
            if( mid == 0 ) max = 0; }
        else {
            min = mid + 1;
            if( min > max ) min = max;
        }
    }
    mid = min;
    if( numberOfParticles > 0 ) {
        iCmp = strcmp( name, particleSortedList[mid]->name );
        if( iCmp == 0 ) return( particleSortedList[mid] );
        if( ( iCmp < 0 ) && ( mid != 0 ) ) {
            mid--;
            iCmp = strcmp( name, particleSortedList[mid]->name );
        }
    }
 
    if( ( particle = MCGIDI_particle_new( smr ) ) == NULL ) return( NULL );
    if( ( particle->name = smr_allocateCopyString( smr, name, "particle->name", __FILE__, __LINE__, __func__ ) ) == NULL ) goto err;
    if( MCGIDI_miscNameToZAm( smr, name, &Z, &A, &m, &level ) != 0 ) goto err;
    particle->prior = NULL;
    particle->next = NULL;
    particle->Z = Z;
    particle->A = A;
    particle->m = m;
    if( ( pop = MCGIDI_POPs_findParticle( pops, name ) ) == NULL ) {    /* This should not happend. */
        particle->mass_MeV = MCGIDI_AMU2MeV * MCGIDI_particleMass_AMU( smr, name ); }
    else {
        particle->mass_MeV = pop->mass_MeV;
    }
    if( !smr_isOk( smr ) ) goto err;
 
    if( sizeOfParticleSortedList < ( numberOfParticles + 1 ) ) {
        if( sizeOfParticleSortedList == 0 ) {
            sizeOfParticleSortedList = initialSizeOfList; }
        else {
            sizeOfParticleSortedList += incrementalSizeOfList;
        }
        if( ( particleSortedList = (MCGIDI_particle **) smr_realloc2( smr, particleSortedList, sizeOfParticleSortedList * sizeof( MCGIDI_particle * ), 
            "particleSortedList" ) ) == NULL ) goto err;
    }
 
    if( particleList == NULL ) {
        particle->ordinal = 0;
        particleListEnd = particleList = particle; }
    else {
        particle->ordinal = particleListEnd->ordinal + 1;
        particle->prior = particleListEnd;
        particleListEnd->next = particle;
        particleListEnd = particle;
    }
 
    if( ( mid != 0 ) || ( iCmp > 0 ) ) mid++;
    for( i = numberOfParticles; i > mid; i-- ) particleSortedList[i] = particleSortedList[i-1];
    particleSortedList[mid] = particle;
    numberOfParticles++;
 
    return( particle );
 
err:
    MCGIDI_particle_free( smr, particle );
    return( NULL );
}

MCGIDI_particle_initialize()

int MCGIDI_particle_initialize	(	statusMessageReporting *	smr,
		MCGIDI_particle *	particle
	)

Definition at line 31 of file MCGIDI_particle.cc.

                                                                                        {
 
    memset( particle, 0, sizeof( MCGIDI_particle ) );
    return( 0 );
}

Referenced by MCGIDI_particle_new().

MCGIDI_particle_new()

MCGIDI_particle * MCGIDI_particle_new

(

statusMessageReporting *

smr

)

Definition at line 20 of file MCGIDI_particle.cc.

                                                                    {
 
    MCGIDI_particle *particle = (MCGIDI_particle *) smr_malloc2( smr, sizeof( MCGIDI_particle ), 0, "particle" );
 
    if( particle == NULL ) return( NULL );
    MCGIDI_particle_initialize( smr, particle );
    return( particle );
}

Referenced by MCGIDI_particle_getInternalID().

MCGIDI_particle_printInternalSortedList()

int MCGIDI_particle_printInternalSortedList

(

statusMessageReporting *

smr

)

Definition at line 159 of file MCGIDI_particle.cc.

                                                                          {
 
    int i;
 
    for( i = 0; i < numberOfParticles; i++ ) printf( "%s\n", particleSortedList[i]->name );
    return( 0 );
}

MCGIDI_particle_release()

int MCGIDI_particle_release	(	statusMessageReporting *	smr,
		MCGIDI_particle *	particle
	)

Definition at line 62 of file MCGIDI_particle.cc.

                                                                                     {
 
    smr_freeMemory( (void **) &(particle->name) );
    return( 0 );
}

Referenced by MCGIDI_particle_free().

MCGIDI_POP_free()

MCGIDI_POP * MCGIDI_POP_free

(

MCGIDI_POP *

pop

)

Definition at line 191 of file MCGIDI_pop.cc.

                                               {
 
    if( pop == NULL ) return( NULL );
    MCGIDI_POP_release( pop );
    smr_freeMemory( (void **) &pop );
    return( NULL );
}

Referenced by MCGIDI_POPs_release().

MCGIDI_POP_getMass_MeV()

double MCGIDI_POP_getMass_MeV

(

MCGIDI_POP *

pop

)

Definition at line 212 of file MCGIDI_pop.cc.

                                                 {
 
    return( pop->mass_MeV );
}

Referenced by MCGIDI_product_getMass_MeV(), MCGIDI_target_heated_getProjectileMass_MeV(), and MCGIDI_target_heated_getTargetMass_MeV().

MCGIDI_POP_new()

MCGIDI_POP * MCGIDI_POP_new	(	statusMessageReporting *	smr,
		char const *	name,
		double	mass_MeV,
		double	level_MeV,
		MCGIDI_POP *	parent
	)

Definition at line 165 of file MCGIDI_pop.cc.

                                                                                                                                   {
 
    int Z, A, m, level;
    MCGIDI_POP *pop = (MCGIDI_POP *) smr_malloc2( smr, sizeof( MCGIDI_POP ), 0, "pop" );
 
    if( pop == NULL ) return( NULL );
    pop->next = NULL;
    pop->parent = parent;
    if( ( pop->name = smr_allocateCopyString2( smr, name, "pop->name" ) ) == NULL ) {
        smr_freeMemory( (void **) &pop );
        return( NULL );
    }
    MCGIDI_miscNameToZAm( smr, name, &Z, &A, &m, &level );
    pop->Z = Z;
    pop->A = A;
    pop->level = level;
    pop->m = m;
    pop->mass_MeV = mass_MeV;
    pop->level_MeV = level_MeV;
    pop->numberOfGammaBranchs = 0;
    pop->gammas = NULL;
    return( pop );
}

Referenced by MCGIDI_POPs_addParticleIfNeeded().

MCGIDI_POP_release()

MCGIDI_POP * MCGIDI_POP_release

(

MCGIDI_POP *

pop

)

Definition at line 201 of file MCGIDI_pop.cc.

                                                  {
 
    if( pop == NULL ) return( NULL );
    smr_freeMemory( (void **) &(pop->name) );
    pop->numberOfGammaBranchs = 0;
    if( pop->gammas != NULL ) smr_freeMemory( (void **) &(pop->gammas) );
    return( NULL );
}

Referenced by MCGIDI_POP_free().

MCGIDI_POPs_addParticleIfNeeded()

MCGIDI_POP * MCGIDI_POPs_addParticleIfNeeded	(	statusMessageReporting *	smr,
		MCGIDI_POPs *	pops,
		char const *	name,
		double	mass_MeV,
		double	level_MeV,
		MCGIDI_POP *	parent,
		int	globalParticle
	)

Definition at line 67 of file MCGIDI_pop.cc.

                                                                   {
 
    int i, index;
    MCGIDI_POP *pop;
 
    if( ( index = MCGIDI_POPs_findParticleIndex( pops, name ) ) >= 0 ) return( pops->sorted[index] );
    if( pops->size == pops->numberOfPOPs ) {
        int size = pops->size + pops->increment;
        MCGIDI_POP **sorted = (MCGIDI_POP **) smr_malloc2( smr, size * sizeof( MCGIDI_POP * ), 0, "sorted" );
 
        if( sorted == NULL ) return( NULL );
        for( i = 0; i < pops->numberOfPOPs; i++ ) sorted[i] = pops->sorted[i];
        smr_freeMemory( (void **) &(pops->sorted) );
        pops->sorted = sorted;
        pops->size = size;
    }
    index = -index - 1;
    if( ( pop = MCGIDI_POP_new( smr, name, mass_MeV, level_MeV, parent ) ) == NULL ) return( NULL );
    for( i = pops->numberOfPOPs; i > index; i-- ) pops->sorted[i] = pops->sorted[i-1];
    pops->sorted[index] = pop;
    if( pops->first == NULL ) {
        pops->first = pop; }
    else {
        pops->last->next = pop;
    }
    pops->last = pop;
    pops->numberOfPOPs++;
    pop->globalPoPsIndex = -1;
    if( globalParticle ) {
        if( ( pop->globalPoPsIndex = lPoPs_addParticleIfNeeded( smr, name, "LLNL" ) ) < 0 ) return( NULL );
    }
    return( pop );
}

MCGIDI_POPs_findParticle()

MCGIDI_POP * MCGIDI_POPs_findParticle	(	MCGIDI_POPs *	pops,
		char const *	name
	)

Definition at line 133 of file MCGIDI_pop.cc.

                                                                            {
 
    int index = MCGIDI_POPs_findParticleIndex( pops, name );
 
    if( index < 0 ) return( NULL );
    return( pops->sorted[index] );
}

Referenced by MCGIDI_particle_getInternalID(), MCGIDI_product_parseFromTOM(), and MCGIDI_target_heated_read().

MCGIDI_POPs_findParticleIndex()

int MCGIDI_POPs_findParticleIndex	(	MCGIDI_POPs *	pops,
		char const *	name
	)

Definition at line 104 of file MCGIDI_pop.cc.

                                                                         {
 
    int iCmp = 0, min = 0, mid = 0, max = pops->numberOfPOPs;
 
    if( max == 0 ) return( -1 );
    while( ( max - min ) > 1 ) {
        mid = ( min + max ) / 2;
        iCmp = strcmp( name, pops->sorted[mid]->name );
        if( iCmp == 0 ) return( mid );
        if( iCmp < 0 ) {
            max = mid; }
        else {
            min = mid;
        }
    }  // Loop checking, 11.05.2015, T. Koi
    if( max == 1 ) {            /* First point is not checked as loop exits when ( max = 1 ) - ( min = 0 ) !> 1 ). */
        if( strcmp( name, pops->sorted[0]->name ) == 0 ) return( 0 );
    }
    if( max < pops->numberOfPOPs ) {
        if( strcmp( name, pops->sorted[max]->name ) == 0 ) return( max );
    }
    if( max == 1 ) {
        if( strcmp( name, pops->sorted[0]->name ) < 0 ) return( -1 );
    }
    return( -max - 1 );
}

Referenced by MCGIDI_POPs_addParticleIfNeeded(), and MCGIDI_POPs_findParticle().

MCGIDI_POPs_free()

void * MCGIDI_POPs_free

(

MCGIDI_POPs *

pops

)

Definition at line 41 of file MCGIDI_pop.cc.

                                            {
 
    if( pops == NULL ) return( NULL );
    MCGIDI_POPs_release( pops );
    smr_freeMemory( (void **) &pops );
    return( NULL );
}

MCGIDI_POPs_initial()

int MCGIDI_POPs_initial	(	statusMessageReporting *	smr,
		MCGIDI_POPs *	pops,
		int	size
	)

Definition at line 30 of file MCGIDI_pop.cc.

                                                                                   {
 
    memset( pops, 0, sizeof( MCGIDI_POPs ) );
    if( size < 10 ) size = 10;
    pops->increment = size;
    
    return( 0 );
}

Referenced by MCGIDI_POPs_new(), MCGIDI_POPs_release(), and MCGIDI_target_heated_initialize().

MCGIDI_POPs_new()

MCGIDI_POPs * MCGIDI_POPs_new	(	statusMessageReporting *	smr,
		int	size
	)

Definition at line 19 of file MCGIDI_pop.cc.

                                                                      {
 
    MCGIDI_POPs *pops;
 
    if( ( pops = (MCGIDI_POPs *) smr_malloc2( smr, sizeof( MCGIDI_POPs ), 0, "pops->sorted" ) ) == NULL ) return( NULL );
    if( MCGIDI_POPs_initial( smr, pops, size ) ) smr_freeMemory( (void **) &pops );
    return( pops );
}

MCGIDI_POPs_printSortedList()

void MCGIDI_POPs_printSortedList

(

MCGIDI_POPs *

pops

)

Definition at line 153 of file MCGIDI_pop.cc.

                                                      {
 
    MCGIDI_POPs_writeSortedList( pops, stdout );
}

MCGIDI_POPs_release()

int MCGIDI_POPs_release

(

MCGIDI_POPs *

pops

)

Definition at line 51 of file MCGIDI_pop.cc.

                                             {
 
    MCGIDI_POP *pop, *next;
 
    if( pops == NULL ) return( 0 );
    for( pop = pops->first; pop != NULL; pop = next ) {
        next = pop->next;
        MCGIDI_POP_free( pop );
    }
    smr_freeMemory( (void **) &(pops->sorted) );
    MCGIDI_POPs_initial( NULL, pops, 0 );
    return( 0 );
}

Referenced by MCGIDI_POPs_free(), and MCGIDI_target_heated_release().

MCGIDI_POPs_writeSortedList()

void MCGIDI_POPs_writeSortedList	(	MCGIDI_POPs *	pops,
		FILE *	f
	)

Definition at line 143 of file MCGIDI_pop.cc.

                                                               {
 
    int i;
 
    fprintf( f, "POPs Information: n = %d\n", pops->numberOfPOPs );
    for( i = 0; i < pops->numberOfPOPs; i++ ) fprintf( f, "    %-20s  %e\n", pops->sorted[i]->name, pops->sorted[i]->mass_MeV );
}

Referenced by MCGIDI_POPs_printSortedList().

MCGIDI_product_free()

MCGIDI_product * MCGIDI_product_free	(	statusMessageReporting *	smr,
		MCGIDI_product *	product
	)

Definition at line 51 of file MCGIDI_product.cc.

                                                                                            {
 
    MCGIDI_product_release( smr, product );
    smr_freeMemory( (void **) &product );
    return( NULL );
}

Referenced by MCGIDI_product_new().

MCGIDI_product_getDomain()

int MCGIDI_product_getDomain	(	statusMessageReporting *	smr,
		MCGIDI_product *	product,
		double *	EMin,
		double *	EMax
	)

Definition at line 282 of file MCGIDI_product.cc.

                                                                                                                 {
 
    return( MCGIDI_outputChannel_getDomain( smr, product->outputChannel, EMin, EMax ) );
}

Referenced by MCGIDI_outputChannel_getDomain().

MCGIDI_product_getMass_MeV()

double MCGIDI_product_getMass_MeV	(	statusMessageReporting *	smr,
		MCGIDI_product *	product
	)

Definition at line 297 of file MCGIDI_product.cc.

                                                                                         {
 
    return( MCGIDI_POP_getMass_MeV( product->pop ) );
}

Referenced by MCGIDI_outputChannel_parseFromTOM(), and MCGIDI_outputChannel_sampleProductsAtE().

MCGIDI_product_getProjectileMass_MeV()

double MCGIDI_product_getProjectileMass_MeV	(	statusMessageReporting *	smr,
		MCGIDI_product *	product
	)

Definition at line 311 of file MCGIDI_product.cc.

                                                                                                    {
 
    return( MCGIDI_outputChannel_getProjectileMass_MeV( smr, product->outputChannel ) );
}

Referenced by MCGIDI_energy_parseFromTOM(), and MCGIDI_outputChannel_getProjectileMass_MeV().

MCGIDI_product_getTargetHeated()

MCGIDI_target_heated * MCGIDI_product_getTargetHeated	(	statusMessageReporting *	smr,
		MCGIDI_product *	product
	)

Definition at line 304 of file MCGIDI_product.cc.

                                                                                                             {
 
    return( MCGIDI_outputChannel_getTargetHeated( smr, product->outputChannel ) );
}

Referenced by MCGIDI_KalbachMann_parseFromTOM(), and MCGIDI_outputChannel_getTargetHeated().

MCGIDI_product_getTargetMass_MeV()

double MCGIDI_product_getTargetMass_MeV	(	statusMessageReporting *	smr,
		MCGIDI_product *	product
	)

Definition at line 318 of file MCGIDI_product.cc.

                                                                                                {
 
    return( MCGIDI_outputChannel_getTargetMass_MeV( smr, product->outputChannel ) );
}

Referenced by MCGIDI_energy_parseFromTOM(), and MCGIDI_outputChannel_getTargetMass_MeV().

MCGIDI_product_initialize()

int MCGIDI_product_initialize	(	statusMessageReporting *	smr,
		MCGIDI_product *	product
	)

Definition at line 42 of file MCGIDI_product.cc.

                                                                                     {
 
    memset( product, 0, sizeof( MCGIDI_product ) );
    product->delayedNeutronIndex = -1;
    return( 0 );
}

Referenced by MCGIDI_product_new(), MCGIDI_product_parseFromTOM(), and MCGIDI_product_release().

MCGIDI_product_new()

MCGIDI_product * MCGIDI_product_new

(

statusMessageReporting *

smr

)

Definition at line 31 of file MCGIDI_product.cc.

                                                                  {
 
    MCGIDI_product *product;
 
    if( ( product = (MCGIDI_product *) smr_malloc2( smr, sizeof( MCGIDI_product ), 0, "product" ) ) == NULL ) return( NULL );
    if( MCGIDI_product_initialize( smr, product ) ) product = MCGIDI_product_free( smr, product );
    return( product );
}

MCGIDI_product_parseFromTOM()

int MCGIDI_product_parseFromTOM	(	statusMessageReporting *	smr,
		xDataTOM_element *	element,
		MCGIDI_outputChannel *	outputChannel,
		MCGIDI_POPs *	pops,
		MCGIDI_product *	product,
		int *	delayedNeutronIndex
	)

Definition at line 82 of file MCGIDI_product.cc.

                                                                               {
 
    char const *name, *label, *delayedNeutron, *multiplicityStr, *multiplicityUnits[2] = { "MeV", "" };
    xDataTOM_element *multiplicity, *multiplicityTOM, *decayChannelElement;
    nfu_status status;
    ptwXYPoints *multiplicityVsEnergy = NULL, *norms1 = NULL, *norms2 = NULL;
 
    MCGIDI_product_initialize( smr, product );
 
    product->outputChannel = outputChannel;
    if( ( name = xDataTOM_getAttributesValueInElement( element, "name" ) ) == NULL ) goto err;
    if( ( product->pop = MCGIDI_POPs_findParticle( pops, name ) ) == NULL ) {
        smr_setReportError2( smr, smr_unknownID, 1, "product '%s' not found in pops", name );
        goto err;
    }
    if( ( label = xDataTOM_getAttributesValueInElement( element, "label" ) ) != NULL ) {
        if( ( product->label = smr_allocateCopyString2( smr, label, "product->label" ) ) == NULL ) goto err;
    }
 
    if( ( delayedNeutron = xDataTOM_getAttributesValueInElement( element, "emissionMode" ) ) != NULL ) {
        if( strcmp( delayedNeutron, "delayed" ) == 0 ) {
            if( ( delayedNeutron = xDataTOM_getAttributesValueInElement( element, "decayRate" ) ) == NULL ) {
                goto err;
            }
            if( MCGIDI_misc_PQUStringToDoubleInUnitOf( smr, delayedNeutron, "1/s", &(product->delayedNeutronRate) ) != 0 ) goto err;
            product->delayedNeutronIndex = *delayedNeutronIndex;
            (*delayedNeutronIndex)++;
        }
    }
 
    if( ( multiplicityStr = xDataTOM_getAttributesValueInElement( element, "multiplicity" ) ) == NULL ) goto err;
    if( xDataTOME_convertAttributeToInteger( NULL, element, "multiplicity", &(product->multiplicity) ) ) {
        if( strcmp( multiplicityStr, "energyDependent" ) ) {
            smr_setReportError2( smr, smr_unknownID, 1, "invalid multiplicity '%s' for product '%s'", multiplicityStr, name );
            goto err;
        }
        if( ( multiplicity = xDataTOME_getOneElementByName( smr, element, "multiplicity", 1 ) ) == NULL ) goto err;
        if( ( multiplicityTOM = xDataTOME_getOneElementByName( NULL, multiplicity, "weightedReference", 0 ) ) != NULL ) {
            if( MCGIDI_product_parseWeightedReferenceMultiplicityFromTOM( smr, multiplicityTOM, product, &multiplicityVsEnergy, &norms1 ) ) goto err; }
        else if( ( multiplicityTOM = xDataTOME_getOneElementByName( NULL, multiplicity, "piecewise", 0 ) ) != NULL ) {
            if( MCGIDI_product_parsePiecewiseMultiplicity( smr, multiplicityTOM, product ) ) goto err; }
        else if( ( multiplicityTOM = xDataTOME_getOneElementByName( NULL, multiplicity, "polynomial", 0 ) ) != NULL ) {
            if( ( multiplicityVsEnergy = MCGIDI_product_parsePolynomialMultiplicity( smr, multiplicityTOM, product ) ) == NULL ) goto err; }
        else {
/* ??????? Need to check interpolation. */
            if( ( multiplicityTOM = xDataTOME_getOneElementByName( smr, multiplicity, "pointwise", 1 ) ) == NULL ) goto err;
            if( ( multiplicityVsEnergy = MCGIDI_misc_dataFromElement2ptwXYPointsInUnitsOf( smr, multiplicityTOM, multiplicityUnits ) ) == NULL ) goto err;
        }
    }
 
    if( strcmp( product->pop->name, "gamma" ) == 0 ) {
        if( ( norms2 = ptwXY_new( ptwXY_interpolationLinLin, NULL, 2., 1e-3, 200, 10, &status, 0 ) ) == NULL ) {
            smr_setReportError2( smr, smr_unknownID, 1, "ptwXY_new err = %d: %s\n", status, nfu_statusMessage( status ) );
            goto err;
        }
    }
    if( MCGIDI_distribution_parseFromTOM( smr, element, product, pops, norms2 ) ) goto err;
    if( norms2 != NULL ) {
        if( ptwXY_length( norms2 ) < 2 ) {
            norms2 = ptwXY_free( norms2 ); }
        else {
            if( ptwXY_simpleCoalescePoints( norms2 ) != nfu_Okay ) goto err;
            if( ( ptwXY_getYMin( norms2 ) > 0.99 ) && ( ptwXY_getYMax( norms2 ) < 1.01 ) ) norms2 = ptwXY_free( norms2 );
        }
    }
    if( ( norms1 != NULL ) && ( norms2 != NULL ) ) {
        smr_setReportError2p( smr, smr_unknownID, 1, "norm1 and norm2 are both not NULL" );
        goto err;
    }
 
    product->multiplicityVsEnergy = multiplicityVsEnergy;
    product->norms = norms1;
    if( norms2 != NULL ) product->norms = norms2;
 
    if( ( decayChannelElement = xDataTOME_getOneElementByName( NULL, element, "decayChannel", 0 ) ) != NULL ) {
        if( MCGIDI_outputChannel_parseFromTOM( smr, decayChannelElement, pops, &(product->decayChannel), NULL, product ) ) goto err;
    }
 
    return( 0 );
 
err:
    if( multiplicityVsEnergy != NULL ) ptwXY_free( multiplicityVsEnergy );
    if( norms1 != NULL ) ptwXY_free( norms1 );
    if( norms2 != NULL ) ptwXY_free( norms2 );
    MCGIDI_product_release( smr, product );
    return( 1 );
}

Referenced by MCGIDI_outputChannel_parseFromTOM().

MCGIDI_product_release()

int MCGIDI_product_release	(	statusMessageReporting *	smr,
		MCGIDI_product *	product
	)

Definition at line 60 of file MCGIDI_product.cc.

                                                                                   {
 
    int i;
 
    if( product->label != NULL ) smr_freeMemory( (void **) &(product->label) );
 
    if( product->multiplicityVsEnergy != NULL ) ptwXY_free( product->multiplicityVsEnergy );
    if( product->piecewiseMultiplicities != NULL ) {
        for( i = 0; i < product->numberOfPiecewiseMultiplicities; i++ ) ptwXY_free( product->piecewiseMultiplicities[i] );
        smr_freeMemory( (void **) &(product->piecewiseMultiplicities) );
    }
    if( product->norms != NULL ) ptwXY_free( product->norms );
 
    MCGIDI_distribution_release( smr, &(product->distribution) );
    MCGIDI_outputChannel_release( smr, &(product->decayChannel) );
 
    MCGIDI_product_initialize( smr, product );
    return( 0 );
}

Referenced by MCGIDI_outputChannel_release(), MCGIDI_product_free(), and MCGIDI_product_parseFromTOM().

MCGIDI_product_sampleMu()

int MCGIDI_product_sampleMu	(	statusMessageReporting *	smr,
		MCGIDI_product *	product,
		MCGIDI_quantitiesLookupModes &	modes,
		MCGIDI_decaySamplingInfo *	decaySamplingInfo
	)

Definition at line 348 of file MCGIDI_product.cc.

                                                      {
 
    if( product->distribution.type != MCGIDI_distributionType_angular_e ) {
        smr_setReportError2( smr, smr_unknownID, 1, "product distribution is not angular: type = %d", product->distribution.type );
        return( 1 );
    }
    return( MCGIDI_angular_sampleMu( smr, product->distribution.angular, modes, decaySamplingInfo ) );
}

Referenced by G4GIDI_target::getElasticFinalState().

MCGIDI_product_sampleMultiplicity()

int MCGIDI_product_sampleMultiplicity	(	statusMessageReporting *	smr,
		MCGIDI_product *	product,
		double	e_in,
		double	r
	)

Definition at line 325 of file MCGIDI_product.cc.

                                                                                                                    {
 
    int i, multiplicity;
    double y, norm = 1.0;
    ptwXYPoints *ptwXY = product->multiplicityVsEnergy;
 
    if( product->piecewiseMultiplicities != NULL ) {
        for( i = 0; i < product->numberOfPiecewiseMultiplicities - 1; i++ ) {
            if( e_in < ptwXY_getXMax( product->piecewiseMultiplicities[i] ) ) break;
        }
        ptwXY = product->piecewiseMultiplicities[i];
    }
    y = MCGIDI_sampling_ptwXY_getValueAtX( ptwXY, e_in );
    if( product->norms != NULL ) norm = MCGIDI_sampling_ptwXY_getValueAtX( product->norms, e_in );
    y *= norm;
    multiplicity = (int) y;
    if( r < ( y - multiplicity ) ) multiplicity++;
 
    return( multiplicity );
}

Referenced by MCGIDI_outputChannel_sampleProductsAtE().

MCGIDI_product_setTwoBodyMasses()

int MCGIDI_product_setTwoBodyMasses	(	statusMessageReporting *	smr,
		MCGIDI_product *	product,
		double	projectileMass_MeV,
		double	targetMass_MeV,
		double	productMass_MeV,
		double	residualMass_MeV
	)

Definition at line 289 of file MCGIDI_product.cc.

                                                      {
 
    return( MCGIDI_angular_setTwoBodyMasses( smr, product->distribution.angular, projectileMass_MeV, targetMass_MeV, productMass_MeV, residualMass_MeV ) );
}

Referenced by MCGIDI_outputChannel_parseFromTOM().

MCGIDI_productsInfo_getIntegerMultiplicityAtIndex()

int MCGIDI_productsInfo_getIntegerMultiplicityAtIndex	(	MCGIDI_productsInfo *	productsInfo,
		int	index
	)

Definition at line 550 of file MCGIDI_reaction.cc.

                                                                                                      {
 
    if( ( index < 0 ) || ( index >= productsInfo->numberOfProducts ) ) return( -1 );
    return( productsInfo->productInfo[index].multiplicity );
}

MCGIDI_productsInfo_getMultiplicityTypeAtIndex()

enum MCGIDI_productMultiplicityType MCGIDI_productsInfo_getMultiplicityTypeAtIndex	(	MCGIDI_productsInfo *	productsInfo,
		int	index
	)

Definition at line 542 of file MCGIDI_reaction.cc.

                                                                                                                                   {
 
    if( ( index < 0 ) || ( index >= productsInfo->numberOfProducts ) ) return( MCGIDI_productMultiplicityType_invalid_e );
    return( productsInfo->productInfo[index].productMultiplicityType );
}

MCGIDI_productsInfo_getNumberOfUniqueProducts()

int MCGIDI_productsInfo_getNumberOfUniqueProducts

(

MCGIDI_productsInfo *

productsInfo

)

Definition at line 527 of file MCGIDI_reaction.cc.

                                                                                       {
 
    return( productsInfo->numberOfProducts );
}

MCGIDI_productsInfo_getPoPsIndexAtIndex()

int MCGIDI_productsInfo_getPoPsIndexAtIndex	(	MCGIDI_productsInfo *	productsInfo,
		int	index
	)

Definition at line 534 of file MCGIDI_reaction.cc.

                                                                                            {
 
    if( ( index < 0 ) || ( index >= productsInfo->numberOfProducts ) ) return( -1 );
    return( productsInfo->productInfo[index].globalPoPsIndex );
}

MCGIDI_productsInfo_getTransportableAtIndex()

int MCGIDI_productsInfo_getTransportableAtIndex	(	MCGIDI_productsInfo *	productsInfo,
		int	index
	)

Definition at line 558 of file MCGIDI_reaction.cc.

                                                                                                {
 
    if( ( index < 0 ) || ( index >= productsInfo->numberOfProducts ) ) return( -1 );
    return( productsInfo->productInfo[index].transportable );
}

MCGIDI_reaction_fixDomains()

int MCGIDI_reaction_fixDomains	(	statusMessageReporting *	smr,
		MCGIDI_reaction *	reaction,
		double	EMin,
		double	EMax,
		nfu_status *	status
	)

Definition at line 366 of file MCGIDI_reaction.cc.

                                                                                                                                      {
 
    double lowerEps = 1e-14, upperEps = -1e-14;
 
    if( reaction->EMin == EMin ) lowerEps = 0.;
    if( reaction->EMax == EMax ) upperEps = 0.;
    if( ( lowerEps == 0. ) && ( upperEps == 0. ) ) return( 0 );
 
    *status = ptwXY_dullEdges( reaction->crossSection, lowerEps, upperEps, 1 );
    return( *status != nfu_Okay );
}

Referenced by MCGIDI_target_heated_read().

MCGIDI_reaction_free()

MCGIDI_reaction * MCGIDI_reaction_free	(	statusMessageReporting *	smr,
		MCGIDI_reaction *	reaction
	)

Definition at line 60 of file MCGIDI_reaction.cc.

                                                                                                {
 
    MCGIDI_reaction_release( smr, reaction );
    smr_freeMemory( (void **) &reaction );
    return( NULL );
}

Referenced by MCGIDI_reaction_new().

MCGIDI_reaction_getCrossSectionAtE()

double MCGIDI_reaction_getCrossSectionAtE	(	statusMessageReporting *	smr,
		MCGIDI_reaction *	reaction,
		MCGIDI_quantitiesLookupModes &	modes,
		bool	sampling
	)

Definition at line 380 of file MCGIDI_reaction.cc.

                        {
 
    double e_in = modes.getProjectileEnergy( ), xsec;
 
    if( modes.getCrossSectionMode( ) == MCGIDI_quantityLookupMode_pointwise ) {
        if( e_in < reaction->EMin ) e_in = reaction->EMin;
        if( e_in > reaction->EMax ) e_in = reaction->EMax;
        ptwXY_getValueAtX( reaction->crossSection, e_in, &xsec ); }
    else if( modes.getCrossSectionMode( ) == MCGIDI_quantityLookupMode_grouped ) {
        int index = modes.getGroupIndex( );
        double *xSecP = ptwX_getPointAtIndex( reaction->crossSectionGrouped, index );
 
        if( xSecP != NULL ) {
            xsec = *xSecP;
            if( sampling && ( index == reaction->thresholdGroupIndex ) ) xsec += reaction->thresholdGroupedDeltaCrossSection; }
        else {
            xsec = 0.;
            smr_setReportError2( smr, smr_unknownID, 1, "Invalid cross section group index %d", index );
        } }
    else {
        xsec = 0.;
    }
    return( xsec );
}

Referenced by MCGIDI_target_heated_getIndexReactionCrossSectionAtE().

MCGIDI_reaction_getDomain()

int MCGIDI_reaction_getDomain	(	statusMessageReporting *	smr,
		MCGIDI_reaction *	reaction,
		double *	EMin,
		double *	EMax
	)

Definition at line 350 of file MCGIDI_reaction.cc.

                                                                                                                   {
/*
*   Return value
*       <  0    No cross section data.
*       == 0    Okay and EMin and EMax set.
*       >  0    error, EMin and EMax undefined.
*/
 
    if( !reaction->domainValuesPresent ) return( -1 );
    *EMin = reaction->EMin;
    *EMax = reaction->EMax;
    return( 0 );
}

Referenced by MCGIDI_outputChannel_getDomain(), and MCGIDI_target_heated_read().

MCGIDI_reaction_getENDF_MTNumber()

int MCGIDI_reaction_getENDF_MTNumber

(

MCGIDI_reaction *

reaction

)

Definition at line 415 of file MCGIDI_reaction.cc.

                                                                  {
 
    return( reaction->ENDF_MT );
}

Referenced by G4GIDI_target::init().

MCGIDI_reaction_getENDL_CSNumbers()

int MCGIDI_reaction_getENDL_CSNumbers	(	MCGIDI_reaction *	reaction,
		int *	S
	)

Definition at line 422 of file MCGIDI_reaction.cc.

                                                                           {
 
    if( S != NULL ) *S = reaction->ENDL_S;
    return( reaction->ENDL_C );
}

MCGIDI_reaction_getFinalQ()

double MCGIDI_reaction_getFinalQ	(	statusMessageReporting *	smr,
		MCGIDI_reaction *	reaction,
		MCGIDI_quantitiesLookupModes &	modes
	)

Definition at line 408 of file MCGIDI_reaction.cc.

                                                                                                                           {
 
    return( reaction->finalQ );
}

Referenced by MCGIDI_target_heated_getIndexReactionFinalQ().

MCGIDI_reaction_getProductsInfo()

MCGIDI_productsInfo * MCGIDI_reaction_getProductsInfo

(

MCGIDI_reaction *

reaction

)

Definition at line 489 of file MCGIDI_reaction.cc.

                                                                                  {
 
    return( &(reaction->productsInfo) );
}

MCGIDI_reaction_getProjectileMass_MeV()

double MCGIDI_reaction_getProjectileMass_MeV	(	statusMessageReporting *	smr,
		MCGIDI_reaction *	reaction
	)

Definition at line 336 of file MCGIDI_reaction.cc.

                                                                                                       {
 
    return( MCGIDI_target_heated_getProjectileMass_MeV( smr, reaction->target ) );
}

Referenced by MCGIDI_outputChannel_getProjectileMass_MeV(), MCGIDI_outputChannel_parseFromTOM(), and MCGIDI_outputChannel_sampleProductsAtE().

MCGIDI_reaction_getReactionType()

enum MCGIDI_reactionType MCGIDI_reaction_getReactionType	(	statusMessageReporting *	smr,
		MCGIDI_reaction *	reaction
	)

Definition at line 322 of file MCGIDI_reaction.cc.

                                                                                                                  {
 
    return( reaction->reactionType );
}

Referenced by MCGIDI_target_getReactionTypeAtIndex().

MCGIDI_reaction_getTargetHeated()

MCGIDI_target_heated * MCGIDI_reaction_getTargetHeated	(	statusMessageReporting *	smr,
		MCGIDI_reaction *	reaction
	)

Definition at line 329 of file MCGIDI_reaction.cc.

                                                                                                               {
 
    return( reaction->target );
}

Referenced by MCGIDI_outputChannel_getTargetHeated().

MCGIDI_reaction_getTargetMass_MeV()

double MCGIDI_reaction_getTargetMass_MeV	(	statusMessageReporting *	smr,
		MCGIDI_reaction *	reaction
	)

Definition at line 343 of file MCGIDI_reaction.cc.

                                                                                                   {
 
    return( MCGIDI_target_heated_getTargetMass_MeV( smr, reaction->target ) );
}

Referenced by MCGIDI_outputChannel_getTargetMass_MeV(), MCGIDI_outputChannel_parseFromTOM(), and MCGIDI_outputChannel_sampleProductsAtE().

MCGIDI_reaction_initialize()

int MCGIDI_reaction_initialize	(	statusMessageReporting *	smr,
		MCGIDI_reaction *	reaction
	)

Definition at line 42 of file MCGIDI_reaction.cc.

                                                                                         {
 
    if( MCGIDI_reaction_initialize2( smr, reaction ) != 0 ) return( 1 );
    reaction->transportabilities = new transportabilitiesMap( );
    return( 0 );
}

Referenced by MCGIDI_reaction_new(), and MCGIDI_reaction_parseFromTOM().

MCGIDI_reaction_new()

MCGIDI_reaction * MCGIDI_reaction_new

(

statusMessageReporting *

smr

)

Definition at line 31 of file MCGIDI_reaction.cc.

                                                                    {
 
    MCGIDI_reaction *reaction;
 
    if( ( reaction = (MCGIDI_reaction *) smr_malloc2( smr, sizeof( MCGIDI_reaction ), 0, "reaction" ) ) == NULL ) return( NULL );
    if( MCGIDI_reaction_initialize( smr, reaction ) ) reaction = MCGIDI_reaction_free( smr, reaction );
    return( reaction );
}

MCGIDI_reaction_parseFromTOM()

int MCGIDI_reaction_parseFromTOM	(	statusMessageReporting *	smr,
		xDataTOM_element *	element,
		MCGIDI_target_heated *	target,
		MCGIDI_POPs *	pops,
		MCGIDI_reaction *	reaction
	)

Definition at line 84 of file MCGIDI_reaction.cc.

                                                       {
 
    xDataTOM_element *child, *linear, *outputChannel;
    enum xDataTOM_interpolationFlag independent, dependent;
    enum xDataTOM_interpolationQualifier qualifier;
    char const *outputChannelStr, *crossSectionUnits[2] = { "MeV", "b" };
 
    MCGIDI_reaction_initialize( smr, reaction );
 
    reaction->target = target;
    reaction->reactionType = MCGIDI_reactionType_unknown_e;
    if( xDataTOME_copyAttributionList( smr, &(reaction->attributes), element ) ) goto err;
    if( xDataTOME_convertAttributeToInteger( smr, element, "ENDF_MT", &(reaction->ENDF_MT) ) ) goto err;
    if( ( outputChannelStr = xDataTOM_getAttributesValueInElement( element, "outputChannel" ) ) == NULL ) goto err;
    if( ( reaction->outputChannelStr = smr_allocateCopyString2( smr, outputChannelStr, "reaction->outputChannelStr" ) ) == NULL ) goto err;
 
    if( ( child = xDataTOME_getOneElementByName( smr, element, "crossSection", 1 ) ) == NULL ) goto err;
    if( ( linear = xDataTOME_getOneElementByName( smr, child, "linear", 0 ) ) == NULL ) {
        if( ( linear = xDataTOME_getOneElementByName( smr, child, "pointwise", 1 ) ) == NULL ) goto err;
    }
    if( xDataTOME_getInterpolation( smr, linear, 0, &independent, &dependent, &qualifier ) ) goto err;
    if( ( independent != xDataTOM_interpolationFlag_linear ) || ( dependent != xDataTOM_interpolationFlag_linear ) ) {
        smr_setReportError2( smr, smr_unknownID, 1, "cross section interpolation (%d,%d) is not linear-linear", independent, dependent );
        goto err;
    }
    if( ( reaction->crossSection = MCGIDI_misc_dataFromElement2ptwXYPointsInUnitsOf( smr, linear, crossSectionUnits ) ) == NULL ) goto err;
    reaction->domainValuesPresent = 1;
    reaction->EMin = ptwXY_getXMin( reaction->crossSection );
    reaction->EMax = ptwXY_getXMax( reaction->crossSection );
 
    if( ( outputChannel = xDataTOME_getOneElementByName( smr, element, "outputChannel", 1 ) ) == NULL ) goto err;
    if( MCGIDI_outputChannel_parseFromTOM( smr, outputChannel, pops, &(reaction->outputChannel), reaction, NULL ) ) goto err;
 
    if( MCGIDI_reaction_ParseReactionTypeAndDetermineProducts( smr, pops, reaction ) != 0 ) goto err;
 
    return( 0 );
 
err:
    MCGIDI_reaction_release( smr, reaction );
    return( 1 );
}

MCGIDI_reaction_recast()

int MCGIDI_reaction_recast	(	statusMessageReporting *	smr,
		MCGIDI_reaction *	reaction,
		GIDI_settings &	settings,
		GIDI_settings_particle const *	projectileSettings,
		double	temperature_MeV,
		ptwXPoints *	totalGroupedCrossSection
	)

Definition at line 496 of file MCGIDI_reaction.cc.

                                                                                                                         {
 
    if( totalGroupedCrossSection != NULL ) {
        nfu_status status_nf;
        GIDI_settings_group group( projectileSettings->getGroup( ) );
 
        if( reaction->crossSectionGrouped != NULL ) reaction->crossSectionGrouped = ptwX_free( reaction->crossSectionGrouped );
        if( ( reaction->crossSectionGrouped = projectileSettings->groupFunction( smr, reaction->crossSection, temperature_MeV, 0 ) ) == NULL ) return( 1 );
        if( ( status_nf = ptwX_add_ptwX( totalGroupedCrossSection, reaction->crossSectionGrouped ) ) != nfu_Okay ) return( 1 );
 
        reaction->thresholdGroupDomain = reaction->thresholdGroupedDeltaCrossSection = 0.;
        reaction->thresholdGroupIndex = group.getGroupIndexFromEnergy( reaction->EMin, false );
        if( reaction->thresholdGroupIndex > -1 ) {
            reaction->thresholdGroupDomain = group[reaction->thresholdGroupIndex+1] - reaction->EMin;
            if( reaction->thresholdGroupDomain > 0 ) {
                                                            /* factor 2 for linear reject in bin but above threshold. */
                reaction->thresholdGroupedDeltaCrossSection = *ptwX_getPointAtIndex( reaction->crossSectionGrouped, reaction->thresholdGroupIndex ) *
                        ( 2 * ( group[reaction->thresholdGroupIndex+1] - group[reaction->thresholdGroupIndex] ) / reaction->thresholdGroupDomain - 1 );
            }
        }
    }
    return( 0 );
}

Referenced by MCGIDI_target_heated_recast().

MCGIDI_reaction_release()

int MCGIDI_reaction_release	(	statusMessageReporting *	smr,
		MCGIDI_reaction *	reaction
	)

Definition at line 69 of file MCGIDI_reaction.cc.

                                                                                      {
 
    ptwXY_free( reaction->crossSection );
    ptwX_free( reaction->crossSectionGrouped );
    MCGIDI_outputChannel_release( smr, &(reaction->outputChannel) );
    xDataTOMAL_release( &(reaction->attributes) );
    smr_freeMemory( (void **) &(reaction->outputChannelStr) );
    if( reaction->productsInfo.productInfo != NULL ) smr_freeMemory( (void **) &(reaction->productsInfo.productInfo) );
    delete reaction->transportabilities;
    MCGIDI_reaction_initialize2( smr, reaction );
    return( 0 );
}

Referenced by MCGIDI_reaction_free(), MCGIDI_reaction_parseFromTOM(), and MCGIDI_target_heated_release().

MCGIDI_sampledProducts_addProduct()

int MCGIDI_sampledProducts_addProduct	(	statusMessageReporting *	smr,
		MCGIDI_sampledProductsDatas *	sampledProductsDatas,
		MCGIDI_sampledProductsData *	sampledProductsData
	)

Definition at line 398 of file MCGIDI_product.cc.

                                                                                                                                                                         {
 
    if( sampledProductsDatas->numberOfProducts == sampledProductsDatas->numberAllocated ) {
        if( ( MCGIDI_sampledProducts_remalloc( smr, sampledProductsDatas ) ) != 0 ) return( 1 );
    }
    sampledProductsDatas->products[sampledProductsDatas->numberOfProducts] = *sampledProductsData;
    sampledProductsDatas->numberOfProducts++;
    return( 0 );
}

Referenced by MCGIDI_outputChannel_sampleProductsAtE(), and MCGIDI_target_sampleNullReactionProductsAtE().

MCGIDI_sampledProducts_getProductAtIndex()

MCGIDI_sampledProductsData * MCGIDI_sampledProducts_getProductAtIndex	(	MCGIDI_sampledProductsDatas *	sampledProductsDatas,
		int	index
	)

Definition at line 417 of file MCGIDI_product.cc.

                                                                                                                                     {
 
    if( index < 0 ) return( NULL );
    if( index >= sampledProductsDatas->numberOfProducts ) return( NULL );
    return( &(sampledProductsDatas->products[index]) );
}

MCGIDI_sampledProducts_initialize()

int MCGIDI_sampledProducts_initialize	(	statusMessageReporting *	smr,
		MCGIDI_sampledProductsDatas *	sampledProductsDatas,
		int	incrementSize
	)

Definition at line 362 of file MCGIDI_product.cc.

                                                                                                                                           {
 
    if( incrementSize < 10 ) incrementSize = 10;
    sampledProductsDatas->numberOfProducts = 0;
    sampledProductsDatas->numberAllocated = 0;
    sampledProductsDatas->incrementSize = incrementSize;
    sampledProductsDatas->products = NULL;
    return( MCGIDI_sampledProducts_remalloc( smr, sampledProductsDatas ) );
}

Referenced by G4GIDI_target::getFinalState().

MCGIDI_sampledProducts_number()

int MCGIDI_sampledProducts_number

(

MCGIDI_sampledProductsDatas *

sampledProductsDatas

)

Definition at line 410 of file MCGIDI_product.cc.

                                                                                       {
 
    return( sampledProductsDatas->numberOfProducts );
}

MCGIDI_sampledProducts_release()

int MCGIDI_sampledProducts_release	(	statusMessageReporting *	smr,
		MCGIDI_sampledProductsDatas *	sampledProductsDatas
	)

Definition at line 374 of file MCGIDI_product.cc.

                                                                                                                    {
 
    smr_freeMemory( (void **) &(sampledProductsDatas->products) );
    return( 0 );
}

Referenced by G4GIDI_target::getFinalState().

MCGIDI_sampledProducts_remalloc()

int MCGIDI_sampledProducts_remalloc	(	statusMessageReporting *	smr,
		MCGIDI_sampledProductsDatas *	sampledProductsDatas
	)

Definition at line 382 of file MCGIDI_product.cc.

                                                                                                                      {
 
    int size = sampledProductsDatas->numberAllocated + sampledProductsDatas->incrementSize;
 
    if( ( sampledProductsDatas->products = (MCGIDI_sampledProductsData *) smr_realloc2( smr, sampledProductsDatas->products, 
        size * sizeof( MCGIDI_sampledProductsData ), "products" ) ) != NULL ) {
        sampledProductsDatas->numberAllocated = size;
        return( 0 );
    }
    sampledProductsDatas->numberOfProducts = 0;
    sampledProductsDatas->numberAllocated = 0;
    return( 1 );
}

Referenced by MCGIDI_sampledProducts_addProduct(), and MCGIDI_sampledProducts_initialize().

MCGIDI_sampling_doubleDistribution()

int MCGIDI_sampling_doubleDistribution	(	statusMessageReporting *	smr,
		MCGIDI_pdfsOfXGivenW *	pdfOfWGivenV,
		MCGIDI_pdfsOfXGivenW *	pdfOfXGivenVAndW,
		MCGIDI_quantitiesLookupModes &	modes,
		MCGIDI_decaySamplingInfo *	decaySamplingInfo
	)

Definition at line 141 of file MCGIDI_sampling.cc.

                                                                                           {
 
    int iV;
    double e_in = modes.getProjectileEnergy( );
    double randomW = decaySamplingInfo->rng( decaySamplingInfo->rngState ), randomX = decaySamplingInfo->rng( decaySamplingInfo->rngState );
    MCGIDI_pdfsOfXGivenW_sampled sampledX, sampledW;
    ptwXY_interpolation interpolationWY = pdfOfWGivenV->interpolationWY; 
 
    sampledX.smr = smr;
    sampledW.smr = smr;
    sampledW.interpolationXY = pdfOfWGivenV->interpolationXY;
    iV = MCGIDI_misc_binarySearch( pdfOfWGivenV->numberOfWs, pdfOfWGivenV->Ws, e_in );
    if( iV < 0 ) {
        interpolationWY = ptwXY_interpolationFlat;
        if( iV == -2 ) {
            iV = 0; }
        else {
            iV = pdfOfWGivenV->numberOfWs - 1;
        }
        e_in = pdfOfWGivenV->Ws[iV];
    }
        
    MCGIDI_sampling_sampleX_from_pdfOfX( &(pdfOfWGivenV->dist[iV]), &sampledW, randomW );
    sampledX.w = sampledW.x;
    MCGIDI_sampling_sampleX_from_pdfsOfXGivenW( &(pdfOfXGivenVAndW[iV]), &sampledX, randomX );
 
    if( interpolationWY != ptwXY_interpolationFlat ) {
        double x = sampledX.x, w = sampledW.x, Vs[3] = { e_in, pdfOfWGivenV->Ws[iV], pdfOfWGivenV->Ws[iV+1] };
 
        MCGIDI_sampling_sampleX_from_pdfOfX( &(pdfOfWGivenV->dist[iV+1]), &sampledW, randomW );
        sampledX.w = sampledW.x;
        MCGIDI_sampling_sampleX_from_pdfsOfXGivenW( &(pdfOfXGivenVAndW[iV+1]), &sampledX, randomX );
 
        MCGIDI_sampling_interpolationValues( smr, interpolationWY, Vs, w, sampledW.x, &sampledW.x );
        MCGIDI_sampling_interpolationValues( smr, interpolationWY, Vs, x, sampledX.x, &sampledX.x );
    }
    
    decaySamplingInfo->mu = sampledW.x;
    decaySamplingInfo->Ep = sampledX.x;
 
    return( 0 );
}

Referenced by MCGIDI_angularEnergy_sampleDistribution(), and MCGIDI_energyAngular_sampleDistribution().

MCGIDI_sampling_interpolationValues()

int MCGIDI_sampling_interpolationValues	(	statusMessageReporting *	smr,
		ptwXY_interpolation	interpolation,
		double *	ws,
		double	y1,
		double	y2,
		double *	y
	)

Definition at line 187 of file MCGIDI_sampling.cc.

                                                                                                                                                       {
 
    double frac;
 
    if( interpolation == ptwXY_interpolationLinLin ) {
        frac = ( ws[2] - ws[0] ) / ( ws[2] - ws[1] );
        *y = frac * y1 + ( 1 - frac ) * y2; }
    else if( interpolation == ptwXY_interpolationLogLin ) {
        frac = G4Log( ws[2] / ws[0] ) / G4Log( ws[2] / ws[1] );
        *y = frac * y1 + ( 1 - frac ) * y2; }
    else if( interpolation == ptwXY_interpolationLinLog ) {
        frac = ( ws[2] - ws[0] ) / ( ws[2] - ws[1] );
        *y = y1 * G4Pow::GetInstance()->powA( y2 / y1, frac ); }
    else if( interpolation == ptwXY_interpolationLogLog ) {
        frac = G4Log( ws[2] / ws[0] ) / G4Log( ws[2] / ws[1] );
        *y = y2 * G4Pow::GetInstance()->powA( y2 / y1, frac ); }
    else {  // This should never happen.
        smr_setReportError2( smr, smr_unknownID, 1, "bad interpolation = %d\n", interpolation );
        return( 1 );
    }
    return( 0 );
}

Referenced by MCGIDI_sampling_doubleDistribution().

MCGIDI_sampling_pdfsOfX_release()

int MCGIDI_sampling_pdfsOfX_release	(	statusMessageReporting *	smr,
		MCGIDI_pdfOfX *	dist
	)

Definition at line 41 of file MCGIDI_sampling.cc.

                                                                                       {
 
    smr_freeMemory( (void **) &(dist->Xs) );
    return( 0 );
}

Referenced by MCGIDI_energy_release(), and MCGIDI_sampling_pdfsOfXGivenW_release().

MCGIDI_sampling_pdfsOfXGivenW_initialize()

int MCGIDI_sampling_pdfsOfXGivenW_initialize	(	statusMessageReporting *	smr,
		MCGIDI_pdfsOfXGivenW *	dists
	)

Definition at line 20 of file MCGIDI_sampling.cc.

                                                                                                        {
 
    memset( dists, 0, sizeof( MCGIDI_pdfsOfXGivenW ) );
    return( 0 );
}

Referenced by MCGIDI_sampling_pdfsOfXGivenW_release().

MCGIDI_sampling_pdfsOfXGivenW_release()

int MCGIDI_sampling_pdfsOfXGivenW_release	(	statusMessageReporting *	smr,
		MCGIDI_pdfsOfXGivenW *	dists
	)

Definition at line 28 of file MCGIDI_sampling.cc.

                                                                                                      {
 
    int i;
 
    for( i = 0; i < dists->numberOfWs; i++ ) MCGIDI_sampling_pdfsOfX_release( smr, &(dists->dist[i]) );
    smr_freeMemory( (void **) &(dists->Ws) );
    smr_freeMemory( (void **) &(dists->dist) );
    MCGIDI_sampling_pdfsOfXGivenW_initialize( smr, dists );
    return( 0 );
}

Referenced by MCGIDI_angular_release(), MCGIDI_angularEnergy_release(), MCGIDI_energy_release(), and MCGIDI_energyAngular_release().

MCGIDI_sampling_ptwXY_getValueAtX()

double MCGIDI_sampling_ptwXY_getValueAtX	(	ptwXYPoints *	ptwXY,
		double	x1
	)

Definition at line 212 of file MCGIDI_sampling.cc.

                                                                          {
 
    double y1;
 
    if( ptwXY_getValueAtX( ptwXY, x1, &y1 ) == nfu_XOutsideDomain ) {
        if( x1 < ptwXY_getXMin( ptwXY ) ) {
            ptwXY_getValueAtX( ptwXY, ptwXY_getXMin( ptwXY ), &y1 ); }
        else {
            ptwXY_getValueAtX( ptwXY, ptwXY_getXMax( ptwXY ), &y1 );
        }
    }
    return( y1 );
}

Referenced by MCGIDI_energy_sampleEnergy(), and MCGIDI_product_sampleMultiplicity().

MCGIDI_sampling_sampleX_from_pdfOfX()

int MCGIDI_sampling_sampleX_from_pdfOfX	(	MCGIDI_pdfOfX *	dist,
		MCGIDI_pdfsOfXGivenW_sampled *	sampled,
		double	r
	)

Definition at line 98 of file MCGIDI_sampling.cc.

                                                                                                                       {
 
    int iX;
    double d1, d2, frac;
 
    iX = sampled->iX1 = MCGIDI_misc_binarySearch( dist->numberOfXs, dist->cdf, rngValue );
 
    if( iX < 0 ) {                 /* This should never happen. */
        smr_setReportError2( sampled->smr, smr_unknownID, 1, "bad iX = %d\n", iX );
        sampled->x = dist->Xs[0];
        return( 1 );
    }
    if( sampled->interpolationXY == ptwXY_interpolationFlat ) {
        frac = ( dist->cdf[iX+1] - rngValue ) / ( dist->cdf[iX+1] - dist->cdf[iX] );
        sampled->x = frac * dist->Xs[iX] + ( 1 - frac ) * dist->Xs[iX+1]; }
    else {
        double s1 = dist->pdf[iX+1] - dist->pdf[iX];
 
        if( s1 == 0. ) {
            if( dist->pdf[iX] == 0 ) {
                sampled->x = dist->Xs[iX];
                if( iX == 0 ) sampled->x = dist->Xs[1]; }
            else {
                frac = ( dist->cdf[iX+1] - rngValue ) / ( dist->cdf[iX+1] - dist->cdf[iX] );
                sampled->x = frac * dist->Xs[iX] + ( 1 - frac ) * dist->Xs[iX+1];
            } }
        else {
            s1 = s1 / ( dist->Xs[iX+1] - dist->Xs[iX] );
            d1 = rngValue - dist->cdf[iX];
            d2 = dist->cdf[iX+1] - rngValue;
            if( d2 > d1 ) {     /* Closer to iX. */
                sampled->x = dist->Xs[iX] + ( std::sqrt( dist->pdf[iX] * dist->pdf[iX] + 2. * s1 * d1 ) - dist->pdf[iX] ) / s1; }
            else {              /* Closer to iX + 1. */
                sampled->x = dist->Xs[iX+1] - ( dist->pdf[iX+1] - std::sqrt( dist->pdf[iX+1] * dist->pdf[iX+1] - 2. * s1 * d2 ) ) / s1;
            }
        }
    }
 
    return( 0 );
}

Referenced by MCGIDI_energy_sampleEnergy(), MCGIDI_sampling_doubleDistribution(), and MCGIDI_sampling_sampleX_from_pdfsOfXGivenW().

MCGIDI_sampling_sampleX_from_pdfsOfXGivenW()

int MCGIDI_sampling_sampleX_from_pdfsOfXGivenW	(	MCGIDI_pdfsOfXGivenW *	dists,
		MCGIDI_pdfsOfXGivenW_sampled *	sampled,
		double	r
	)

Definition at line 49 of file MCGIDI_sampling.cc.

                                                                                                                                      {
 
    int iW, iX1;
 
    sampled->interpolationWY = dists->interpolationWY;
    sampled->interpolationXY = dists->interpolationXY;
    iW = sampled->iW = MCGIDI_misc_binarySearch( dists->numberOfWs, dists->Ws, sampled->w );
    sampled->frac = 1;
 
    if( iW == -2 ) {            /* w < first value of Ws. */
        return( MCGIDI_sampling_sampleX_from_pdfOfX( dists->dist, sampled, rngValue ) ); }
    else if( iW == -1 ) {       /* w > last value of Ws. */
        return( MCGIDI_sampling_sampleX_from_pdfOfX( &(dists->dist[dists->numberOfWs-1]), sampled, rngValue ) ); }
    else {
        if( MCGIDI_sampling_sampleX_from_pdfOfX( &(dists->dist[iW]), sampled, rngValue ) ) return( 1 );
        if( dists->interpolationWY != ptwXY_interpolationFlat ) {    // ptwXY_interpolationOther was not allowed at startup.
            double xSampled = sampled->x, frac = 1.;
 
            iX1 = sampled->iX1;
            if( MCGIDI_sampling_sampleX_from_pdfOfX( &(dists->dist[iW+1]), sampled, rngValue ) ) return( 1 );
 
            if( dists->interpolationWY == ptwXY_interpolationLinLin ) {
                frac = ( dists->Ws[iW+1] - sampled->w ) / ( dists->Ws[iW+1] - dists->Ws[iW] );
                sampled->x = frac * xSampled + ( 1 - frac ) * sampled->x; }
            else if( dists->interpolationWY == ptwXY_interpolationLogLin ) {
                frac = G4Log( dists->Ws[iW+1] / sampled->w ) / G4Log( dists->Ws[iW+1] / dists->Ws[iW] );
                sampled->x = frac * xSampled + ( 1 - frac ) * sampled->x; }
            else if( dists->interpolationWY == ptwXY_interpolationLinLog ) {
                frac = ( dists->Ws[iW+1] - sampled->w ) / ( dists->Ws[iW+1] - dists->Ws[iW] );
                sampled->x = xSampled * G4Pow::GetInstance()->powA( sampled->x / xSampled, frac ); }
            else if( dists->interpolationWY == ptwXY_interpolationLogLog ) {
                frac = G4Log( dists->Ws[iW+1] / sampled->w ) / G4Log( dists->Ws[iW+1] / dists->Ws[iW] );
                sampled->x = xSampled * G4Pow::GetInstance()->powA( sampled->x / xSampled, frac ); }
            else {  // This should never happen.
                smr_setReportError2( sampled->smr, smr_unknownID, 1, "bad interpolation = %d\n", dists->interpolationWY );
                return( 1 );
            }
 
            sampled->iX2 = sampled->iX1;
            sampled->iX1 = iX1;
            sampled->frac = frac;
        }
    }
 
    return( 0 );
}

Referenced by MCGIDI_angular_sampleMu(), MCGIDI_energy_sampleEnergy(), MCGIDI_KalbachMann_sampleEp(), and MCGIDI_sampling_doubleDistribution().

MCGIDI_target_free()

MCGIDI_target * MCGIDI_target_free	(	statusMessageReporting *	smr,
		MCGIDI_target *	target
	)

Definition at line 114 of file MCGIDI_target.cc.

                                                                                        {
 
    MCGIDI_target_release( smr, target );
    smr_freeMemory( (void **) &target );
    return( NULL );
}

Referenced by MCGIDI_target_new(), and G4GIDI_target::~G4GIDI_target().

MCGIDI_target_getAttributesValue()

char const * MCGIDI_target_getAttributesValue	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		char const *	name
	)

Definition at line 245 of file MCGIDI_target.cc.

                                                                                                                    {
 
    return( xDataTOMAL_getAttributesValue( &(target->attributes), name ) );
}

MCGIDI_target_getDomain()

int MCGIDI_target_getDomain	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		double *	EMin,
		double *	EMax
	)

Definition at line 382 of file MCGIDI_target.cc.

                                                                                                              {
 
    int ir, nr = MCGIDI_target_numberOfReactions( smr, target );
    double EMin_, EMax_;
 
    for( ir = 0; ir < nr; ir++ ) {
        MCGIDI_target_heated_getReactionsDomain( smr, target->baseHeatedTarget, ir, &EMin_, &EMax_ );
        if( ir == 0 ) {
            *EMin = EMin_;
            *EMax = EMax_; }
        else {
            if( *EMin > EMin_ ) *EMin = EMin_;
            if( *EMax < EMax_ ) *EMax = EMax_;
        }
    }
    return( 0 );
}

MCGIDI_target_getHeatedTargetAtIndex_ReadIfNeeded()

MCGIDI_target_heated * MCGIDI_target_getHeatedTargetAtIndex_ReadIfNeeded	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		int	index
	)

Definition at line 289 of file MCGIDI_target.cc.

                                                                                                                                         {
 
    if( ( index < 0 ) || ( index >= target->nHeatedTargets ) ) {
        smr_setReportError2( smr, smr_unknownID, 1, "temperature index = %d out of range (0 <= index < %d", index, target->nHeatedTargets );
        return( NULL );
    }
    if( target->heatedTargets[index].heatedTarget == NULL ) MCGIDI_target_readHeatedTarget( smr, target, index );
    return( target->heatedTargets[index].heatedTarget );
}

MCGIDI_target_getHeatedTargetAtTIndex()

MCGIDI_target_heated * MCGIDI_target_getHeatedTargetAtTIndex	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		int	index
	)

Definition at line 301 of file MCGIDI_target.cc.

                                                                                                                             {
 
    if( ( index < 0 ) || ( index >= target->nHeatedTargets ) ) {
        smr_setReportError2( smr, smr_unknownID, 1, "temperature index = %d out of range (0 <= index < %d", index, target->nHeatedTargets );
        return( NULL );
    }
    if( target->heatedTargets[index].heatedTarget == NULL ) {
        smr_setReportError2( smr, smr_unknownID, 1, "temperature index = %d not read in", index );
        return( NULL );
    }
    return( target->heatedTargets[index].heatedTarget );
}

MCGIDI_target_getIndexReactionCrossSectionAtE()

double MCGIDI_target_getIndexReactionCrossSectionAtE	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		int	index,
		MCGIDI_quantitiesLookupModes &	modes,
		bool	sampling
	)

Definition at line 402 of file MCGIDI_target.cc.

                        {
 
    int i;
    double xsec = 0., xsec1, xsec2, temperature = modes.getTemperature( );
 
    for( i = 0; i < target->nReadHeatedTargets; i++ ) if( target->readHeatedTargets[i]->temperature > temperature ) break;
    if( i == 0 ) {
        xsec = MCGIDI_target_heated_getIndexReactionCrossSectionAtE( smr, target->readHeatedTargets[0]->heatedTarget, index, modes, sampling ); }
    else if( i == target->nReadHeatedTargets ) {
        xsec = MCGIDI_target_heated_getIndexReactionCrossSectionAtE( smr, target->readHeatedTargets[i-1]->heatedTarget, index, modes, sampling ); }
    else {
        xsec1 = MCGIDI_target_heated_getIndexReactionCrossSectionAtE(smr, target->readHeatedTargets[i-1]->heatedTarget, index, modes, sampling );
        xsec2 = MCGIDI_target_heated_getIndexReactionCrossSectionAtE(smr, target->readHeatedTargets[i  ]->heatedTarget, index, modes, sampling );
        xsec = ( ( target->readHeatedTargets[i]->temperature - temperature ) * xsec1 + 
                 ( temperature - target->readHeatedTargets[i-1]->temperature ) * xsec2 ) / 
                 ( target->readHeatedTargets[i]->temperature - target->readHeatedTargets[i-1]->temperature );
    }
 
    return( xsec );
}

Referenced by MCGIDI_target_sampleReaction(), G4GIDI_target::sampleChannelCrossSectionAtE(), and G4GIDI_target::sumChannelCrossSectionAtE().

MCGIDI_target_getIndexReactionFinalQ()

double MCGIDI_target_getIndexReactionFinalQ	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		int	index,
		MCGIDI_quantitiesLookupModes &	modes
	)

Definition at line 493 of file MCGIDI_target.cc.

                                              {
 
    return( MCGIDI_target_heated_getIndexReactionFinalQ( smr, target->baseHeatedTarget, index, modes ) );
}

MCGIDI_target_getReactionAtIndex()

MCGIDI_reaction * MCGIDI_target_getReactionAtIndex	(	MCGIDI_target *	target,
		int	index
	)

Definition at line 333 of file MCGIDI_target.cc.

                                                                                      {
 
    return( MCGIDI_target_heated_getReactionAtIndex( target->baseHeatedTarget, index ) );
}

MCGIDI_target_getReactionAtIndex_smr()

MCGIDI_reaction * MCGIDI_target_getReactionAtIndex_smr	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		int	index
	)

Definition at line 340 of file MCGIDI_target.cc.

                                                                                                                       {
 
    return( MCGIDI_target_heated_getReactionAtIndex_smr( smr, target->baseHeatedTarget, index ) );
}

MCGIDI_target_getReactionTypeAtIndex()

enum MCGIDI_reactionType MCGIDI_target_getReactionTypeAtIndex	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		int	index
	)

Definition at line 323 of file MCGIDI_target.cc.

                                                                                                                               {
 
    MCGIDI_reaction *reaction = MCGIDI_target_heated_getReactionAtIndex_smr( smr, target->baseHeatedTarget, index );
 
    if( reaction == NULL ) return( MCGIDI_reactionType_unknown_e );
    return( MCGIDI_reaction_getReactionType( smr, reaction ) );
}

MCGIDI_target_getTemperatures()

int MCGIDI_target_getTemperatures	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		double *	temperatures
	)

Definition at line 252 of file MCGIDI_target.cc.

                                                                                                             {
 
    int i;
 
    if( temperatures != NULL ) for( i = 0; i < target->nHeatedTargets; i++ ) temperatures[i] = target->heatedTargets[i].temperature;
    return( target->nHeatedTargets );
}

Referenced by G4GIDI_target::getTemperatures().

MCGIDI_target_getTotalCrossSectionAtTAndE()

double MCGIDI_target_getTotalCrossSectionAtTAndE	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		MCGIDI_quantitiesLookupModes &	modes,
		bool	sampling
	)

Definition at line 358 of file MCGIDI_target.cc.

                        {
 
    int i;
    double xsec = 0., xsec1, xsec2, temperature = modes.getTemperature( );
 
    for( i = 0; i < target->nReadHeatedTargets; i++ ) if( target->readHeatedTargets[i]->temperature > temperature ) break;
    if( i == 0 ) {
        xsec = MCGIDI_target_heated_getTotalCrossSectionAtE( smr, target->readHeatedTargets[0]->heatedTarget, modes, sampling ); }
    else if( i == target->nReadHeatedTargets ) {
        xsec = MCGIDI_target_heated_getTotalCrossSectionAtE( smr, target->readHeatedTargets[i-1]->heatedTarget, modes, sampling ); }
    else {
        xsec1 = MCGIDI_target_heated_getTotalCrossSectionAtE( smr, target->readHeatedTargets[i-1]->heatedTarget, modes, sampling );
        xsec2 = MCGIDI_target_heated_getTotalCrossSectionAtE( smr, target->readHeatedTargets[i  ]->heatedTarget, modes, sampling );
        xsec = ( ( target->readHeatedTargets[i]->temperature - temperature ) * xsec1 + 
                 ( temperature - target->readHeatedTargets[i-1]->temperature ) * xsec2 ) / 
                 ( target->readHeatedTargets[i]->temperature - target->readHeatedTargets[i-1]->temperature );
    }
 
    return( xsec );
}

Referenced by G4GIDI_target::getTotalCrossSectionAtE().

MCGIDI_target_getUniqueProducts()

transportabilitiesMap const * MCGIDI_target_getUniqueProducts	(	statusMessageReporting *	smr,
		MCGIDI_target *	target
	)

Definition at line 501 of file MCGIDI_target.cc.

                                                                                                                                       {
 
    return( MCGIDI_target_heated_getUniqueProducts( smr, target->baseHeatedTarget ) );
}

MCGIDI_target_heated_free()

MCGIDI_target_heated * MCGIDI_target_heated_free	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target
	)

Definition at line 64 of file MCGIDI_target_heated.cc.

                                                                                                             {
 
    MCGIDI_target_heated_release( smr, target );
    smr_freeMemory( (void **) &target );
    return( NULL );
}

Referenced by MCGIDI_target_release().

MCGIDI_target_heated_getEnergyGrid()

int MCGIDI_target_heated_getEnergyGrid	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target,
		double **	energyGrid
	)

MCGIDI_target_heated_getIndexReactionCrossSectionAtE()

double MCGIDI_target_heated_getIndexReactionCrossSectionAtE	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target,
		int	index,
		MCGIDI_quantitiesLookupModes &	modes,
		bool	sampling
	)

Definition at line 496 of file MCGIDI_target_heated.cc.

                                                             {
 
    double xsec = 0.;
    MCGIDI_reaction *reaction = MCGIDI_target_heated_getReactionAtIndex_smr( smr, target, index );
 
    if( reaction != NULL ) xsec = MCGIDI_reaction_getCrossSectionAtE( smr, reaction, modes, sampling );
    return( xsec );
}

Referenced by MCGIDI_target_getIndexReactionCrossSectionAtE().

MCGIDI_target_heated_getIndexReactionFinalQ()

double MCGIDI_target_heated_getIndexReactionFinalQ	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target,
		int	index,
		MCGIDI_quantitiesLookupModes &	modes
	)

Definition at line 542 of file MCGIDI_target_heated.cc.

                                              {
 
    MCGIDI_reaction *reaction = MCGIDI_target_heated_getReactionAtIndex_smr( smr, target, index );
 
    if( reaction == NULL ) return( 0. );
    return( MCGIDI_reaction_getFinalQ( smr, reaction, modes ) );
}

Referenced by MCGIDI_target_getIndexReactionFinalQ().

MCGIDI_target_heated_getPOPForProjectile()

MCGIDI_POP * MCGIDI_target_heated_getPOPForProjectile	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target
	)

Definition at line 433 of file MCGIDI_target_heated.cc.

                                                                                                                 {
 
    return( target->projectilePOP );
}

Referenced by MCGIDI_KalbachMann_parseFromTOM().

MCGIDI_target_heated_getPOPForTarget()

MCGIDI_POP * MCGIDI_target_heated_getPOPForTarget	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target
	)

Definition at line 440 of file MCGIDI_target_heated.cc.

                                                                                                             {
 
    return( target->targetPOP );
}

Referenced by MCGIDI_KalbachMann_parseFromTOM().

MCGIDI_target_heated_getProjectileMass_MeV()

double MCGIDI_target_heated_getProjectileMass_MeV	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target
	)

Definition at line 447 of file MCGIDI_target_heated.cc.

                                                                                                              {
 
    return( MCGIDI_POP_getMass_MeV( target->projectilePOP ) );
}

Referenced by MCGIDI_reaction_getProjectileMass_MeV().

MCGIDI_target_heated_getReactionAtIndex()

MCGIDI_reaction * MCGIDI_target_heated_getReactionAtIndex	(	MCGIDI_target_heated *	target,
		int	index
	)

Definition at line 401 of file MCGIDI_target_heated.cc.

                                                                                                    {
 
    if( ( index >= 0 ) && ( index < target->numberOfReactions ) ) return( &(target->reactions[index]) );
    return( NULL );
}

Referenced by G4GIDI_target::getChannelIDs(), G4GIDI_target::init(), MCGIDI_target_getReactionAtIndex(), MCGIDI_target_heated_getReactionAtIndex_smr(), MCGIDI_target_heated_getReactionsDomain(), MCGIDI_target_heated_getReactionsThreshold(), and MCGIDI_target_sampleReaction().

MCGIDI_target_heated_getReactionAtIndex_smr()

MCGIDI_reaction * MCGIDI_target_heated_getReactionAtIndex_smr	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target,
		int	index
	)

Definition at line 409 of file MCGIDI_target_heated.cc.

                                                                                                                                     {
 
    MCGIDI_reaction *reaction = MCGIDI_target_heated_getReactionAtIndex( target, index );
 
    if( reaction == NULL ) {
        smr_setReportError2( smr, smr_unknownID, 1, "bad reaction index = %d for %s + %s", index, target->projectilePOP->name, target->targetPOP->name ); 
    }
    return( reaction );
}

Referenced by G4GIDI_target::getChannelsID(), G4GIDI_target::getElasticFinalState(), MCGIDI_target_getReactionAtIndex_smr(), MCGIDI_target_getReactionTypeAtIndex(), MCGIDI_target_heated_getIndexReactionCrossSectionAtE(), MCGIDI_target_heated_getIndexReactionFinalQ(), and MCGIDI_target_heated_sampleIndexReactionProductsAtE().

MCGIDI_target_heated_getReactionsDomain()

int MCGIDI_target_heated_getReactionsDomain	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target,
		int	index,
		double *	EMin,
		double *	EMax
	)

Definition at line 530 of file MCGIDI_target_heated.cc.

                                                                                                                                               {
 
    MCGIDI_reaction *reaction = MCGIDI_target_heated_getReactionAtIndex( target, index );
 
    if( reaction == NULL ) return( -1 );
    *EMin = reaction->EMin;
    *EMax = reaction->EMax;
    return( 0 );
}

Referenced by G4GIDI_target::getReactionsDomain(), and MCGIDI_target_getDomain().

MCGIDI_target_heated_getReactionsThreshold()

double MCGIDI_target_heated_getReactionsThreshold	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target,
		int	index
	)

Definition at line 520 of file MCGIDI_target_heated.cc.

                                                                                                                         {
 
    MCGIDI_reaction *reaction = MCGIDI_target_heated_getReactionAtIndex( target, index );
 
    if( reaction == NULL ) return( -1 );
    return( reaction->EMin );
}

Referenced by G4GIDI_target::getReactionsThreshold().

MCGIDI_target_heated_getTargetMass_MeV()

double MCGIDI_target_heated_getTargetMass_MeV	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target
	)

Definition at line 454 of file MCGIDI_target_heated.cc.

                                                                                                          {
 
    return( MCGIDI_POP_getMass_MeV( target->targetPOP ) );
}

Referenced by MCGIDI_reaction_getTargetMass_MeV().

MCGIDI_target_heated_getTotalCrossSectionAtE()

double MCGIDI_target_heated_getTotalCrossSectionAtE	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target,
		MCGIDI_quantitiesLookupModes &	modes,
		bool	sampling
	)

Definition at line 461 of file MCGIDI_target_heated.cc.

                                                             {
 
    double xsec;
 
    if( modes.getCrossSectionMode( ) == MCGIDI_quantityLookupMode_pointwise ) {
        double e_in = modes.getProjectileEnergy( );
 
        if( e_in < target->EMin ) e_in = target->EMin;
        if( e_in > target->EMax ) e_in = target->EMax;
        ptwXY_getValueAtX( target->crossSection, e_in, &xsec ); }
    else if( modes.getCrossSectionMode( ) == MCGIDI_quantityLookupMode_grouped ) {
        int index = modes.getGroupIndex( );
        double *xSecP;
 
        if( sampling ) {
            xSecP = ptwX_getPointAtIndex( target->crossSectionGroupedForSampling, index ); }
        else {
            xSecP = ptwX_getPointAtIndex( target->crossSectionGrouped, index );
        }
 
        if( xSecP != NULL ) {
            xsec = *xSecP; }
        else {
            xsec = 0.;
            smr_setReportError2( smr, smr_unknownID, 1, "Invalid cross section group index %d", index, (int) ptwX_length( target->crossSectionGrouped ) );
        } }
    else {
        xsec = 0.;
    }
    return( xsec );
}

Referenced by MCGIDI_target_getTotalCrossSectionAtTAndE().

MCGIDI_target_heated_getUniqueProducts()

transportabilitiesMap const * MCGIDI_target_heated_getUniqueProducts	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target
	)

Definition at line 553 of file MCGIDI_target_heated.cc.

                                                                                                                                                    {
 
    return( target->transportabilities );
}

Referenced by MCGIDI_target_getUniqueProducts().

MCGIDI_target_heated_initialize()

int MCGIDI_target_heated_initialize	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target
	)

Definition at line 43 of file MCGIDI_target_heated.cc.

                                                                                                 {
 
    memset( target, 0, sizeof( MCGIDI_target_heated ) );
    MCGIDI_POPs_initial( smr, &(target->pops), 100 );
    target->transportabilities = new transportabilitiesMap( );
    return( 0 );
}

Referenced by MCGIDI_target_heated_new().

MCGIDI_target_heated_new()

MCGIDI_target_heated * MCGIDI_target_heated_new

(

statusMessageReporting *

smr

)

Definition at line 32 of file MCGIDI_target_heated.cc.

                                                                              {
 
    MCGIDI_target_heated *target;
 
    if( ( target = (MCGIDI_target_heated *) smr_malloc2( smr, sizeof( MCGIDI_target_heated ), 0, "target" ) ) == NULL ) return( NULL );
    if( MCGIDI_target_heated_initialize( smr, target ) ) target = (MCGIDI_target_heated *) smr_freeMemory( (void **) &target );
    return( target );
}

Referenced by MCGIDI_target_heated_newRead().

MCGIDI_target_heated_newRead()

MCGIDI_target_heated * MCGIDI_target_heated_newRead	(	statusMessageReporting *	smr,
		const char *	fileName
	)

Definition at line 53 of file MCGIDI_target_heated.cc.

                                                                                                        {
 
    MCGIDI_target_heated *target;
 
    if( ( target = MCGIDI_target_heated_new( smr ) ) == NULL ) return( NULL );
    if( MCGIDI_target_heated_read( smr, target, fileName ) != 0 ) target = (MCGIDI_target_heated *) smr_freeMemory( (void **) &target );
    return( target );
}

Referenced by MCGIDI_target_readHeatedTarget().

MCGIDI_target_heated_numberOfProductionReactions()

int MCGIDI_target_heated_numberOfProductionReactions	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target
	)

Definition at line 394 of file MCGIDI_target_heated.cc.

                                                                                                             {
 
    return( 0 );
}

Referenced by MCGIDI_target_numberOfProductionReactions().

MCGIDI_target_heated_numberOfReactions()

int MCGIDI_target_heated_numberOfReactions	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target
	)

Definition at line 387 of file MCGIDI_target_heated.cc.

                                                                                                       {
 
    return( target->numberOfReactions );
}

Referenced by MCGIDI_target_numberOfReactions().

MCGIDI_target_heated_read()

int MCGIDI_target_heated_read	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target,
		const char *	fileName
	)

Definition at line 92 of file MCGIDI_target_heated.cc.

                                                                                                                 {
/*
*   If a target has already been read into this target, user must have called MCGIDI_target_heated_release before calling this routine.
*   Otherwise, there will be memory leaks.
*/
    int n, ir;
    xDataTOM_TOM *doc = NULL;
    xDataTOM_element *element, *child, *particles, *particleAliases;
    char const *name, *version, *temperatureStr;
    char *e1;
    MCGIDI_reaction *reaction;
    double crossSectionInit[4] = { 0., 0., 0., 0., };
    nfu_status status;
    ptwXYPoints *crossSection;
int subtag1_Notice = 0;
 
    if( ( target->path = smr_allocateCopyString2( smr, fileName, "path" ) ) == NULL ) goto err;
    if( ( target->absPath = xDataTOMMisc_getAbsPath( smr, fileName ) ) == NULL ) goto err;
    if( ( doc = xDataTOM_importFile( smr, fileName ) ) == NULL ) goto err;
    element = xDataTOM_getDocumentsElement( doc );
    if( ( version = xDataTOM_getAttributesValueInElement( element, "version" ) ) == NULL ) {
            smr_setReportError2( smr, smr_unknownID, 1, "version attribute missing from element '%s'", element->name );
            goto err; }
    else {
        if( strcmp( version, "GND 1.3" ) != 0 ) {
            smr_setReportError2( smr, smr_unknownID, 1, "Unsupported version '%s' for element %s", version, element->name );
            goto err;
        }
    }
    if( strcmp( element->name, "reactionSuite" ) != 0 ) {
        smr_setReportError2( smr, smr_unknownID, 1, "input file's top element must be reactionSuite and not %s", element->name );
        goto err; }
    else {
        xDataTOMAL_copyAttributionList( smr, &(target->attributes), &(element->attributes) );
        particleAliases = xDataTOME_getOneElementByName( smr, element, "aliases", 0 );
        if( ( particles = xDataTOME_getOneElementByName( smr, element, "particles", 1 ) ) == NULL ) goto err;
        if( MCGIDI_target_heated_parsePOPs( smr, target, particles, particleAliases ) != 0 ) goto err;
 
        if( ( temperatureStr = MCGIDI_misc_pointerToTOMAttributeIfAllOk3( smr, target->absPath, 1, &(target->attributes), "temperature" ) ) == NULL ) goto err;
        target->temperature_MeV = strtod( temperatureStr, &e1 );
        while( isspace( *e1 ) ) ++e1; // Loop checking, 11.06.2015, T. Koi
        target->temperature_MeV *= MCGIDI_misc_getUnitConversionFactor( smr, e1, "MeV/k" );
        if( !smr_isOk( smr ) ) goto err;
 
        if( ( name = MCGIDI_misc_pointerToTOMAttributeIfAllOk3( smr, target->absPath, 1, &(target->attributes), "projectile" ) ) != NULL )
            target->projectilePOP = MCGIDI_POPs_findParticle( &(target->pops), name );
        if( !smr_isOk( smr ) ) goto err;
 
        if( ( name = MCGIDI_misc_pointerToTOMAttributeIfAllOk3( smr, target->absPath, 1, &(target->attributes), "target" ) ) != NULL )
        if( !smr_isOk( smr ) ) goto err;
            target->targetPOP = MCGIDI_POPs_findParticle( &(target->pops), name );
 
        n = xDataTOM_numberOfElementsByName( smr, element, "reaction" );
        if( n == 0 ) {
            smr_setReportError2( smr, smr_unknownID, 1, "target does not have any reactions: file = '%s'", fileName );
            goto err;
        }
        if( ( target->reactions = (MCGIDI_reaction *) smr_malloc2( smr, n * sizeof( MCGIDI_reaction ), 1, "target->reactions" ) ) == NULL ) goto err;
 
        for( ir = 0, child = xDataTOME_getFirstElement( element ); child != NULL; child = xDataTOME_getNextElement( child ) ) {
            if( strcmp( child->name, "particles" ) == 0 ) continue;
            if( strcmp( child->name, "styles" ) == 0 ) continue;
            if( strcmp( child->name, "documentations" ) == 0 ) continue;
            if( strcmp( child->name, "resonances" ) == 0 ) continue;
            if( strcmp( child->name, "summedReaction" ) == 0 ) continue;
            if( strcmp( child->name, "fissionComponent" ) == 0 ) continue;
            if( strcmp( child->name, "reaction" ) == 0 ) {
                double EMin, EMax;
 
                reaction =  &(target->reactions[ir]);
                if( MCGIDI_target_heated_parseReaction( smr, child, target, &(target->pops), reaction ) ) goto err;
                if( MCGIDI_reaction_getDomain( smr, reaction, &EMin, &EMax ) ) goto err;
                if( ir == 0 ) { target->EMin = EMin; target->EMax = EMax; }
                if( EMin < target->EMin ) target->EMin = EMin;
                if( EMax > target->EMax ) target->EMax = EMax;
                for( transportabilitiesMap::const_iterator iter = reaction->transportabilities->begin( ); 
                            iter != reaction->transportabilities->end( ); ++iter ) {
                    MCGIDI_misc_updateTransportabilitiesMap( target->transportabilities, iter->first, iter->second );
                }
                ir++; }
            else if( strcmp( child->name, "production" ) == 0 ) {
                continue; }
            else if( strcmp( child->name, "aliases" ) == 0 ) {
                continue; }
            else if( strcmp( child->name, "partialGammaProduction" ) == 0 ) {
                if( subtag1_Notice == 0 ) printf( "Unsupported reactionSuite sub-tag = '%s'\n", child->name );
                subtag1_Notice++; }
            else {
                printf( "Unsupported reactionSuite sub-tag = '%s'\n", child->name );
            }
        }
        crossSectionInit[0] = target->EMin;
        crossSectionInit[2] = target->EMax;
        if( ( target->crossSection = ptwXY_create( ptwXY_interpolationLinLin, NULL, 2., 1e-3, 2, 10, 2, crossSectionInit, &status, 0 ) ) == NULL ) {
            smr_setReportError2( smr, smr_unknownID, 1, "ptwXY_create err = %d: %s\n", status, nfu_statusMessage( status ) );
            goto err;
        }
        for( ir = 0; ir < target->numberOfReactions; ir++ ) {
            reaction =  &(target->reactions[ir]);
            if( MCGIDI_reaction_fixDomains( smr, reaction, target->EMin, target->EMax, &status ) ) {
                smr_setReportError2( smr, smr_unknownID, 1, "ptwXY_add_ptwXY err = %d: %s\n", status, nfu_statusMessage( status ) );
                goto err;
            }
            if( ( crossSection = ptwXY_add_ptwXY( target->crossSection, reaction->crossSection, &status ) ) == NULL ) {
                smr_setReportError2( smr, smr_unknownID, 1, "ptwXY_add_ptwXY err = %d: %s\n", status, nfu_statusMessage( status ) );
                goto err;
            }
            target->crossSection = ptwXY_free( target->crossSection );
            target->crossSection = crossSection;
        }
    }
    xDataTOM_freeTOM( smr, &doc );
    return( 0 );
 
err:
    smr_setReportError2( smr, smr_unknownID, 1, "Sub-error while reading file '%s'", fileName );
    if( doc != NULL ) xDataTOM_freeTOM( smr, &doc );
    MCGIDI_target_heated_release( smr, target );
    return( 1 );
}

Referenced by MCGIDI_target_heated_newRead().

MCGIDI_target_heated_recast()

int MCGIDI_target_heated_recast	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target,
		GIDI_settings &	settings
	)

Definition at line 560 of file MCGIDI_target_heated.cc.

                                                                                                                      {
 
    int ir, projectilePoPID = target->projectilePOP->globalPoPsIndex;
    ptwXPoints *totalGroupedCrossSection = NULL;
    GIDI_settings_particle const *projectileSettings = settings.getParticle( projectilePoPID );
    nfu_status status_nf;
 
    if( projectileSettings == NULL ) {
        smr_setReportError2( smr, smr_unknownID, 1, "Settings missing for projectile %s", target->projectilePOP->name ); 
        return( 1 );
    }
    target->crossSectionGrouped = ptwX_free( target->crossSectionGrouped );
    target->crossSectionGroupedForSampling = ptwX_free( target->crossSectionGroupedForSampling );
    if( projectileSettings->isEnergyMode_grouped( ) ) {
        int64_t numberOfGroups = projectileSettings->getNumberOfGroups( );
 
        if( ( totalGroupedCrossSection = ptwX_createLine( numberOfGroups, numberOfGroups, 0, 0, &status_nf ) ) == NULL ) {
            smr_setReportError2( smr, smr_unknownID, 1, "totalGroupedCrossSection allocation failed: status_nf = %d, '%s'", 
                    status_nf, nfu_statusMessage( status_nf ) ); 
            goto err;
        }
    }
 
    for( ir = 0; ir < target->numberOfReactions; ++ir ) {
        if( MCGIDI_reaction_recast( smr, &(target->reactions[ir]), settings, projectileSettings, target->temperature_MeV, totalGroupedCrossSection ) != 0 ) goto err;
    }
    if( projectileSettings->isEnergyMode_grouped( ) ) {
        if( ( target->crossSectionGroupedForSampling = ptwX_clone( totalGroupedCrossSection, &status_nf ) ) == NULL ) {
            smr_setReportError2( smr, smr_unknownID, 1, "totalGroupedCrossSection allocation failed: status_nf = %d, '%s'", 
                    status_nf, nfu_statusMessage( status_nf ) ); 
            goto err;
        }
        for( ir = 0; ir < target->numberOfReactions; ++ir ) {
            int index = target->reactions[ir].thresholdGroupIndex;
 
            if( index > -1 ) {
                double xSec = target->reactions[ir].thresholdGroupedDeltaCrossSection +
                        ptwX_getPointAtIndex_Unsafely( target->crossSectionGroupedForSampling, index );
 
                ptwX_setPointAtIndex( target->crossSectionGroupedForSampling, index, xSec );
            }
        }
    }
    target->crossSectionGrouped = totalGroupedCrossSection;
    totalGroupedCrossSection = NULL;
 
    return( 0 );
 
err:
    ptwX_free( totalGroupedCrossSection );
    target->crossSectionGroupedForSampling = ptwX_free( target->crossSectionGroupedForSampling );
    return( 1 );
}

Referenced by MCGIDI_target_recast().

MCGIDI_target_heated_release()

int MCGIDI_target_heated_release	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target
	)

Definition at line 73 of file MCGIDI_target_heated.cc.

                                                                                             {
 
    int ir;
 
    ptwXY_free( target->crossSection );
    ptwX_free( target->crossSectionGrouped );
    ptwX_free( target->crossSectionGroupedForSampling );
    for( ir = 0; ir < target->numberOfReactions; ir++ ) MCGIDI_reaction_release( NULL, &(target->reactions[ir]) );
    smr_freeMemory( (void **) &(target->reactions) );
    MCGIDI_POPs_release( &(target->pops) );
    smr_freeMemory( (void **) &(target->path) );
    smr_freeMemory( (void **) &(target->absPath) );
    xDataTOMAL_release( &(target->attributes) );
    delete target->transportabilities;
    return( 0 );
}

Referenced by MCGIDI_target_heated_free(), and MCGIDI_target_heated_read().

MCGIDI_target_heated_sampleIndexReactionProductsAtE()

int MCGIDI_target_heated_sampleIndexReactionProductsAtE	(	statusMessageReporting *	smr,
		MCGIDI_target_heated *	target,
		int	index,
		MCGIDI_quantitiesLookupModes &	modes,
		MCGIDI_decaySamplingInfo *	decaySamplingInfo,
		MCGIDI_sampledProductsDatas *	productData
	)

Definition at line 508 of file MCGIDI_target_heated.cc.

                                                                                                                                      {
 
    MCGIDI_reaction *reaction = MCGIDI_target_heated_getReactionAtIndex_smr( smr, target, index );
 
    productDatas->numberOfProducts = 0;
    if( reaction == NULL ) return( -1 );
    return( MCGIDI_outputChannel_sampleProductsAtE( smr, &(reaction->outputChannel), modes, decaySamplingInfo, productDatas, NULL ) );
}

Referenced by G4GIDI_target::getFinalState(), and MCGIDI_target_sampleIndexReactionProductsAtE().

MCGIDI_target_initialize()

int MCGIDI_target_initialize	(	statusMessageReporting *	smr,
		MCGIDI_target *	target
	)

Definition at line 44 of file MCGIDI_target.cc.

                                                                                  {
 
    memset( target, 0, sizeof( MCGIDI_target ) );
    return( 0 );
}

Referenced by MCGIDI_target_new(), MCGIDI_target_read(), and MCGIDI_target_release().

MCGIDI_target_new()

MCGIDI_target * MCGIDI_target_new

(

statusMessageReporting *

smr

)

Definition at line 33 of file MCGIDI_target.cc.

                                                                {
 
    MCGIDI_target *target;
 
    if( ( target = (MCGIDI_target *) smr_malloc2( smr, sizeof( MCGIDI_target ), 0, "target" ) ) == NULL ) return( NULL );
    if( MCGIDI_target_initialize( smr, target ) ) target = MCGIDI_target_free( smr, target );
    return( target );
}

Referenced by MCGIDI_target_newRead().

MCGIDI_target_newRead()

MCGIDI_target * MCGIDI_target_newRead	(	statusMessageReporting *	smr,
		const char *	fileName
	)

Definition at line 52 of file MCGIDI_target.cc.

                                                                                          {
 
    MCGIDI_target *target;
 
    if( ( target = MCGIDI_target_new( smr ) ) == NULL ) return( NULL );
    if( MCGIDI_target_read( smr, target, fileName ) != 0 ) smr_freeMemory( (void **) &target );
    return( target );
}

Referenced by G4GIDI_target::init(), MCGIDI_target_newReadFromMap(), and MCGIDI_target_newReadFromMapViaPoPIDs().

MCGIDI_target_newReadFromMap()

MCGIDI_target * MCGIDI_target_newReadFromMap	(	statusMessageReporting *	smr,
		MCGIDI_map *	map,
		const char *	evaluation,
		const char *	projectileName,
		const char *	targetName
	)

Definition at line 99 of file MCGIDI_target.cc.

                                 {
 
    char *targetPath;
    MCGIDI_target *target;
 
    targetPath = MCGIDI_map_findTarget( smr, map, evaluation, projectileName, targetName );
    if( targetPath == NULL ) return( NULL );
    target = MCGIDI_target_newRead( smr, targetPath );
    smr_freeMemory( (void **) &targetPath );
    return( target );
}

MCGIDI_target_newReadFromMapViaPoPIDs()

MCGIDI_target * MCGIDI_target_newReadFromMapViaPoPIDs	(	statusMessageReporting *	smr,
		MCGIDI_map *	map,
		const char *	evaluation,
		int	projectile_PoPID,
		int	target_PoPID
	)

Definition at line 85 of file MCGIDI_target.cc.

                                                 {
 
    char *targetPath;
    MCGIDI_target *target;
 
    if( ( targetPath = MCGIDI_map_findTargetViaPoPIDs( smr, map, evaluation, projectile_PoPID, target_PoPID ) ) == NULL ) return( NULL );
    target = MCGIDI_target_newRead( smr, targetPath );
    smr_freeMemory( (void **) &targetPath );
    return( target );
}

MCGIDI_target_numberOfProductionReactions()

int MCGIDI_target_numberOfProductionReactions	(	statusMessageReporting *	smr,
		MCGIDI_target *	target
	)

Definition at line 347 of file MCGIDI_target.cc.

                                                                                               {
 
#if 0
    return( MCGIDI_target_heated_numberOfProductionReactions( smr, target->baseHeatedTarget ) );
#endif
return( 0 );
}

Referenced by G4GIDI_target::getNumberOfProductionChannels().

MCGIDI_target_numberOfReactions()

int MCGIDI_target_numberOfReactions	(	statusMessageReporting *	smr,
		MCGIDI_target *	target
	)

Definition at line 316 of file MCGIDI_target.cc.

                                                                                          {
 
    return( MCGIDI_target_heated_numberOfReactions( smr, target->baseHeatedTarget ) );
}

Referenced by G4GIDI_target::getChannelIDs(), G4GIDI_target::getNumberOfChannels(), G4GIDI_target::init(), MCGIDI_target_getDomain(), and MCGIDI_target_sampleReaction().

MCGIDI_target_read()

int MCGIDI_target_read	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		const char *	fileName
	)

Definition at line 143 of file MCGIDI_target.cc.

                                                                                                   {
/*
*   If a target has already been read into this target, user must have called MCGIDI_target_release before calling this routine.
*   Otherwise, there will be memory leaks.
*/
    xDataXML_document *doc;
    xDataXML_element *element, *child;
    int i, iHeated, nHeated = 0, status = 1;
    double temperature;
    /* char *pReturnValue; */
    char const *version, *contents;
 
    MCGIDI_target_initialize( smr, target );
    if( ( target->path = smr_allocateCopyString2( smr, fileName, "path" ) ) == NULL ) return( status );
    if( ( target->absPath = MCGIDI_misc_getAbsPath( smr, fileName ) ) == NULL ) return( _MCGIDI_target_releaseAndReturnOne( smr, target ) );
    if( ( doc = xDataXML_importFile2( smr, fileName ) ) == NULL ) return( _MCGIDI_target_releaseAndReturnOne( smr, target ) );
    element = xDataXML_getDocumentsElement( doc );
    if( strcmp( element->name, "xTarget" ) != 0 ) {
        MCGIDI_misc_setMessageError_Element( smr, NULL, element, __FILE__, __LINE__, 1, "input file's top element must be xTarget and not %s", element->name ); }
    else {
        status = 0;
        if( ( version = xDataXML_getAttributesValueInElement( element, "version" ) ) == NULL ) {
            smr_setReportError2( smr, smr_unknownID, 1, "version attribute missing from element '%s'", element->name );
            status = 1; }
        else {
            if( strcmp( version, "xMCProcess 0.1" ) != 0 ) {
                smr_setReportError2( smr, smr_unknownID, 1, "Unsupported version '%s' for element %s", version, element->name );
                status = 1;
            }
        }
        if( status == 0 ) {
          /*  pReturnValue = ( MCGIDI_misc_copyXMLAttributesToTOM( smr, &(target->attributes), &(element->attributes) ) ) ? NULL : target->path; */
            for( nHeated = 0, child = xDataXML_getFirstElement( element ); child != NULL; nHeated++, child = xDataXML_getNextElement( child ) ) {
                if( strcmp( child->name, "target" ) != 0 ) {
                    MCGIDI_misc_setMessageError_Element( smr, NULL, element, __FILE__, __LINE__, 1, "element can only have target sub-elements%s", 
                                element->name );
                    status = 1;
                    break;
                }
            }
        }
        if( status == 0 ) {
            if( ( target->heatedTargets = (MCGIDI_target_heated_info *) smr_malloc2( smr, nHeated * sizeof( MCGIDI_target_heated_info ), 1, "heatedTargets" ) ) == NULL ) {
                status = 1; }
            else {
                if( ( target->readHeatedTargets = (MCGIDI_target_heated_info **) smr_malloc2( smr, nHeated * sizeof( MCGIDI_target_heated_info * ), 1, "heatedTargets" ) ) == NULL ) 
                    status = 1;
            }
            for( nHeated = 0, child = xDataXML_getFirstElement( element ); ( status == 0 ) && ( child != NULL ); 
                    nHeated++, child = xDataXML_getNextElement( child ) ) {
                if( ( i = xDataXML_convertAttributeToDouble( smr, child, "temperature", &temperature, 1 ) ) != 0 ) {
                    if( i > 0 ) smr_setReportError2p( smr, smr_unknownID, 1, "target does not have a temperature attribute" );
                    status = 1;
                    break;
                }
                for( iHeated = 0; iHeated < nHeated; iHeated++ ) if( target->heatedTargets[iHeated].temperature > temperature ) break;
                if( iHeated < nHeated ) for( i = nHeated; i >= iHeated; i-- ) target->heatedTargets[i+1] = target->heatedTargets[i];
                target->heatedTargets[iHeated].temperature = temperature;
                target->heatedTargets[iHeated].path = NULL;
                target->heatedTargets[iHeated].contents = NULL;
                target->heatedTargets[iHeated].heatedTarget = NULL;
                if( ( contents = xDataXML_getAttributesValueInElement( child, "contents" ) ) != NULL ) {
                    if( ( target->heatedTargets[iHeated].contents = smr_allocateCopyString2( smr, contents, "contents" ) ) == NULL ) {
                        status = 1;
                        break;
                    }
                }
                if( ( contents = xDataXML_getAttributesValueInElement( child, "file" ) ) == NULL ) {
                    status = 1;
                    break;
                }
                if( ( target->heatedTargets[iHeated].path = (char *) smr_malloc2(smr, strlen( target->absPath ) + strlen( contents ) + 2, 0, "path") ) == NULL) {
                    status = 1;
                    break;
                }
                strcpy( target->heatedTargets[iHeated].path, target->absPath );
                *strrchr( target->heatedTargets[iHeated].path, '/' ) = 0;
                strcat( target->heatedTargets[iHeated].path, "/" );
                strcat( target->heatedTargets[iHeated].path, contents );
                target->nHeatedTargets++;
            }
        }
    }
    xDataXML_freeDoc( smr, doc );
    if( status == 0 ) {
        for( i = 0; i < nHeated; i++ ) target->heatedTargets[i].ordinal = i;
        for( i = 0; i < nHeated; i++ ) if( target->heatedTargets[i].contents == NULL ) break;
        if( i == nHeated ) i = 0;                                           /* All heated targets are crossSection only. */
        if( MCGIDI_target_readHeatedTarget( smr, target, i ) == 0 ) {
            target->baseHeatedTarget = target->heatedTargets[i].heatedTarget; }
        else {
            MCGIDI_target_release( NULL, target );
            status = 1;
        } }
    else {
        MCGIDI_target_release( smr, target );
    }
    return( status );
}

Referenced by MCGIDI_target_newRead(), MCGIDI_target_readFromMap(), and MCGIDI_target_readFromMapViaPoPIDs().

MCGIDI_target_readFromMap()

int MCGIDI_target_readFromMap	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		MCGIDI_map *	map,
		const char *	evaluation,
		const char *	projectileName,
		const char *	targetName
	)

Definition at line 74 of file MCGIDI_target.cc.

                                 {
 
    char *targetPath;
 
    if( ( targetPath = MCGIDI_map_findTarget( smr, map, evaluation, projectileName, targetName ) ) == NULL ) return( 1 );
    return( MCGIDI_target_read( smr, target, targetPath ) );
}

MCGIDI_target_readFromMapViaPoPIDs()

int MCGIDI_target_readFromMapViaPoPIDs	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		MCGIDI_map *	map,
		const char *	evaluation,
		int	projectile_PoPID,
		int	target_PoPID
	)

Definition at line 63 of file MCGIDI_target.cc.

                                                 {
 
    char *targetPath;
 
    if( ( targetPath = MCGIDI_map_findTargetViaPoPIDs( smr, map, evaluation, projectile_PoPID, target_PoPID ) ) == NULL ) return( 1 );
    return( MCGIDI_target_read( smr, target, targetPath ) );
}

MCGIDI_target_readHeatedTarget()

int MCGIDI_target_readHeatedTarget	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		int	index
	)

Definition at line 262 of file MCGIDI_target.cc.

                                                                                                    {
 
    int i;
 
    if( ( index < 0 ) || ( index >= target->nHeatedTargets ) ) {
        smr_setReportError2( smr, smr_unknownID, 1, "temperature index = %d out of range (0 <= index < %d", index, target->nHeatedTargets );
        return( -1 );
    }
    if( target->heatedTargets[index].heatedTarget != NULL ) return( 1 );
    if( ( target->heatedTargets[index].heatedTarget = MCGIDI_target_heated_newRead( smr, target->heatedTargets[index].path ) ) != NULL ) {
        target->projectilePOP = target->heatedTargets[index].heatedTarget->projectilePOP;
        target->targetPOP = target->heatedTargets[index].heatedTarget->targetPOP;
        if( target->heatedTargets[index].heatedTarget != NULL ) {
            target->heatedTargets[index].heatedTarget->ordinal = target->heatedTargets[index].ordinal;
            for( i = target->nReadHeatedTargets; i > 0; i-- ) {
                if( target->readHeatedTargets[i-1]->temperature < target->heatedTargets[index].temperature ) break;
                target->readHeatedTargets[i] = target->readHeatedTargets[i-1];
            }
            target->readHeatedTargets[i] = &(target->heatedTargets[i]);
            target->nReadHeatedTargets++;
        }
    }
    return( ( target->heatedTargets[index].heatedTarget == NULL ? -1 : 0 ) );
}

Referenced by MCGIDI_target_getHeatedTargetAtIndex_ReadIfNeeded(), MCGIDI_target_read(), and G4GIDI_target::readTemperature().

MCGIDI_target_recast()

int MCGIDI_target_recast	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		GIDI_settings &	settings
	)

Definition at line 508 of file MCGIDI_target.cc.

                                                                                                        {
 
    int i1, status = 0;
 
    for( i1 = 0; i1 < target->nReadHeatedTargets; i1++ ) {
        if( ( status = MCGIDI_target_heated_recast( smr, target->readHeatedTargets[i1]->heatedTarget, settings ) ) != 0 ) break;
    }
    return( status );
}

MCGIDI_target_release()

int MCGIDI_target_release	(	statusMessageReporting *	smr,
		MCGIDI_target *	target
	)

Definition at line 123 of file MCGIDI_target.cc.

                                                                                {
 
    int i;
 
    smr_freeMemory( (void **) &(target->path) );
    smr_freeMemory( (void **) &(target->absPath) );
    xDataTOMAL_release( &(target->attributes) );
    for( i = 0; i < target->nHeatedTargets; i++ ) {
        smr_freeMemory( (void **) &(target->heatedTargets[i].path) );
        smr_freeMemory( (void **) &(target->heatedTargets[i].contents) );
        if( target->heatedTargets[i].heatedTarget != NULL ) MCGIDI_target_heated_free( smr, target->heatedTargets[i].heatedTarget );
    }
    smr_freeMemory( (void **) &(target->heatedTargets) );
    smr_freeMemory( (void **) &(target->readHeatedTargets) );
    MCGIDI_target_initialize( smr, target );
    return( 0 );
}

Referenced by MCGIDI_target_free(), and MCGIDI_target_read().

MCGIDI_target_sampleIndexReactionProductsAtE()

int MCGIDI_target_sampleIndexReactionProductsAtE	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		int	index,
		MCGIDI_quantitiesLookupModes &	modes,
		MCGIDI_decaySamplingInfo *	decaySamplingInfo,
		MCGIDI_sampledProductsDatas *	productData
	)

Definition at line 485 of file MCGIDI_target.cc.

                                                                                                                                     {
 
    return( MCGIDI_target_heated_sampleIndexReactionProductsAtE( smr, target->baseHeatedTarget, index, modes, decaySamplingInfo, productData ) );
}

MCGIDI_target_sampleNullReactionProductsAtE()

int MCGIDI_target_sampleNullReactionProductsAtE	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		MCGIDI_quantitiesLookupModes &	modes,
		MCGIDI_decaySamplingInfo *	decaySamplingInfo,
		MCGIDI_sampledProductsDatas *	productDatas
	)

Definition at line 461 of file MCGIDI_target.cc.

                                                                                                                                  {
 
    MCGIDI_sampledProductsData productData;
 
    productData.isVelocity = decaySamplingInfo->isVelocity;
    productData.pop = target->projectilePOP;
    productData.kineticEnergy = modes.getProjectileEnergy( );
    productData.px_vx = 0.;
    productData.py_vy = 0.;
    productData.pz_vz = std::sqrt( productData.kineticEnergy * ( productData.kineticEnergy + 2. * productData.pop->mass_MeV ) );
    if( productData.isVelocity ) productData.pz_vz *=
            MCGIDI_speedOfLight_cm_sec / std::sqrt( productData.pz_vz * productData.pz_vz + productData.pop->mass_MeV * productData.pop->mass_MeV );
    productData.delayedNeutronIndex = 0;
    productData.delayedNeutronRate = 0.;
    productData.birthTimeSec = 0;
 
    productDatas->numberOfProducts = 0;
    MCGIDI_sampledProducts_addProduct( smr, productDatas, &productData );
    return( productDatas->numberOfProducts );
}

MCGIDI_target_sampleReaction()

int MCGIDI_target_sampleReaction	(	statusMessageReporting *	smr,
		MCGIDI_target *	target,
		MCGIDI_quantitiesLookupModes &	modes,
		double	totalXSec,
		double(*)(void *)	userrng,
		void *	rngState
	)

Definition at line 426 of file MCGIDI_target.cc.

                                                      {
 
    int ir, nr = MCGIDI_target_numberOfReactions( smr, target );
    double rngValue = (*userrng)( rngState );
    double cumm_xsec = 0., r_xsec = rngValue * totalXSec;
 
    for( ir = 0; ir < nr; ir++ ) {
        cumm_xsec += MCGIDI_target_getIndexReactionCrossSectionAtE( smr, target, ir, modes, true );
        if( cumm_xsec >= r_xsec ) break;
    }
    if( ir == nr ) {
        if( ( totalXSec - cumm_xsec ) >= 1e-12 * totalXSec ) {
            smr_setReportError2( smr, smr_unknownID, 1, 
                "Failed to sample a reaction for temperature = %.12e, energy = %.12e, totalXSec = %16.e, rngValue = %16.e, r_xsec = %16.e, cumm_xsec = %16.e", 
                modes.getTemperature( ), modes.getProjectileEnergy( ), totalXSec, rngValue, r_xsec, cumm_xsec );
            return( -1 );
        }
        ir--;                               /* May not be correct but close. */
    }
    if( modes.getCrossSectionMode( ) == MCGIDI_quantityLookupMode_grouped ) {
        MCGIDI_reaction *reaction = MCGIDI_target_heated_getReactionAtIndex( target->baseHeatedTarget, ir );
 
        if( modes.getGroupIndex( ) == reaction->thresholdGroupIndex ) {
            double dEnergy = modes.getProjectileEnergy( ) - reaction->EMin;
 
            if( dEnergy  <= 0 ) return( MCGIDI_nullReaction );
            if( ( (*userrng)( rngState ) * reaction->thresholdGroupDomain ) > dEnergy ) return( MCGIDI_nullReaction );
        }
    }
    return( ir );
}

MCGIDI_uncorrelated_parseFromTOM()

int MCGIDI_uncorrelated_parseFromTOM	(	statusMessageReporting *	smr,
		xDataTOM_element *	element,
		MCGIDI_distribution *	distribution,
		ptwXYPoints *	norms,
		enum MCGIDI_energyType	energyType,
		double	gammaEnergy_MeV
	)

Definition at line 18 of file MCGIDI_uncorrelated.cc.

                                                                    {
 
    xDataTOM_element *uncorrelatedElement;
    ptwXYPoints *angularNorms = NULL;
 
    if( ( energyType == MCGIDI_energyType_primaryGamma ) || ( energyType == MCGIDI_energyType_discreteGamma ) ) {
        angularNorms = norms;
        uncorrelatedElement = element; }
    else {
        if( ( uncorrelatedElement = xDataTOME_getOneElementByName( smr, element, "uncorrelated", 1 ) ) == NULL ) goto err;
    }
 
    if( MCGIDI_angular_parseFromTOM( smr, uncorrelatedElement, distribution, angularNorms ) ) goto err;
    if( MCGIDI_energy_parseFromTOM( smr, uncorrelatedElement, distribution, norms, energyType, gammaEnergy_MeV ) ) goto err;
    distribution->type = MCGIDI_distributionType_uncorrelated_e;
 
    return( 0 );
 
err:
    return( 1 );
}

Referenced by MCGIDI_distribution_parseFromTOM().

MCGIDI_uncorrelated_sampleDistribution()

int MCGIDI_uncorrelated_sampleDistribution	(	statusMessageReporting *	smr,
		MCGIDI_distribution *	distribution,
		MCGIDI_quantitiesLookupModes &	modes,
		MCGIDI_decaySamplingInfo *	decaySamplingInfo
	)

Definition at line 43 of file MCGIDI_uncorrelated.cc.

                                                      {
 
    enum xDataTOM_frame frame;
 
    if( MCGIDI_energy_sampleEnergy( smr, distribution->energy, modes, decaySamplingInfo ) ) return( 1 );
    frame = decaySamplingInfo->frame;
    if( MCGIDI_angular_sampleMu( smr, distribution->angular, modes, decaySamplingInfo ) ) return( 1 );
    decaySamplingInfo->frame = frame;       /* Discrete and primary gammas in COM are treated as lab for now and energy sets it correctly. */
    return( 0 );
}

Referenced by MCGIDI_outputChannel_sampleProductsAtE().

MCGIDI_version()

char const * MCGIDI_version

(

void

)

Definition at line 13 of file MCGIDI_version.cc.

                                   {
 
    if( versionStr[0] == 0 ) snprintf( versionStr, sizeof versionStr, "MCGIDI version %d.%d.%d", MCGIDI_VERSION_MAJOR, MCGIDI_VERSION_MINOR, MCGIDI_VERSION_PATCHLEVEL );
    return( versionStr );
}

MCGIDI_versionMajor()

int MCGIDI_versionMajor

(

void

)

Definition at line 21 of file MCGIDI_version.cc.

{ return( MCGIDI_VERSION_MAJOR ); }

MCGIDI_versionMinor()

int MCGIDI_versionMinor

(

void

)

Definition at line 22 of file MCGIDI_version.cc.

{ return( MCGIDI_VERSION_MINOR ); }

MCGIDI_versionPatchLevel()

int MCGIDI_versionPatchLevel

(

void

)

Definition at line 23 of file MCGIDI_version.cc.

{ return( MCGIDI_VERSION_PATCHLEVEL ); }

Variable Documentation

MCGIDI_productGenre_NBody_angular_energy

const char * MCGIDI_productGenre_NBody_angular_energy

Definition at line 219 of file MCGIDI.h.

MCGIDI_productGenre_NBody_pairProduction

const char * MCGIDI_productGenre_NBody_pairProduction

Definition at line 219 of file MCGIDI.h.

MCGIDI_productGenre_twoBody_angular

const char * MCGIDI_productGenre_twoBody_angular

Definition at line 218 of file MCGIDI.h.

MCGIDI_productGenre_twoBody_formFactor

const char * MCGIDI_productGenre_twoBody_formFactor

Definition at line 218 of file MCGIDI.h.

MCGIDI_productGenre_unknown

const char* MCGIDI_productGenre_unknown

extern