MCGIDI_reaction.cc

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file MCGIDI_reaction.cc

/*
# <<BEGIN-copyright>>
# <<END-copyright>>
*/
#include <string.h>
#include <cmath>

#include <PoPs.h>
#include "MCGIDI.h"
#include "MCGIDI_misc.h"
#include "MCGIDI_private.h"

#if defined __cplusplus
namespace GIDI {
using namespace GIDI;
#endif

#define nParticleChanges 6

static int MCGIDI_reaction_initialize2( statusMessageReporting *smr, MCGIDI_reaction *reaction );
static int MCGIDI_reaction_particleChanges( MCGIDI_POP *projectile, MCGIDI_POP *target, MCGIDI_productsInfo *productsInfo, int n1, int *particlesChanges );
static int MCGIDI_reaction_ParseReactionTypeAndDetermineProducts( statusMessageReporting *smr, MCGIDI_POPs *pops, MCGIDI_reaction *reaction );
static int MCGIDI_reaction_ParseDetermineReactionProducts( statusMessageReporting *smr, MCGIDI_POPs *pops, MCGIDI_outputChannel *outputChannel,
    MCGIDI_productsInfo *productsInfo, MCGIDI_reaction *reaction, double *finalQ, int level );
static int MCGIDI_reaction_addReturnProduct( statusMessageReporting *smr, MCGIDI_productsInfo *productsInfo, int ID, MCGIDI_product *product, 
        MCGIDI_reaction *reaction, int transportable );
static int MCGIDI_reaction_setENDL_CSNumbers( statusMessageReporting *smr, MCGIDI_reaction *reaction );
/*
************************************************************
*/
MCGIDI_reaction *MCGIDI_reaction_new( statusMessageReporting *smr ) {

    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 );
}
/*
************************************************************
*/
int MCGIDI_reaction_initialize( statusMessageReporting *smr, MCGIDI_reaction *reaction ) {

    if( MCGIDI_reaction_initialize2( smr, reaction ) != 0 ) return( 1 );
    reaction->transportabilities = new transportabilitiesMap( );
    return( 0 );
}
/*
************************************************************
*/
static int MCGIDI_reaction_initialize2( statusMessageReporting *smr, MCGIDI_reaction *reaction ) {

    memset( reaction, 0, sizeof( MCGIDI_reaction ) );
    xDataTOMAL_initial( smr, &(reaction->attributes) );
    return( 0 );
}
/*
************************************************************
*/
MCGIDI_reaction *MCGIDI_reaction_free( statusMessageReporting *smr, MCGIDI_reaction *reaction ) {

    MCGIDI_reaction_release( smr, reaction );
    smr_freeMemory( (void **) &reaction );
    return( NULL );
}
/*
************************************************************
*/
int MCGIDI_reaction_release( statusMessageReporting *smr, MCGIDI_reaction *reaction ) {

    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 );
}
/*
************************************************************
*/
int MCGIDI_reaction_parseFromTOM( statusMessageReporting *smr, xDataTOM_element *element, MCGIDI_target_heated *target, 
        MCGIDI_POPs *pops, MCGIDI_reaction *reaction ) {

    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 );
}
/*
************************************************************
*/
static int MCGIDI_reaction_ParseReactionTypeAndDetermineProducts( statusMessageReporting *smr, MCGIDI_POPs *pops, MCGIDI_reaction *reaction ) {

    MCGIDI_outputChannel *outputChannel = &(reaction->outputChannel);
    int MT;
    int particlesChanges[nParticleChanges], numberOfChanges;
    double finalQ = 0.;

    if( MCGIDI_reaction_ParseDetermineReactionProducts( smr, pops, outputChannel, &(reaction->productsInfo), reaction, &finalQ, 0 ) != 0 ) return( 1 );
    reaction->finalQ = finalQ;
    MT = MCGIDI_reaction_getENDF_MTNumber( reaction );
    switch( MT ) {
    case 2 :
        reaction->reactionType = MCGIDI_reactionType_elastic_e;
        break;
    case 18 : case 19 : case 20 : case 21 : case 38 :
        reaction->reactionType = MCGIDI_reactionType_fission_e;
        break;
    case 102 :
        reaction->reactionType = MCGIDI_reactionType_capture_e;
        break;
    case 5 :
        reaction->reactionType = MCGIDI_reactionType_sumOfRemainingOutputChannels_e;
        break;
    default :
        numberOfChanges = MCGIDI_reaction_particleChanges( reaction->target->projectilePOP, reaction->target->targetPOP, &(reaction->productsInfo), 
            nParticleChanges, particlesChanges );

        reaction->reactionType = MCGIDI_reactionType_unknown_e;
        if( numberOfChanges == 0 ) {
            reaction->reactionType = MCGIDI_reactionType_scattering_e; }
        else {
            reaction->reactionType = MCGIDI_reactionType_nuclearIsomerTransmutation_e;
        }

/*
    Currently, these are not handled properly:
        MCGIDI_reactionType_nuclearLevelTransition_e
        MCGIDI_reactionType_atomic_e
*/
        break;
    }

    MCGIDI_reaction_setENDL_CSNumbers( smr, reaction );
    return( 0 );
}
/*
************************************************************
*/
static int MCGIDI_reaction_particleChanges( MCGIDI_POP *projectile, MCGIDI_POP *target, MCGIDI_productsInfo *productsInfo, int n1, int *particlesChanges ) {

    int projectileGlobalIndex = projectile->globalPoPsIndex, targetGlobalIndex = target->globalPoPsIndex, i1, i2 = 0;
    int gammaIndex = PoPs_particleIndex( "gamma" );

    if( projectileGlobalIndex != gammaIndex ) {
        for( i1 = 0; i1 < productsInfo->numberOfProducts; i1++ ) if( projectileGlobalIndex == productsInfo->productInfo[i1].globalPoPsIndex ) break;
        if( i1 == productsInfo->numberOfProducts ) particlesChanges[i2++] = projectileGlobalIndex;
    }

    for( i1 = 0; i1 < productsInfo->numberOfProducts; i1++ ) if( targetGlobalIndex == productsInfo->productInfo[i1].globalPoPsIndex ) break;
    if( i1 == productsInfo->numberOfProducts ) particlesChanges[i2++] = targetGlobalIndex;

    for( i1 = 0; i1 < productsInfo->numberOfProducts; i1++ ) {
        if( i2 == n1 ) break;
        if( /*(*/ projectileGlobalIndex == productsInfo->productInfo[i1].globalPoPsIndex /*)*/ ) continue;
        if( /*(*/ targetGlobalIndex == productsInfo->productInfo[i1].globalPoPsIndex /*)*/ ) continue;
        if( /*(*/ gammaIndex == productsInfo->productInfo[i1].globalPoPsIndex /*)*/ ) continue;
        particlesChanges[i2++] = productsInfo->productInfo[i1].globalPoPsIndex;
    }
    return( i2 );
}
/*
************************************************************
*/
static int MCGIDI_reaction_ParseDetermineReactionProducts( statusMessageReporting *smr, MCGIDI_POPs *pops, MCGIDI_outputChannel *outputChannel,
    MCGIDI_productsInfo *productsInfo, MCGIDI_reaction *reaction, double *finalQ, int level ) {
/*
*   This function determines all products that can be returned during sampling for this outputChannel. Note, products like 'U238_c' and
*   'U238_e3' are not returned during sampling as both are decay to the groud state (unless a meta-stable is encountered). 
*   Some examples for projectile 'n' and target 'U238' are:
*       outputChannel                       products returned during sampling.
*       'n + U238'                          n, U238
*       'n + U238 + gamma'                  n, U238, gamma
*       'n + U238_c'                        n, U238     (even if no gammas are give, return ground state of residual.
*       'n + (U238_e3 -> U238 + gamma)'     n, U238, gamma
*/
    int iProduct, nProducts = MCGIDI_outputChannel_numberOfProducts( outputChannel ), globalPoPsIndex, productIsTrackable;
    int twoBodyProductsWithData = 0;
    MCGIDI_product *product;
    MCGIDI_POP *residual;

    if( ( level == 0 ) && ( outputChannel->genre == MCGIDI_channelGenre_twoBody_e ) ) {
        for( iProduct = 0; iProduct < nProducts; iProduct++ ) {
            product = MCGIDI_outputChannel_getProductAtIndex( smr, outputChannel, iProduct );
            if( product->pop->globalPoPsIndex < 0 ) {
                twoBodyProductsWithData = -1; }
            else if( product->distribution.type == MCGIDI_distributionType_angular_e ) {
                if( twoBodyProductsWithData >= 0 ) twoBodyProductsWithData = 1;
            }
        }
    }
    if( twoBodyProductsWithData < 0 ) twoBodyProductsWithData = 0;
    *finalQ += MCGIDI_outputChannel_getQ_MeV( smr, outputChannel, 0 );
    for( iProduct = 0; iProduct < nProducts; iProduct++ ) {
        productIsTrackable = twoBodyProductsWithData;
        product = MCGIDI_outputChannel_getProductAtIndex( smr, outputChannel, iProduct );
        globalPoPsIndex = product->pop->globalPoPsIndex;
        if( ( product->distribution.type != MCGIDI_distributionType_none_e ) && ( product->distribution.type != MCGIDI_distributionType_unknown_e ) ) {
            productIsTrackable = 1;
            if( globalPoPsIndex < 0 ) {
                if( product->distribution.angular != NULL ) {
                    if( product->distribution.angular->type == MCGIDI_angularType_recoil ) productIsTrackable = 0;
                }
                if( productIsTrackable ) {
                    int len = (int) strlen( product->pop->name );

                    if( len > 2 ) {     /* Special case for continuum reactions with data for residual (e.g., n + U233 -> n + U233_c). */
                        if( ( product->pop->name[len-2] == '_' ) && ( product->pop->name[len-1] == 'c' ) ) {
                            for( residual = product->pop; residual->globalPoPsIndex < 0; residual = residual->parent ) ;
                            productIsTrackable = 1;
                            globalPoPsIndex = residual->globalPoPsIndex;
                        }
                    }
                    if( globalPoPsIndex < 0 ) {
                        smr_setReportError2( smr, smr_unknownID, 1, "product determination for '%s' cannot be determined", product->pop->name );
                        return( 1 );
                    }
                }
            }
        }
        if( productIsTrackable ) {
            if( MCGIDI_reaction_addReturnProduct( smr, productsInfo, globalPoPsIndex, product, reaction, 1 ) != 0 ) return( 1 ); }
        else {
            if( product->decayChannel.genre != MCGIDI_channelGenre_undefined_e ) {
                if( MCGIDI_reaction_ParseDetermineReactionProducts( smr, pops, &(product->decayChannel), productsInfo, reaction, finalQ, level + 1 ) != 0 ) return( 1 ); }
            else {
                *finalQ += product->pop->level_MeV;
                for( residual = product->pop; residual->globalPoPsIndex < 0; residual = residual->parent ) ;
                if( MCGIDI_reaction_addReturnProduct( smr, productsInfo, residual->globalPoPsIndex, product, reaction, 0 ) != 0 ) return( 1 );
                if( product->pop->numberOfGammaBranchs != 0 ) {
                    int gammaIndex = PoPs_particleIndex( "gamma" );
                    if( MCGIDI_reaction_addReturnProduct( smr, productsInfo, gammaIndex, NULL, reaction, 1 ) != 0 ) return( 1 );
                }
            }
        }
    }
    return( 0 );
}
/*
************************************************************
*/
static int MCGIDI_reaction_addReturnProduct( statusMessageReporting *smr, MCGIDI_productsInfo *productsInfo, int ID, MCGIDI_product *product, 
        MCGIDI_reaction *reaction, int transportable ) {

    int i1;
    enum MCGIDI_productMultiplicityType productMultiplicityType;

    MCGIDI_misc_updateTransportabilitiesMap2( reaction->transportabilities, ID, transportable );
    for( i1 = 0; i1 < productsInfo->numberOfProducts; i1++ ) {
        if( productsInfo->productInfo[i1].globalPoPsIndex == ID ) break;
    }
    if( i1 == productsInfo->numberOfProducts ) {
        if( productsInfo->numberOfProducts == productsInfo->numberOfAllocatedProducts ) {
            productsInfo->numberOfAllocatedProducts += 4;
            if( ( productsInfo->productInfo = (MCGIDI_productInfo *) smr_realloc2( smr, productsInfo->productInfo, 
                productsInfo->numberOfAllocatedProducts * sizeof( MCGIDI_productInfo ), "productsInfo->productInfo" ) ) == NULL ) return( 1 );
        }
        productsInfo->numberOfProducts++;
        productsInfo->productInfo[i1].globalPoPsIndex = ID;
        productsInfo->productInfo[i1].productMultiplicityType = MCGIDI_productMultiplicityType_unknown_e;
        productsInfo->productInfo[i1].multiplicity = 0;
        productsInfo->productInfo[i1].transportable = transportable;
    }
    if( product == NULL ) {
        productMultiplicityType = MCGIDI_productMultiplicityType_gammaBranching_e; }
    else {
        if( ( product->multiplicityVsEnergy != NULL ) || ( product->piecewiseMultiplicities != NULL ) ) {
            productMultiplicityType = MCGIDI_productMultiplicityType_energyDependent_e; }
        else {
            productsInfo->productInfo[i1].multiplicity += product->multiplicity;
            productMultiplicityType = MCGIDI_productMultiplicityType_integer_e;
        }
    }
    if( ( productsInfo->productInfo[i1].productMultiplicityType == MCGIDI_productMultiplicityType_unknown_e ) ||
        ( productsInfo->productInfo[i1].productMultiplicityType == productMultiplicityType ) ) {
        productsInfo->productInfo[i1].productMultiplicityType = productMultiplicityType; }
    else {
        productsInfo->productInfo[i1].productMultiplicityType = MCGIDI_productMultiplicityType_mixed_e;
    }
    return( 0 );
}
/*
************************************************************
*/
enum MCGIDI_reactionType MCGIDI_reaction_getReactionType( statusMessageReporting * /*smr*/, MCGIDI_reaction *reaction ) {

