PoPs.cc File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "PoPs.h"
#include "PoPs_private.h"

Go to the source code of this file.

Data Structures
struct	unitConversions_s

Macros
#define	AMU2eV   ( MeV2eV * 931.494028 )
#define	AMU2MeV   931.494028
#define	incrementalSize   1000
#define	K2eV   ( MeV2eV * K2MeV )
#define	K2MeV   8.6173856922566752e-11
#define	MeV2eV   1e6
#define	MeV2keV   1e3

Typedefs
typedef struct unitConversions_s	unitConversions

Functions
int	PoP_copyParticle (statusMessageReporting *smr, PoP *desc, PoP *src)
PoP *	PoP_free (PoP *pop)
int	PoP_getIndex (PoP *pop)
double	PoP_getMassInUnitOf (statusMessageReporting *smr, PoP *pop, char const *unit)
char const *	PoP_getName (PoP *pop)
int	PoP_initialize (statusMessageReporting *, PoP *pop)
PoP *	PoP_makeAlias (statusMessageReporting *smr, char const *name, char const *alias)
PoP *	PoP_makeParticle (statusMessageReporting *smr, enum PoPs_genre genre, char const *name, double mass, char const *massUnit)
PoP *	PoP_new (statusMessageReporting *smr)
int	PoP_release (PoP *pop)
int	PoP_setZ_A_l (statusMessageReporting *, PoP *pop, int Z, int A, int l)
PoP *	PoPs_addAliasIfNeeded (statusMessageReporting *smr, char const *name, char const *alias)
PoP *	PoPs_addParticleIfNeeded (statusMessageReporting *smr, PoP *pop)
PoP *	PoPs_copyAddParticleIfNeeded (statusMessageReporting *smr, PoP *pop)
char const *	PoPs_genreTokenToString (enum PoPs_genre genre)
int	PoPs_getAtomsIndex (statusMessageReporting *smr, char const *name)
int	PoPs_getAtomsIndex_atIndex (statusMessageReporting *smr, int index)
char const *	PoPs_getAtomsName (statusMessageReporting *smr, char const *name)
char const *	PoPs_getAtomsName_atIndex (statusMessageReporting *smr, int index)
enum PoPs_genre	PoPs_getGenre (statusMessageReporting *smr, char const *name)
enum PoPs_genre	PoPs_getGenre_atIndex (statusMessageReporting *smr, int index)
double	PoPs_getMassInUnitOf (statusMessageReporting *smr, char const *name, char const *unit)
double	PoPs_getMassInUnitOf_atIndex (statusMessageReporting *smr, int index, char const *unit)
char const *	PoPs_getName_atIndex (statusMessageReporting *smr, int index)
PoP *	PoPs_getParticle_atIndex (int index)
int	PoPs_getZ_A_l (statusMessageReporting *smr, char const *name, int *Z, int *A, int *l)
int	PoPs_getZ_A_l_atIndex (statusMessageReporting *smr, int index, int *Z, int *A, int *l)
int	PoPs_hasNucleus (statusMessageReporting *smr, char const *name, int protonIsNucleus)
int	PoPs_hasNucleus_atIndex (statusMessageReporting *smr, int index, int protonIsNucleus)
int	PoPs_numberOfParticle (void)
int	PoPs_particleIndex (char const *name)
int	PoPs_particleIndex_smr (statusMessageReporting *smr, char const *name, char const *file, int line, char const *func)
static int	PoPs_particleProperIndex (int index)
void	PoPs_print (int sorted)
int	PoPs_readDatabase (statusMessageReporting *smr, char const *fileName)
int	PoPs_register (void)
int	PoPs_release (statusMessageReporting *smr)
int	PoPs_releasePrivate (statusMessageReporting *)
static int	PoPs_sortedParticleIndex (char const *name)
int	PoPs_unitConversionRatio (char const *_from, char const *_to, double *ratio)
const char *	PoPs_version (void)
int	PoPs_versionMajor (void)
int	PoPs_versionMinor (void)
int	PoPs_versionPatchLevel (void)
void	PoPs_write (FILE *f, int sorted)
char const *	unitsDB_addUnitIfNeeded (statusMessageReporting *smr, char const *unit)
int	unitsDB_index (statusMessageReporting *, char const *unit)
static int	unitsDB_release (void)
char const *	unitsDB_stringFromIndex (statusMessageReporting *smr, int index)

Variables
static unitConversions	conversions []
static char const *	PoPs_genreStrings [] = { "invalid", "unknown", "alias", "photon", "lepton", "quark", "meson", "baryon", "nucleus", "atom" }
int	PoPs_smr_ID = smr_unknownID
static PoPs	popsRoot = { 0, 0, NULL, NULL }
static int	referenceCount = 0
static unitsDB	unitsRoot = { 0, 0, NULL }
static char	versionStr [64] = ""

Macro Definition Documentation

AMU2eV

#define AMU2eV   ( MeV2eV * 931.494028 )

Definition at line 23 of file PoPs.cc.

AMU2MeV

#define AMU2MeV   931.494028

Definition at line 22 of file PoPs.cc.

incrementalSize

#define incrementalSize   1000

Definition at line 18 of file PoPs.cc.

K2eV

#define K2eV   ( MeV2eV * K2MeV )

Definition at line 25 of file PoPs.cc.

K2MeV

#define K2MeV   8.6173856922566752e-11

Definition at line 24 of file PoPs.cc.

MeV2eV

#define MeV2eV   1e6

Definition at line 20 of file PoPs.cc.

MeV2keV

#define MeV2keV   1e3

Definition at line 21 of file PoPs.cc.

Typedef Documentation

unitConversions

typedef struct unitConversions_s unitConversions

Definition at line 27 of file PoPs.cc.

Function Documentation

PoP_copyParticle()

int PoP_copyParticle	(	statusMessageReporting *	smr,
		PoP *	desc,
		PoP *	src
	)

Definition at line 567 of file PoPs.cc.

                                                                         {
 
    desc->index = -1;
    desc->properIndex = src->properIndex;
    desc->aliasIndex = src->aliasIndex;
    desc->genre = src->genre;
    if( ( desc->name = smr_allocateCopyString2( smr, src->name, "desc->name" ) ) == NULL ) return( 1 );
    desc->Z = src->Z;
    desc->A = src->A;
    desc->l = src->l;
    desc->mass = src->mass;
    desc->massUnit = src->massUnit;
 
    return( 0 );
}

References PoP_s::A, PoP_s::aliasIndex, PoP_s::genre, PoP_s::index, PoP_s::l, PoP_s::mass, PoP_s::massUnit, PoP_s::name, PoP_s::properIndex, smr_allocateCopyString2, and PoP_s::Z.

Referenced by PoPs_copyAddParticleIfNeeded().

PoP_free()

PoP * PoP_free

(

PoP *

pop

)

Definition at line 558 of file PoPs.cc.

                          {
 
    PoP_release( pop );
    smr_freeMemory( (void **) &pop );
    return( NULL );
}

References PoP_release(), and smr_freeMemory().

Referenced by lPoPs_addParticleIfNeeded(), PoP_makeAlias(), PoP_makeParticle(), PoP_new(), PoPs_addAliasIfNeeded(), PoPs_copyAddParticleIfNeeded(), PoPs_particleCreateLoadInfo(), PoPs_particleReadDatabase(), and PoPs_releasePrivate().

PoP_getIndex()

int PoP_getIndex

(

PoP *

pop

)

Definition at line 612 of file PoPs.cc.

                             {
 
    return( pop->index );
}

References PoP_s::index.

PoP_getMassInUnitOf()

double PoP_getMassInUnitOf	(	statusMessageReporting *	smr,
		PoP *	pop,
		char const *	unit
	)

Definition at line 626 of file PoPs.cc.

                                                                                      {
 
    double mass = -1., ratio;
    /* PoP *pop_ = pop;*/
 
    /*if( pop->genre == PoPs_genre_alias ) pop_ = popsRoot.pops[PoPs_particleProperIndex( pop->index )];*/
    if( PoPs_unitConversionRatio( pop->massUnit, unit, &ratio ) != 0 ) {
        smr_setReportError2( smr, PoPs_smr_ID, PoPs_errorToken_badUnitConversion, "could not convert unit '%s' to '%s'", pop->massUnit, unit ); }
    else {
        mass = pop->mass * ratio;
    }
 
    return( mass );
}

References PoP_s::mass, PoP_s::massUnit, PoPs_errorToken_badUnitConversion, PoPs_smr_ID, PoPs_unitConversionRatio(), and smr_setReportError2.

Referenced by PoPs_getMassInUnitOf_atIndex().

PoP_getName()

char const * PoP_getName

(

PoP *

pop

)

Definition at line 619 of file PoPs.cc.

                                    {
 
    return( pop->name );
}

References PoP_s::name.

PoP_initialize()

int PoP_initialize	(	statusMessageReporting *	smr,
		PoP *	pop
	)

Definition at line 533 of file PoPs.cc.

                                                           {
 
    pop->index = -1;
    pop->properIndex = -1;
    pop->aliasIndex = -1;
    pop->genre = PoPs_genre_unknown;
    pop->name = NULL;
    pop->Z = 0;
    pop->A = 0;
    pop->mass = 0.0;
    pop->massUnit = NULL;
    return( 0 );
}

References PoP_s::A, PoP_s::aliasIndex, PoP_s::genre, PoP_s::index, PoP_s::mass, PoP_s::massUnit, PoP_s::name, PoPs_genre_unknown, PoP_s::properIndex, and PoP_s::Z.

Referenced by PoP_new(), and PoP_release().

PoP_makeAlias()

PoP * PoP_makeAlias	(	statusMessageReporting *	smr,
		char const *	name,
		char const *	alias
	)

Definition at line 647 of file PoPs.cc.

                                                                                       {
 
    int properIndex = PoPs_particleIndex( name ), aliasIndex = PoPs_particleIndex( alias );
    PoP *pop;
 
    if( properIndex < 0 ) {
        smr_setReportError2( smr, PoPs_smr_ID, PoPs_errorToken_badName, "proper particle '%s' not in PoPs for alias '%s'", name, alias );
        return( NULL );
    }
    if( aliasIndex >= 0 ) {     /* alias has already been defined. */
        PoP *truePop = popsRoot.pops[aliasIndex];
 
        for( pop = truePop; strcmp( alias, pop->name ); pop = popsRoot.pops[aliasIndex] ) aliasIndex = pop->aliasIndex;
        if( pop->genre != PoPs_genre_alias ) {
            smr_setReportError2( smr, PoPs_smr_ID, PoPs_errorToken_badName, "particle '%s' already in PoPs and not an alias", alias );
            return( NULL );
        }
        if( pop->properIndex != properIndex ) {
            smr_setReportError2( smr, PoPs_smr_ID, PoPs_errorToken_badName, "particle '%s' already an alias for '%s', cannot re-alias to '%s'", 
                alias, truePop->name, name );
            return( NULL );
        } }
    else {
        if( ( pop = PoP_new( smr ) ) == NULL ) return( NULL );
        if( ( pop->name = smr_allocateCopyString2( smr, alias, "name" ) ) == NULL ) {
            PoP_free( pop );
            return( NULL );
        }
        pop->properIndex = properIndex;
        pop->genre = PoPs_genre_alias;
    }
    return( pop );
}

References PoP_s::aliasIndex, PoP_s::genre, G4InuclParticleNames::name(), PoP_s::name, PoP_free(), PoP_new(), PoPs_s::pops, PoPs_errorToken_badName, PoPs_genre_alias, PoPs_particleIndex(), PoPs_smr_ID, popsRoot, PoP_s::properIndex, smr_allocateCopyString2, and smr_setReportError2.

Referenced by lPoPs_addParticleIfNeeded(), and PoPs_addAliasIfNeeded().

PoP_makeParticle()

PoP * PoP_makeParticle	(	statusMessageReporting *	smr,
		enum PoPs_genre	genre,
		char const *	name,
		double	mass,
		char const *	massUnit
	)