    return( reaction->reactionType );
}
/*
************************************************************
*/
MCGIDI_target_heated *MCGIDI_reaction_getTargetHeated( statusMessageReporting * /*smr*/, MCGIDI_reaction *reaction ) {

    return( reaction->target );
}
/*
************************************************************
*/
double MCGIDI_reaction_getProjectileMass_MeV( statusMessageReporting *smr, MCGIDI_reaction *reaction ) {

    return( MCGIDI_target_heated_getProjectileMass_MeV( smr, reaction->target ) );
}
/*
************************************************************
*/
double MCGIDI_reaction_getTargetMass_MeV( statusMessageReporting *smr, MCGIDI_reaction *reaction ) {

    return( MCGIDI_target_heated_getTargetMass_MeV( smr, reaction->target ) );
}
/*
************************************************************
*/
int MCGIDI_reaction_getDomain( statusMessageReporting * /*smr*/, MCGIDI_reaction *reaction, double *EMin, double *EMax ) {
/*
*   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 );
}
/*
************************************************************
*/
int MCGIDI_reaction_fixDomains( statusMessageReporting * /*smr*/, MCGIDI_reaction *reaction, double EMin, double EMax, nfu_status *status ) {

    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 );
}
/*
************************************************************
*/
double MCGIDI_reaction_getCrossSectionAtE( statusMessageReporting *smr, MCGIDI_reaction *reaction, MCGIDI_quantitiesLookupModes &modes,
        bool sampling ) {

    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 );
}
/*
************************************************************
*/
double MCGIDI_reaction_getFinalQ( statusMessageReporting * /*smr*/, MCGIDI_reaction *reaction, MCGIDI_quantitiesLookupModes &/*modes*/ ) {

    return( reaction->finalQ );
}
/*
************************************************************
*/
int MCGIDI_reaction_getENDF_MTNumber( MCGIDI_reaction *reaction ) {

    return( reaction->ENDF_MT );
}
/*
************************************************************
*/
int MCGIDI_reaction_getENDL_CSNumbers( MCGIDI_reaction *reaction, int *S ) {

    if( S != NULL ) *S = reaction->ENDL_S;
    return( reaction->ENDL_C );
}
/*
************************************************************
*/
static int MCGIDI_reaction_setENDL_CSNumbers( statusMessageReporting * /*smr*/, MCGIDI_reaction *reaction ) {

    int MT = MCGIDI_reaction_getENDF_MTNumber( reaction );
    int MT1_50ToC[] = { 1,   10,  -3,   -4,   -5,    0,    0,    0,    0,  -10,
                       32,    0,   0,    0,    0,   12,   13,   15,   15,   15,
                       15,   26,  36,   33,  -25,    0,  -27,   20,   27,  -30,
                        0,   22,  24,   25,  -35,  -36,   14,   15,    0,    0,
                       29,   16,   0,   17,   34,    0,    0,    0,    0 };
    int MT100_200ToC[] = { -101,   46,   40,   41,   42,   44,   45,   37, -109,    0,
                             18,   48, -113, -114,   19,   39,   47,    0,    0,    0,
                              0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
                              0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
                              0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
                              0, -152, -153, -154,   43, -156, -157,   23,   31, -160,
                           -161, -162, -163, -164, -165, -166, -167, -168, -169, -170,
                           -171, -172, -173, -174, -175, -176, -177, -178, -179, -180,
                           -181, -182, -183, -184, -185, -186, -187, -188,   28, -190,
                           -191, -192,   38, -194, -195, -196, -197, -198, -199, -200 };

    reaction->ENDL_C = 0;
    reaction->ENDL_S = 0;
    if( MT <= 0 ) return( 1 );
    if( MT > 891 ) return( 1 );
    if( MT < 50 ) {
        reaction->ENDL_C = MT1_50ToC[MT - 1]; }
    else if( MT <= 91 ) {
        reaction->ENDL_C = 11;
        if( MT != 91 ) reaction->ENDL_S = 1; }
    else if( ( MT > 100 ) && ( MT <= 200 ) ) {
        reaction->ENDL_C = MT100_200ToC[MT - 101]; }
    else if( ( MT == 452 ) || ( MT == 455 ) || ( MT == 456 ) || ( MT == 458 ) ) {
        reaction->ENDL_C = 15;
        if( MT == 455 ) reaction->ENDL_S = 7; }
    else if( MT >= 600 ) {
        if( MT < 650 ) {
            reaction->ENDL_C = 40;
            if( MT != 649 ) reaction->ENDL_S = 1; }
        else if( MT < 700 ) {
            reaction->ENDL_C = 41;
            if( MT != 699 ) reaction->ENDL_S = 1; }
        else if( MT < 750 ) {
            reaction->ENDL_C = 42;
            if( MT != 749 ) reaction->ENDL_S = 1; }
        else if( MT < 800 ) {
            reaction->ENDL_C = 44;
            if( MT != 799 ) reaction->ENDL_S = 1; }
        else if( MT < 850 ) {
            reaction->ENDL_C = 45;
            if( MT != 849 ) reaction->ENDL_S = 1; }
        else if( ( MT >= 875 ) && ( MT <= 891 ) ) {
            reaction->ENDL_C = 12;
            if( MT != 891 ) reaction->ENDL_S = 1;
        }
    }
    return( 0 );
}
/*
************************************************************
*/
MCGIDI_productsInfo *MCGIDI_reaction_getProductsInfo( MCGIDI_reaction *reaction ) {

    return( &(reaction->productsInfo) );
}
/*
************************************************************
*/
int MCGIDI_reaction_recast( statusMessageReporting *smr, MCGIDI_reaction *reaction, GIDI_settings & /*settings*/, 
        GIDI_settings_particle const *projectileSettings, double temperature_MeV, ptwXPoints *totalGroupedCrossSection ) {

    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 );
}