Definition at line 585 of file PoPs.cc.

                                                                                                                                 {
 
    PoP *pop;
    
    if( ( pop = PoP_new( smr ) ) == NULL ) return( NULL );
    if( ( pop->name = smr_allocateCopyString2( smr, name, "name" ) ) == NULL ) {
        PoP_free( pop );
        return( NULL );
    }
    pop->genre = genre;
    pop->mass = mass;
    if( ( pop->massUnit = unitsDB_addUnitIfNeeded( smr, massUnit ) ) == NULL ) pop = PoP_free( pop );
    return( pop );
}

References PoP_s::genre, PoP_s::mass, PoP_s::massUnit, G4InuclParticleNames::name(), PoP_s::name, PoP_free(), PoP_new(), smr_allocateCopyString2, and unitsDB_addUnitIfNeeded().

PoP_new()

PoP * PoP_new

(

statusMessageReporting *

smr

)

Definition at line 522 of file PoPs.cc.

                                            {
 
    PoP *pop;
 
    if( ( pop = (PoP *) smr_malloc2( smr, sizeof( PoP ), 0, "pop" ) ) == NULL ) return( NULL );
    if( PoP_initialize( smr, pop ) != 0 ) pop = PoP_free( pop );
    return( pop );
}

References PoP_free(), PoP_initialize(), and smr_malloc2.

Referenced by PoP_makeAlias(), PoP_makeParticle(), and PoPs_particleCreateLoadInfo().

PoP_release()

int PoP_release

(

PoP *

pop

)

Definition at line 549 of file PoPs.cc.

                            {
 
    if( pop->name != NULL ) smr_freeMemory( (void **) &(pop->name ) );
    PoP_initialize( NULL, pop );                                /* Make it clean in case someone trys to use if. */
    return( 0 );
}

References PoP_s::name, PoP_initialize(), and smr_freeMemory().

Referenced by PoP_free().

PoP_setZ_A_l()

int PoP_setZ_A_l	(	statusMessageReporting *	smr,
		PoP *	pop,
		int	Z,
		int	A,
		int	l
	)

Definition at line 602 of file PoPs.cc.

                                                                              {
 
    pop->Z = Z;
    pop->A = A;
    pop->l = l;
    return( 0 );
}

References A, PoP_s::A, PoP_s::l, Z, and PoP_s::Z.

PoPs_addAliasIfNeeded()

PoP * PoPs_addAliasIfNeeded	(	statusMessageReporting *	smr,
		char const *	name,
		char const *	alias
	)

Definition at line 179 of file PoPs.cc.

                                                                                               {
 
    PoP *pop = PoP_makeAlias( smr, name, alias );
 
    if( pop != NULL ) {
        if( pop->index < 0 ) {
            if( PoPs_addParticleIfNeeded( smr, pop ) == NULL ) {
                PoP_free( pop );
                return( NULL );
            }
        }
    }
    
    return( pop );
}

References PoP_s::index, G4InuclParticleNames::name(), PoP_free(), PoP_makeAlias(), and PoPs_addParticleIfNeeded().

Referenced by MCGIDI_map_initialize().

PoPs_addParticleIfNeeded()

PoP * PoPs_addParticleIfNeeded	(	statusMessageReporting *	smr,
		PoP *	pop
	)

Definition at line 113 of file PoPs.cc.

                                                                       {
/*
    If particle with name pop->name is already in popsRoot, returns the pointer to the existing particle.
    A NULL is returned if adding particle to popsRoot fails.
*/
    int i, index = PoPs_sortedParticleIndex( pop->name );
 
    if( index >= 0 ) return( popsRoot.pops[PoPs_particleProperIndex( popsRoot.sorted[index]->index )] );
    if( popsRoot.numberOfParticles == popsRoot.allocated ) {
        int size = popsRoot.allocated + incrementalSize;
        PoP **sorted, **pops = (PoP **) smr_malloc2( smr, 2 * size * sizeof( PoPs * ), 0, "pops" );
 
        if( pops == NULL ) return( NULL );
        sorted = &(pops[size]);
        for( i = 0; i < popsRoot.numberOfParticles; i++ ) {
            pops[i] = popsRoot.pops[i];
            sorted[i] = popsRoot.sorted[i];
        }
        smr_freeMemory( (void **) &(popsRoot.pops) );
        popsRoot.pops = pops;
        popsRoot.sorted = sorted;
        popsRoot.allocated = size;
    }
    popsRoot.pops[popsRoot.numberOfParticles] = pop;
    index = -index - 1;
    for( i = popsRoot.numberOfParticles; i > index; i-- ) popsRoot.sorted[i] = popsRoot.sorted[i-1];
    popsRoot.sorted[index] = pop;
    pop->index = popsRoot.numberOfParticles;
    popsRoot.numberOfParticles++;
    if( pop->genre == PoPs_genre_alias ) {  /* Add pop->index to end of list of particles aliased by pop->properIndex. */
        PoP *pop2;
 
        for( pop2 = popsRoot.pops[pop->properIndex]; pop2->aliasIndex >= 0; pop2 = popsRoot.pops[pop2->aliasIndex] ) ;
        pop2->aliasIndex = pop->index;
    }
    return( pop );
}

References PoP_s::aliasIndex, PoPs_s::allocated, PoP_s::genre, incrementalSize, PoP_s::index, PoP_s::name, PoPs_s::numberOfParticles, PoPs_s::pops, PoPs_genre_alias, PoPs_particleProperIndex(), PoPs_sortedParticleIndex(), popsRoot, PoP_s::properIndex, smr_freeMemory(), smr_malloc2, and PoPs_s::sorted.

Referenced by lPoPs_addParticleIfNeeded(), PoPs_addAliasIfNeeded(), PoPs_copyAddParticleIfNeeded(), and PoPs_particleReadDatabase().

PoPs_copyAddParticleIfNeeded()

PoP * PoPs_copyAddParticleIfNeeded	(	statusMessageReporting *	smr,
		PoP *	pop
	)

Definition at line 153 of file PoPs.cc.

                                                                           {
/*
    If particle with name pop->name is already in popsRoot, return the address of the existing particle.
    If particle is not in popsRoot then copy particle to a new 'PoP *', add the copied PoP to popsRoot and return its address.
    A NULL is return if particle coping fails or adding particle to popsRoot fails.
*/
 
    int index = PoPs_particleIndex( pop->name );
    PoP *newPoP;
 
    if( index >= 0 ) return( popsRoot.pops[index] );
 
    if( ( newPoP = (PoP *) smr_malloc2( smr, sizeof( PoP ), 0, "newPoP" ) ) == NULL ) return( NULL );
    if( PoP_copyParticle( smr, newPoP, pop ) ) {
        smr_freeMemory( (void **) &newPoP );
        return( NULL );
    }
    if( PoPs_addParticleIfNeeded( smr, newPoP ) == NULL ) {
        PoP_free( newPoP );
        return( NULL );
    }
    return( newPoP );
}

References PoP_s::name, PoP_copyParticle(), PoP_free(), PoPs_s::pops, PoPs_addParticleIfNeeded(), PoPs_particleIndex(), popsRoot, smr_freeMemory(), and smr_malloc2.

PoPs_genreTokenToString()

char const * PoPs_genreTokenToString

(

enum PoPs_genre

genre

)

Definition at line 446 of file PoPs.cc.

                                                             {
 
    if( genre < PoPs_genre_invalid ) return( NULL );
    if( genre > PoPs_genre_atom ) return( NULL );
    return( PoPs_genreStrings[genre] );
}

References PoPs_genre_atom, PoPs_genre_invalid, and PoPs_genreStrings.

Referenced by PoPs_write().

PoPs_getAtomsIndex()

int PoPs_getAtomsIndex	(	statusMessageReporting *	smr,
		char const *	name
	)

Definition at line 397 of file PoPs.cc.

                                                                        {
 
    int index = PoPs_particleIndex_smr( smr, name, __FILE__, __LINE__, __func__ );
 
    if( index < 0 ) return( index );
    return( PoPs_getAtomsIndex_atIndex( smr, index ) );
}

References G4InuclParticleNames::name(), PoPs_getAtomsIndex_atIndex(), and PoPs_particleIndex_smr().

PoPs_getAtomsIndex_atIndex()

int PoPs_getAtomsIndex_atIndex	(	statusMessageReporting *	smr,
		int	index
	)

Definition at line 407 of file PoPs.cc.

                                                                         {
 
    char const *p = NULL;
 
    if( ( index < 0 ) || ( index >= popsRoot.numberOfParticles ) ) {
        smr_setReportError2( smr, PoPs_smr_ID, PoPs_errorToken_badIndex, "index %d not in PoPs", index );
        return( -1 );
    }
 
    if( popsRoot.pops[index]->genre == PoPs_genre_atom ) return( index );
 
    if(      strcmp( "p", popsRoot.pops[index]->name ) == 0 ) {
        p = "H1"; }
    else {
        if( popsRoot.pops[index]->genre != PoPs_genre_nucleus ) return( -1 );
        else if( strcmp( "h2", popsRoot.pops[index]->name ) == 0 ) {
            p = "H2"; }
        else if( strcmp( "h3", popsRoot.pops[index]->name ) == 0 ) {
            p = "H3"; }
        else if( strcmp( "he3", popsRoot.pops[index]->name ) == 0 ) {
            p = "He3"; }
        else if( strcmp( "he4", popsRoot.pops[index]->name ) == 0 ) {
            p = "He4";
        }
    }
    if( p != NULL ) return( PoPs_particleIndex_smr( smr, p, __FILE__, __LINE__, __func__ ) );
    return( -1 );
}

References PoP_s::genre, PoP_s::name, PoPs_s::numberOfParticles, PoPs_s::pops, PoPs_errorToken_badIndex, PoPs_genre_atom, PoPs_genre_nucleus, PoPs_particleIndex_smr(), PoPs_smr_ID, popsRoot, and smr_setReportError2.

Referenced by PoPs_getAtomsIndex(), and PoPs_getAtomsName_atIndex().

PoPs_getAtomsName()

char const * PoPs_getAtomsName	(	statusMessageReporting *	smr,
		char const *	name
	)

Definition at line 377 of file PoPs.cc.

                                                                               {
 
    int index = PoPs_particleIndex_smr( smr, name, __FILE__, __LINE__, __func__ );
 
    if( index < 0 ) return( NULL );
    return( PoPs_getAtomsName_atIndex( smr, index ) );
}

References G4InuclParticleNames::name(), PoPs_getAtomsName_atIndex(), and PoPs_particleIndex_smr().

PoPs_getAtomsName_atIndex()

char const * PoPs_getAtomsName_atIndex	(	statusMessageReporting *	smr,
		int	index
	)

Definition at line 387 of file PoPs.cc.

                                                                                {
 
    int atomIndex = PoPs_getAtomsIndex_atIndex( smr, index );
 
    if( atomIndex < 0 ) return( NULL );
    return( popsRoot.pops[atomIndex]->name );
}

References PoP_s::name, PoPs_s::pops, PoPs_getAtomsIndex_atIndex(), and popsRoot.

Referenced by PoPs_getAtomsName().

PoPs_getGenre()

enum PoPs_genre PoPs_getGenre	(	statusMessageReporting *	smr,
		char const *	name
	)

Definition at line 301 of file PoPs.cc.

                                                                               {
 
    int index = PoPs_particleIndex_smr( smr, name, __FILE__, __LINE__, __func__ );
 
    if( index < 0 ) return( PoPs_genre_invalid );
    return( popsRoot.pops[index]->genre );
}

References PoP_s::genre, G4InuclParticleNames::name(), PoPs_s::pops, PoPs_genre_invalid, PoPs_particleIndex_smr(), and popsRoot.

PoPs_getGenre_atIndex()

enum PoPs_genre PoPs_getGenre_atIndex	(	statusMessageReporting *	smr,
		int	index
	)

Definition at line 311 of file PoPs.cc.

                                                                                {
 
    enum PoPs_genre genre = PoPs_genre_invalid;
 
    if( ( index < 0 ) || ( index >= popsRoot.numberOfParticles ) ) {
        smr_setReportError2( smr, PoPs_smr_ID, PoPs_errorToken_badIndex, "index %d not in PoPs", index ); }
    else {
        genre = popsRoot.pops[index]->genre;
    }
    return( genre );
}