/*
*********************** productsInfo ***********************
*/
/*
************************************************************
*/
int MCGIDI_productsInfo_getNumberOfUniqueProducts( MCGIDI_productsInfo *productsInfo ) {

    return( productsInfo->numberOfProducts );
}
/*
************************************************************
*/
int MCGIDI_productsInfo_getPoPsIndexAtIndex( MCGIDI_productsInfo *productsInfo, int index ) {

    if( ( index < 0 ) || ( index >= productsInfo->numberOfProducts ) ) return( -1 );
    return( productsInfo->productInfo[index].globalPoPsIndex );
}
/*
************************************************************
*/
enum MCGIDI_productMultiplicityType MCGIDI_productsInfo_getMultiplicityTypeAtIndex( MCGIDI_productsInfo *productsInfo, int index ) {

    if( ( index < 0 ) || ( index >= productsInfo->numberOfProducts ) ) return( MCGIDI_productMultiplicityType_invalid_e );
    return( productsInfo->productInfo[index].productMultiplicityType );
}
/*
************************************************************
*/
int MCGIDI_productsInfo_getIntegerMultiplicityAtIndex( MCGIDI_productsInfo *productsInfo, int index ) {

    if( ( index < 0 ) || ( index >= productsInfo->numberOfProducts ) ) return( -1 );
    return( productsInfo->productInfo[index].multiplicity );
}
/*
************************************************************
*/
int MCGIDI_productsInfo_getTransportableAtIndex( MCGIDI_productsInfo *productsInfo, int index ) {

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

#if defined __cplusplus
}
#endif