References PoP_s::genre, PoPs_s::numberOfParticles, PoPs_s::pops, PoPs_errorToken_badIndex, PoPs_genre_invalid, PoPs_smr_ID, popsRoot, and smr_setReportError2.

PoPs_getMassInUnitOf()

double PoPs_getMassInUnitOf	(	statusMessageReporting *	smr,
		char const *	name,
		char const *	unit
	)

Definition at line 265 of file PoPs.cc.

                                                                                               {
 
    int index = PoPs_particleIndex_smr( smr, name, __FILE__, __LINE__, __func__ );
 
    if( index < 0 ) return( -1. );
    return( PoPs_getMassInUnitOf_atIndex( smr, index, unit ) );
}

References G4InuclParticleNames::name(), PoPs_getMassInUnitOf_atIndex(), and PoPs_particleIndex_smr().

PoPs_getMassInUnitOf_atIndex()

double PoPs_getMassInUnitOf_atIndex	(	statusMessageReporting *	smr,
		int	index,
		char const *	unit
	)

Definition at line 286 of file PoPs.cc.

                                                                                                {
 
    double mass = -1.;
 
    if( ( index < 0 ) || ( index >= popsRoot.numberOfParticles ) ) {
        smr_setReportError2( smr, PoPs_smr_ID, PoPs_errorToken_badIndex, "index %d not in PoPs", index ); }
    else {
        mass = PoP_getMassInUnitOf( smr, popsRoot.pops[index], unit );
    }
 
    return( mass );
}

References PoPs_s::numberOfParticles, PoP_getMassInUnitOf(), PoPs_s::pops, PoPs_errorToken_badIndex, PoPs_smr_ID, popsRoot, and smr_setReportError2.

Referenced by PoPs_getMassInUnitOf().

PoPs_getName_atIndex()

char const * PoPs_getName_atIndex	(	statusMessageReporting *	smr,
		int	index
	)

Definition at line 275 of file PoPs.cc.

                                                                           {
 
    if( ( index < 0 ) || ( index >= popsRoot.numberOfParticles ) ) {
        smr_setReportError2( smr, PoPs_smr_ID, PoPs_errorToken_badIndex, "index %d not in PoPs", index );
        return( NULL );
    }
    return( popsRoot.pops[index]->name );
}

References PoP_s::name, PoPs_s::numberOfParticles, PoPs_s::pops, PoPs_errorToken_badIndex, PoPs_smr_ID, popsRoot, and smr_setReportError2.

Referenced by MCGIDI_map_findTargetViaPoPIDs().

PoPs_getParticle_atIndex()

PoP * PoPs_getParticle_atIndex

(

int

index

)

Definition at line 438 of file PoPs.cc.

                                           {
 
    if( ( index < 0 ) || ( index >= popsRoot.numberOfParticles ) ) return( NULL );
    return( popsRoot.pops[index] );
}

References PoPs_s::numberOfParticles, PoPs_s::pops, and popsRoot.

PoPs_getZ_A_l()

int PoPs_getZ_A_l	(	statusMessageReporting *	smr,
		char const *	name,
		int *	Z,
		int *	A,
		int *	l
	)

Definition at line 325 of file PoPs.cc.

                                                                                           {
 
    int index = PoPs_particleIndex_smr( smr, name, __FILE__, __LINE__, __func__ );
 
    if( index < 0 ) return( -1 );
    return( PoPs_getZ_A_l_atIndex( smr, index, Z, A, l ) );
}

References A, G4InuclParticleNames::name(), PoPs_getZ_A_l_atIndex(), PoPs_particleIndex_smr(), and Z.

PoPs_getZ_A_l_atIndex()

int PoPs_getZ_A_l_atIndex	(	statusMessageReporting *	smr,
		int	index,
		int *	Z,
		int *	A,
		int *	l
	)

Definition at line 335 of file PoPs.cc.

                                                                                            {
 
    if( ( index < 0 ) || ( index >= popsRoot.numberOfParticles ) ) {
        smr_setReportError2( smr, PoPs_smr_ID, PoPs_errorToken_badIndex, "index %d not in PoPs", index );
        return( -1 );
    }
    *Z = popsRoot.pops[index]->Z;
    *A = popsRoot.pops[index]->A;
    *l = 0;
    return( 0 );
}

References A, PoP_s::A, PoPs_s::numberOfParticles, PoPs_s::pops, PoPs_errorToken_badIndex, PoPs_smr_ID, popsRoot, smr_setReportError2, Z, and PoP_s::Z.

Referenced by PoPs_getZ_A_l().

PoPs_hasNucleus()

int PoPs_hasNucleus	(	statusMessageReporting *	smr,
		char const *	name,
		int	protonIsNucleus
	)

Definition at line 349 of file PoPs.cc.

                                                                                          {
 
    int index = PoPs_particleIndex_smr( smr, name, __FILE__, __LINE__, __func__ );
 
    if( index < 0 ) return( -1 );
    return( PoPs_hasNucleus_atIndex( smr, index, protonIsNucleus ) );
}

References G4InuclParticleNames::name(), PoPs_hasNucleus_atIndex(), and PoPs_particleIndex_smr().

Referenced by PoPs_write().

PoPs_hasNucleus_atIndex()

int PoPs_hasNucleus_atIndex	(	statusMessageReporting *	smr,
		int	index,
		int	protonIsNucleus
	)

Definition at line 359 of file PoPs.cc.

                                                                                           {
/*
*   If an error is encountered, a negative value is returned. A value greater than 0 means the particle
*   contains a nucleus (is an atom, ion or nucleus). Otherwise, a 0 is returned.
*/
    if( ( index < 0 ) || ( index >= popsRoot.numberOfParticles ) ) {
        smr_setReportError2( smr, PoPs_smr_ID, PoPs_errorToken_badIndex, "index %d not in PoPs", index );
        return( -1 );
    }
    if( ( popsRoot.pops[index]->genre == PoPs_genre_nucleus ) || ( popsRoot.pops[index]->genre == PoPs_genre_atom ) ) return( 1 );
    if( protonIsNucleus ) {
        if( strcmp( "p", popsRoot.pops[index]->name ) == 0 ) return( 1 );
    }
    return( 0 );
}

References PoP_s::genre, PoP_s::name, PoPs_s::numberOfParticles, PoPs_s::pops, PoPs_errorToken_badIndex, PoPs_genre_atom, PoPs_genre_nucleus, PoPs_smr_ID, popsRoot, and smr_setReportError2.

Referenced by PoPs_hasNucleus().

PoPs_numberOfParticle()

int PoPs_numberOfParticle

(

void

)

Definition at line 197 of file PoPs.cc.

                                  {
 
    return( popsRoot.numberOfParticles );
}

References PoPs_s::numberOfParticles, and popsRoot.

PoPs_particleIndex()

int PoPs_particleIndex

(

char const *

name

)

Definition at line 204 of file PoPs.cc.

                                           {
/*
    A negative number is return if particle is not in popsRoot. Else, the Id of the real (not aliased) particle is returned.
*/
    int index = PoPs_sortedParticleIndex( name );
 
    if( index >= 0 ) index = PoPs_particleProperIndex( popsRoot.sorted[index]->index );
    return( index );
}

References PoP_s::index, G4InuclParticleNames::name(), PoPs_particleProperIndex(), PoPs_sortedParticleIndex(), popsRoot, and PoPs_s::sorted.

Referenced by lPoPs_addParticleIfNeeded(), MCGIDI_reaction_ParseDetermineReactionProducts(), MCGIDI_reaction_particleChanges(), PoP_makeAlias(), PoPs_copyAddParticleIfNeeded(), and PoPs_particleIndex_smr().

PoPs_particleIndex_smr()

int PoPs_particleIndex_smr	(	statusMessageReporting *	smr,
		char const *	name,
		char const *	file,
		int	line,
		char const *	func
	)

Definition at line 216 of file PoPs.cc.

                                                                                                                          {
 
    int index = PoPs_particleIndex( name );
 
    if( index < 0 )
        smr_setReportError( smr, NULL, file, line, func, PoPs_smr_ID, PoPs_errorToken_badName, "particle '%s' not in PoPs", name );
    return( index );
}

References geant4_check_module_cycles::file, G4InuclParticleNames::name(), PoPs_errorToken_badName, PoPs_particleIndex(), PoPs_smr_ID, and smr_setReportError().

Referenced by PoPs_getAtomsIndex(), PoPs_getAtomsIndex_atIndex(), PoPs_getAtomsName(), PoPs_getGenre(), PoPs_getMassInUnitOf(), PoPs_getZ_A_l(), and PoPs_hasNucleus().

PoPs_particleProperIndex()

static int PoPs_particleProperIndex ( int  index )

static

Definition at line 227 of file PoPs.cc.

                                                 {
 
    while( popsRoot.pops[index]->properIndex >= 0 ) index = popsRoot.pops[index]->properIndex;  /* For alias particles. */  // Loop checking, 11.05.2015, T. Koi
    return( index );
}

References PoPs_s::pops, popsRoot, and PoP_s::properIndex.

Referenced by PoPs_addParticleIfNeeded(), PoPs_particleIndex(), and PoPs_write().

PoPs_print()

void PoPs_print

(

int

sorted

)

Definition at line 455 of file PoPs.cc.

                              {
 
    PoPs_write( stdout, sorted );
}

References PoPs_write().

PoPs_readDatabase()

int PoPs_readDatabase	(	statusMessageReporting *	smr,
		char const *	fileName
	)

Definition at line 81 of file PoPs.cc.

                                                                           {
 
    return( PoPs_particleReadDatabase( smr, fileName ) );
}

References PoPs_particleReadDatabase().

PoPs_register()

int PoPs_register

(

void

)

Definition at line 73 of file PoPs.cc.

                          {
 
    if( referenceCount < 0 ) return( -1 );
    return( ++referenceCount );
}

References referenceCount.

PoPs_release()

int PoPs_release

(

statusMessageReporting *

smr

)

Definition at line 88 of file PoPs.cc.

                                                {
 
    referenceCount--;
    if( referenceCount != 0 ) return( referenceCount );
    PoPs_releasePrivate( smr );
    return( 0 );
}

References PoPs_releasePrivate(), and referenceCount.

PoPs_releasePrivate()

int PoPs_releasePrivate

(

statusMessageReporting *

smr

)

Definition at line 98 of file PoPs.cc.

                                                      {
 
    int i;
 
    for( i = 0; i < popsRoot.numberOfParticles; i++ ) PoP_free( popsRoot.pops[i] );
    smr_freeMemory( (void **) &(popsRoot.pops) );
    popsRoot.sorted = NULL;
    popsRoot.numberOfParticles = 0;
    popsRoot.allocated = 0;
    unitsDB_release( );
    return( 0 );
}

References PoPs_s::allocated, PoPs_s::numberOfParticles, PoP_free(), PoPs_s::pops, popsRoot, smr_freeMemory(), PoPs_s::sorted, and unitsDB_release().

Referenced by PoPs_release().

PoPs_sortedParticleIndex()

static int PoPs_sortedParticleIndex ( char const *  name )

static

Definition at line 235 of file PoPs.cc.

                                                        {
/*
    If name is a particle in popsRoot, its index in the sorted list is returned; otherwise,
    a negative number is returned. For a particle not found, its index would be -returnValue + 1 if added;
*/
    int low = 0, mid, high = popsRoot.numberOfParticles, iCmp;
 
    if( high == 0 ) return( -1 );
    while( ( high - low ) > 1 ) {
        mid = ( low + high ) >> 1;
        iCmp = strcmp( name, popsRoot.sorted[mid]->name );
        if( iCmp == 0 ) return( mid );
        if( iCmp > 0 ) {
            low = mid; }
        else {
            high = mid;
        }
    }  // Loop checking, 11.05.2015, T. Koi
    if( high == 1 ) {           /* First point is not checked as loop exits when ( high = 1 ) - ( low = 0 ) <= 1 ). */
        if( !strcmp( name, popsRoot.sorted[0]->name ) ) return( 0 );            /* First name is a match. */
        if( strcmp( name, popsRoot.sorted[0]->name ) < 0 ) return( -1 );        /* name is less than first name. */
    }
    if( high < popsRoot.numberOfParticles ) {
        if( strcmp( name, popsRoot.sorted[high]->name ) == 0 ) return( high );
    }
    return( -high - 1 );
}

References G4InuclParticleNames::name(), PoP_s::name, PoPs_s::numberOfParticles, popsRoot, and PoPs_s::sorted.

Referenced by PoPs_addParticleIfNeeded(), and PoPs_particleIndex().

PoPs_unitConversionRatio()

int PoPs_unitConversionRatio	(	char const *	_from,
		char const *	_to,
		double *	ratio
	)

Definition at line 748 of file PoPs.cc.

                                                                                  {
 
    int i, n = sizeof( conversions ) / sizeof( conversions[0] );
 
    *ratio = 1.;
    if( strcmp( _from, _to ) == 0 ) return( 0 );
    for( i = 0; i < n; i++ ) {
        if( strcmp( conversions[i]._from, _from ) == 0 ) {
            if( strcmp( conversions[i]._to, _to ) == 0 ) {
                *ratio = conversions[i].ratio;
                return( 0 );
            } }
        else if( strcmp( conversions[i]._to, _from ) == 0 ) {
            if( strcmp( conversions[i]._from, _to ) == 0 ) {
                *ratio = 1. / conversions[i].ratio;
                return( 0 );
            }
        }
    }
    return( 1 );
}

References conversions, CLHEP::detail::n, and unitConversions_s::ratio.

Referenced by PoP_getMassInUnitOf().

PoPs_version()

const char * PoPs_version

(

void

)

Definition at line 59 of file PoPs.cc.

                                 {
 
    if( versionStr[0] == 0 ) sprintf( versionStr, "PoPs version %d.%d.%d", POPS_VERSION_MAJOR, POPS_VERSION_MINOR, POPS_VERSION_PATCHLEVEL );
    return( versionStr );
}

References POPS_VERSION_MAJOR, POPS_VERSION_MINOR, POPS_VERSION_PATCHLEVEL, and versionStr.

PoPs_versionMajor()

int PoPs_versionMajor

(

void

)

Definition at line 67 of file PoPs.cc.

{ return( POPS_VERSION_MAJOR ); }

References POPS_VERSION_MAJOR.

PoPs_versionMinor()

int PoPs_versionMinor

(

void

)

Definition at line 68 of file PoPs.cc.

{ return( POPS_VERSION_MINOR ); }

References POPS_VERSION_MINOR.

PoPs_versionPatchLevel()

int PoPs_versionPatchLevel

(

void

)

Definition at line 69 of file PoPs.cc.

{ return( POPS_VERSION_PATCHLEVEL ); }

References POPS_VERSION_PATCHLEVEL.

PoPs_write()

void PoPs_write	(	FILE *	f,
		int	sorted
	)

Definition at line 462 of file PoPs.cc.

                                       {
 
    int i1, properIndex;
    PoP *pop;
 
    fprintf( f, "Mass units: number of units = %d\n", unitsRoot.numberOfUnits );
    for( i1 = 0; i1 < unitsRoot.numberOfUnits; i1++ ) {
        fprintf( f, " %s", unitsRoot.unsorted[i1] );
    }
    fprintf( f, "\n\n" );
    fprintf( f, "Particles: number of particles = %d\n", popsRoot.numberOfParticles );
    fprintf( f, " name                      index   genre            mass             hasNucleus    alias info\n" );
    fprintf( f, "                                                                           Z   A l\n" );
    fprintf( f, " --------------------------------------------------------------------------------------------\n" );
    for( i1 = 0; i1 < popsRoot.numberOfParticles; i1++ ) {
        if( sorted ) {
            pop = popsRoot.sorted[i1]; }
        else {
            pop = popsRoot.pops[i1];
        }
        properIndex = PoPs_particleProperIndex( pop->index );
        fprintf( f, " %-24s %6d   %-10s %15.8e %-6s", pop->name, pop->index, PoPs_genreTokenToString( pop->genre ), 
            popsRoot.pops[properIndex]->mass, popsRoot.pops[properIndex]->massUnit );
        if( PoPs_hasNucleus( NULL, pop->name, 0 ) ) {
            fprintf( f, " T" ); }
        else {
            fprintf( f, "  " );
        }
        if( PoPs_hasNucleus( NULL, pop->name, 1 ) ) {
            fprintf( f, " T" ); }
        else {
            fprintf( f, "  " );
        }
        if( pop->Z + pop->A > 0 ) {
            fprintf( f, " %3d %3d", pop->Z, pop->A );
            if( pop->l > 0 ) {
                fprintf( f, " %d", pop->l ); }
            else {
                fprintf( f, "  " );
            } }
        else {
            fprintf( f, "          " );
        }
        if( pop->genre == PoPs_genre_alias ) {
            fprintf( f, " %s (%d)", popsRoot.pops[properIndex]->name, popsRoot.pops[properIndex]->index ); }
        else {
            int aliasIndex;
 
            for( aliasIndex = pop->aliasIndex; aliasIndex >= 0; aliasIndex = popsRoot.pops[aliasIndex]->aliasIndex ) fprintf( f, " %d", aliasIndex );
        }
        fprintf( f, "\n" );
    }
}

References PoP_s::A, PoP_s::aliasIndex, PoP_s::genre, PoP_s::index, PoP_s::l, PoP_s::mass, PoP_s::massUnit, PoP_s::name, PoPs_s::numberOfParticles, unitsDB_s::numberOfUnits, PoPs_s::pops, PoPs_genre_alias, PoPs_genreTokenToString(), PoPs_hasNucleus(), PoPs_particleProperIndex(), popsRoot, PoPs_s::sorted, unitsRoot, unitsDB_s::unsorted, and PoP_s::Z.

Referenced by PoPs_print().

unitsDB_addUnitIfNeeded()

char const * unitsDB_addUnitIfNeeded	(	statusMessageReporting *	smr,
		char const *	unit
	)

Definition at line 700 of file PoPs.cc.

                                                                                     {
 
    int i;
 
    for( i = 0; i < unitsRoot.numberOfUnits; i++ ) {
        if( strcmp(  unit, unitsRoot.unsorted[i] ) == 0 ) return( unitsRoot.unsorted[i] );
    }
    if( unitsRoot.numberOfUnits == unitsRoot.allocated ) {
        int size = unitsRoot.allocated + 20;
        char const **unsorted = (char const **) smr_malloc2( smr, size * sizeof( char * ), 0, "unsorted" );
 
        if( unsorted == NULL ) return( NULL );
        for( i = 0; i < unitsRoot.numberOfUnits; i++ ) unsorted[i] = unitsRoot.unsorted[i];
        smr_freeMemory( (void **) &(unitsRoot.unsorted) );
        unitsRoot.unsorted = unsorted;
        unitsRoot.allocated = size;
    }
    if( ( unitsRoot.unsorted[unitsRoot.numberOfUnits] = smr_allocateCopyString2( smr, unit, "unitsRoot.unsorted[unitsRoot.numberOfUnits]" ) ) == NULL ) 
        return( NULL );
    unitsRoot.numberOfUnits++;
    return( unitsRoot.unsorted[unitsRoot.numberOfUnits - 1] );
}

References unitsDB_s::allocated, unitsDB_s::numberOfUnits, smr_allocateCopyString2, smr_freeMemory(), smr_malloc2, unitsRoot, and unitsDB_s::unsorted.

Referenced by PoP_makeParticle(), and PoPs_particleLoadInfo().

unitsDB_index()

int unitsDB_index	(	statusMessageReporting *	smr,
		char const *	unit
	)

Definition at line 725 of file PoPs.cc.

                                                                  {
 
    int i;
 
    for( i = 0; i < unitsRoot.numberOfUnits; i++ ) {
        if( !strcmp( unit, unitsRoot.unsorted[i] ) ) return( i );
    }
    return( -1 );
}

References unitsDB_s::numberOfUnits, unitsRoot, and unitsDB_s::unsorted.

unitsDB_release()

static int unitsDB_release ( void  )

static

Definition at line 687 of file PoPs.cc.

                                   {
 
    int i;
 
    for( i = 0; i < unitsRoot.numberOfUnits; i++ ) smr_freeMemory( (void **) &(unitsRoot.unsorted[i]) );
    smr_freeMemory( (void **) &(unitsRoot.unsorted) );
    unitsRoot.numberOfUnits = 0;
    unitsRoot.allocated = 0;
    return( 0 );
}

References unitsDB_s::allocated, unitsDB_s::numberOfUnits, smr_freeMemory(), unitsRoot, and unitsDB_s::unsorted.

Referenced by PoPs_releasePrivate().

unitsDB_stringFromIndex()

char const * unitsDB_stringFromIndex	(	statusMessageReporting *	smr,
		int	index
	)

Definition at line 737 of file PoPs.cc.

                                                                              {
 
    if( ( index < 0 ) || ( index >= unitsRoot.numberOfUnits ) ) {
        smr_setReportError2( smr, PoPs_smr_ID, 1, "index = %d out of baounds [0 to %d)", index, unitsRoot.numberOfUnits );
        return( NULL );
    }
    return( unitsRoot.unsorted[index] );
}

References unitsDB_s::numberOfUnits, PoPs_smr_ID, smr_setReportError2, unitsRoot, and unitsDB_s::unsorted.

Variable Documentation

conversions

unitConversions conversions[]

static

Initial value:

= { { "amu", "eV/c**2", AMU2eV }, { "amu", "MeV/c**2", AMU2MeV }, { "MeV/c**2", "eV/c**2", MeV2eV }, 
    { "MeV", "eV", MeV2eV }, { "MeV", "keV", MeV2keV }, { "K", "MeV", K2MeV }, { "K", "eV", K2eV } }

Definition at line 48 of file PoPs.cc.

Referenced by PoPs_unitConversionRatio().

PoPs_genreStrings

char const* PoPs_genreStrings[] = { "invalid", "unknown", "alias", "photon", "lepton", "quark", "meson", "baryon", "nucleus", "atom" }

static

Definition at line 51 of file PoPs.cc.

Referenced by PoPs_genreTokenToString().

PoPs_smr_ID

int PoPs_smr_ID = smr_unknownID

Definition at line 35 of file PoPs.cc.

Referenced by lPoPs_addParticleIfNeeded(), PoP_getMassInUnitOf(), PoP_makeAlias(), PoPs_getAtomsIndex_atIndex(), PoPs_getGenre_atIndex(), PoPs_getMassInUnitOf_atIndex(), PoPs_getName_atIndex(), PoPs_getZ_A_l_atIndex(), PoPs_hasNucleus_atIndex(), PoPs_particleIndex_smr(), and unitsDB_stringFromIndex().

popsRoot

PoPs popsRoot = { 0, 0, NULL, NULL }

static

Definition at line 43 of file PoPs.cc.

Referenced by PoP_makeAlias(), PoPs_addParticleIfNeeded(), PoPs_copyAddParticleIfNeeded(), PoPs_getAtomsIndex_atIndex(), PoPs_getAtomsName_atIndex(), PoPs_getGenre(), PoPs_getGenre_atIndex(), PoPs_getMassInUnitOf_atIndex(), PoPs_getName_atIndex(), PoPs_getParticle_atIndex(), PoPs_getZ_A_l_atIndex(), PoPs_hasNucleus_atIndex(), PoPs_numberOfParticle(), PoPs_particleIndex(), PoPs_particleProperIndex(), PoPs_releasePrivate(), PoPs_sortedParticleIndex(), and PoPs_write().

referenceCount

int referenceCount = 0

static

Definition at line 36 of file PoPs.cc.

Referenced by PoPs_register(), and PoPs_release().

unitsRoot

unitsDB unitsRoot = { 0, 0, NULL }

static

Definition at line 42 of file PoPs.cc.

Referenced by PoPs_write(), unitsDB_addUnitIfNeeded(), unitsDB_index(), unitsDB_release(), and unitsDB_stringFromIndex().

versionStr

char versionStr[64] = ""

static

Definition at line 37 of file PoPs.cc.

Referenced by PoPs_version().