In This Package:

NucUtil.cc File Reference

#include "GenDecay/NucUtil.h"
#include "GenDecay/NucState.h"
#include "GenDecay/NucDecay.h"
#include "GenDecay/Radiation.h"
#include "CLHEP/Units/SystemOfUnits.h"
#include <sstream>
#include <more/phys/ens.h>

Include dependency graph for NucUtil.cc:

Go to the source code of this file.

Typedefs
typedef map< const phys::nucleus, ens::nucleus >	NucNucMap_t
typedef map< phys::nucleus, vector< NucState * > >	Nuc2state_t
typedef vector< NucState * >(*)	GetDaughterFunc (NucState *)
Functions
double	GenDecay::more_to_clhep_time (double more_time)
double	GenDecay::more_to_clhep_energy (double more_energy)
template<typename T>
bool	operator== (confidence_interval< T > x, confidence_interval< T > y)
template<typename T>
bool	operator!= (confidence_interval< T > x, confidence_interval< T > y)
bool	GenDecay::get_nucleus (const more::phys::nucleus &pn, more::phys::ens::nucleus &en)
	Fill out a ens::nucleus given the phys::nucleus, return true if no error.
NucState *	GenDecay::get_state (const phys::nucleus &n, ens::confiv_t hl, ens::confiv_t rel, int ref)
static void	normalize_branching_fractions (NucState &state)
const NucDecayMap_t &	GenDecay::get_decays ()
	Get all decays that have been chained so far.
NucDecay *	get_decay (NucState *mo, NucState *da, const string &typ, double q=0, double f=0)
template<typename ItType>
int	count (ItType beg, ItType end)
void	dump_radiation (const ens::rec_radiation &rad)
void	dump_level (const ens::rec_level &lev)
double	rad_mass (const ens::rec_radiation &rad)
double	rad_fraction (const ens::rec_radiation &rad, const ens::rec_norm *norm=0, const string &idstr="")
void	GenDecay::dump_dataset (const ens::dataset &ds)
ens::rec_norm const *	get_norm (const ens::dataset &ds)
ens::rec_parent const *	from_parent (const ens::dataset &ds, NucState &parent)
const ens::dataset &	get_decay_dataset (NucState &parent, ens::nucleus &daughter, string idstr, ens::rec_parent const *&rparent, ens::rec_norm const *&rnorm)
bool	dk_dataset_ok (const ens::dataset &ds)
const ens::dataset &	get_adopted_levels (ens::nucleus &nuc)
bool	al_dataset_ok (const ens::dataset &ds)
const ens::rec_level *	get_level (const ens::dataset &ds, ens::confiv_t erel, int eref)
const ens::rec_level *	get_closest_level (const ens::dataset &ds, ens::confiv_t erel, int eref)
bool	is_only_gamma (const ens::rec_level &lev)
const ens::rec_radiation *	get_non_gamma (const ens::rec_level &lev)
int	count_gammas (const ens::rec_level &lev)
vector< NucState * >	get_daughters (NucState *mother, phys::nucleus daughter, string idstr)
vector< NucState * >	get_alpha_daughters (NucState *mother)
vector< NucState * >	get_betami_daughters (NucState *mother)
vector< NucState * >	get_betapl_daughters (NucState *mother)
vector< NucState * >	get_ec_daughters (NucState *mother)
vector< NucState * >	get_it_daughters (NucState *mother)
vector< NucState * >	get_gamma_daughters (NucState *mother)
void	GenDecay::chain (NucState *mother, int depth=-1, more::phys::nucleus stop_nuc=more::phys::nucleus())
	Form decay chain starting from given mother state.
NucState *	GenDecay::get_ground (std::string name)
	Get a ground state by name (eg "U-238").
NucState *	GenDecay::get_ground (phys::nucleus nucl)
const Radiation *	GenDecay::decay_radiation (const NucDecay &dk)
	Make a radiation object for given decay.
Variables
Nuc2state_t	gsNuc2state
static NucDecayMap_t	gsNucDecays
GetDaughterFunc	get_xxx_daughters []
const char *	decay_names []

---

Typedef Documentation

typedef map<const phys::nucleus, ens::nucleus> NucNucMap_t

Definition at line 39 of file NucUtil.cc.

typedef map<phys::nucleus, vector<NucState*> > Nuc2state_t

Definition at line 65 of file NucUtil.cc.

typedef vector<NucState*>(*) GetDaughterFunc(NucState *)

Definition at line 876 of file NucUtil.cc.

---

Function Documentation

template<typename T>

bool operator==	(	confidence_interval< T >	x,
		confidence_interval< T >	y
	)

Definition at line 26 of file NucUtil.cc.

{
    const double epsilon = 20*SI::eV;
    return (fabs(x.cent()-y.cent()) < epsilon);
    //&& (fabs(x.min()-y.min()) < epsilon)
    //&& (fabs(x.max()-y.max()) < epsilon);
}

template<typename T>

bool operator!=	(	confidence_interval< T >	x,
		confidence_interval< T >	y
	)

Definition at line 34 of file NucUtil.cc.

{
    return !(x==y);
}

static void normalize_branching_fractions

(

NucState &

state

)

[static]

Definition at line 113 of file NucUtil.cc.

{
    vector<NucDecay*>& decays = state.decays();

    // special case, stable or
    if (!decays.size()) return;

    // single decay branch
    if (decays.size() == 1) { 
        decays[0]->fraction = 1.0;
        return;
    }

    // Some decays have unknown (0) branching fraction, drop them.
    vector<NucDecay*> tmp;
    for (size_t dind=0; dind < decays.size(); ++dind) {
        if (decays[dind]->fraction > 0.0) {
            tmp.push_back(decays[dind]);
        }
    }
    decays = tmp;
    if (!decays.size()) return;

    if (decays.size() == 1) { 
        decays[0]->fraction = 1.0;
        return;
    }

    double mag = 0;
    for (size_t dind=0; dind < decays.size(); ++dind) {
        mag += decays[dind]->fraction;
    }

    if (mag == 0.0) {
        cerr << "Zero total decay fraction for: " << state 
             << " with " << state.ndecays() << " decays"
             << endl;
        return;
    }
    for (size_t dind=0; dind < decays.size(); ++dind) {
        decays[dind]->fraction /= mag;
    }
    //cerr << "Normalized daughters of " << state << " by " << mag << endl;
}

NucDecay * get_decay	(	NucState *	mo,
		NucState *	da,
		const string &	typ,
		double	q = 0,
		double	f = 0
	)

Definition at line 163 of file NucUtil.cc.

{
    pair<NucState*,NucState*> moda(mo,da);

    vector<NucDecay*> vec;

    NucDecayMap_t::iterator it = gsNucDecays.find(moda);
    if (it != gsNucDecays.end()) {
        vec = it->second;
    }

    for (size_t ind=0; ind<vec.size(); ++ind) {
        NucDecay* nd = vec[ind];
        if (nd->type == typ) return nd;
    }

    NucDecay* nd = new NucDecay(mo,da,typ,q,f);
    vec.push_back(nd);
    gsNucDecays[moda] = vec;
    return nd;
}

template<typename ItType>

int count	(	ItType	beg,
		ItType	end
	)

Definition at line 186 of file NucUtil.cc.

{
    int c = 0;
    for(; beg!=end; ++beg) ++c;
    return c;
}

void dump_radiation

(

const ens::rec_radiation &

rad

)

Definition at line 193 of file NucUtil.cc.

{
    cerr << "\t\t\t";

    if (rad.is_alpha()) {
        ens::rec_alpha const* alpha = rad.to_alpha();
        cerr << " alpha:"
             << " energy=" << rad.E_minus_E_ref() / SI::keV
             << " ref=" << rad.i_E_ref()
             << " status=" << rad.status()
             << " I_alpha=" << alpha->I_alpha()
             << " hindrance=" << alpha->hindrance_factor();
    }
    else if (rad.is_gamma()) {
        ens::rec_gamma const* gamma = rad.to_gamma();
        cerr << " gamma:"
             << " energy=" << rad.E_minus_E_ref() / SI::keV
             << " ref=" << rad.i_E_ref()
             << " status=" << rad.status()
             << " r_mix=" << gamma->r_mix()
             << " I_gamma_rel=" << gamma->I_gamma_rel()
             << " alpha_tot()=" << gamma->alpha_tot()
             << " I_trans_rel=" << gamma->I_trans_rel();
    }
    else if (rad.is_beta_mi()) {
        ens::rec_beta_mi const* beta_mi = rad.to_beta_mi();
        cerr << " beta-:"
             << " energy=" << rad.E_minus_E_ref() / SI::keV
             << " ref=" << rad.i_E_ref()
             << " status=" << rad.status()
             << " I_beta_mi_rel=" << beta_mi->I_beta_mi_rel()
             << " log_ft=" << beta_mi->log_ft();
    }
    else if (rad.is_beta_pl()) {
        ens::rec_beta_pl const* beta_pl = rad.to_beta_pl();
        cerr << " beta+:"
             << " energy=" << rad.E_minus_E_ref() / SI::keV
             << " ref=" << rad.i_E_ref()
             << " status=" << rad.status()
             << " I_tot_rel=" << beta_pl->I_tot_rel()
             << " I_beta_pl_rel=" << beta_pl->I_beta_pl_rel()
             << " I_EC_rel=" << beta_pl->I_EC_rel()
             << " log_ft=" << beta_pl->log_ft();
    }
    else {
        cerr << "unknown radiation:";
        rad.dump(cerr);
    }
    cerr << endl;

}

void dump_level

(

const ens::rec_level &

lev

)

Definition at line 245 of file NucUtil.cc.

{
    cerr << "\t\tenergy level = " << lev.E_minus_E_ref() / SI::keV
         << " ref=" << lev.i_E_ref()
         << " hl=" << lev.T_half()
         << " radiations:\n";
    for (ens::rec_level::radiation_iterator it_rad = lev.radiation_begin();
         it_rad != lev.radiation_end(); ++it_rad) {
        dump_radiation(*it_rad);
    }
}

double rad_mass

(

const ens::rec_radiation &

rad

)

Definition at line 257 of file NucUtil.cc.

{
    if (rad.is_gamma()) return 0.0;
    if (rad.is_beta_mi() || rad.is_beta_pl()) return SI::E_e;
    if (rad.is_alpha()) return 2*(SI::E_p + SI::E_n);
    cerr << "Unknown radiation:\n";
    rad.dump(cerr);
    return 0.0;
}

double rad_fraction	(	const ens::rec_radiation &	rad,
		const ens::rec_norm *	norm = 0,
		const string &	idstr = ""
	)

Definition at line 269 of file NucUtil.cc.

{
    double fraction = 0;

    if (rad.is_alpha()) {
        ens::rec_alpha const* alpha = rad.to_alpha();
        if (alpha->I_alpha().is_known()) {
            fraction = alpha->I_alpha().cent();
        }
        //cerr << " I_alpha = " << fraction<< endl;
    }
    if (rad.is_gamma()) {
        ens::rec_gamma const* gamma = rad.to_gamma();
        if (gamma->I_gamma_rel().is_known()) {
            fraction = gamma->I_gamma_rel().cent();
            //cerr << " I_gamma_rel = " << fraction<< endl;
            if (norm && norm->mult_gamma_rel_branch().is_known()) {
                fraction *= norm->mult_gamma_rel_branch().cent();
                //cerr << "\twith gamma_rel_branch: " << fraction << endl;
            }
        }
        else if (gamma->I_trans_rel().is_known()) {
            fraction = gamma->I_trans_rel().cent();
            //cerr << " I_trans_rel = " << fraction<< endl;
            if (norm && norm->mult_trans_rel_branch().is_known()) {
                fraction *= norm->mult_trans_rel_branch().cent();
                //cerr << "\twith mult_trans_rel_branch: " << fraction << endl;
            }
        }

    }
    if (rad.is_beta_mi()) {
        ens::rec_beta_mi const* beta_mi = rad.to_beta_mi();
        if (beta_mi->I_beta_mi_rel().is_known()) {
            fraction = beta_mi->I_beta_mi_rel().cent();
        }
        if (norm && norm->mult_beta_rel_branch().is_known()) {
            fraction *= norm->mult_beta_rel_branch().cent();
        }
    }
    if (rad.is_beta_pl()) {
        ens::rec_beta_pl const* beta_pl = rad.to_beta_pl();
        if (idstr == "EC DECAY") {
            if (beta_pl->I_EC_rel().is_known()) {
                fraction = beta_pl->I_EC_rel().cent();
            }
        }
        else {
            if (beta_pl->I_beta_pl_rel().is_known()) {
                fraction = beta_pl->I_beta_pl_rel().cent();
            }
        }
        if (norm && norm->mult_beta_rel_branch().is_known()) {
            fraction *= norm->mult_beta_rel_branch().cent();
        }
    }

    if (norm && norm->mult_branch().is_known()) {
        if (norm->mult_branch().is_known()) {
            fraction *= norm->mult_branch().cent();
        }
    }

    return fraction;
}

ens::rec_norm const* get_norm

(

const ens::dataset &

ds

)

Definition at line 376 of file NucUtil.cc.

{
    for (ens::dataset::decay_info_iterator 
             it_di = ds.decay_info_begin();
         it_di != ds.decay_info_end(); ++it_di) {
        ens::rec_norm const* n = it_di->norm();
        if (n) return n;
    }
    return 0;
}

ens::rec_parent const* from_parent	(	const ens::dataset &	ds,
		NucState &	parent
	)

Definition at line 387 of file NucUtil.cc.

{
    //cerr << "Checking parentage in decay_info for: " << parent << endl;
    for (ens::dataset::decay_info_iterator 
             it_di = ds.decay_info_begin();
         it_di != ds.decay_info_end(); ++it_di) {
            
        ens::rec_parent const* candidate = it_di->parent();

        if (!candidate) {
            //cerr << "from_parent: no decay_info parent\n";
            continue;
        }
        if (candidate->nucl() != parent.nuc()) {
            //cerr << "from_parent: decay_info parent = " << candidate->nucl()
            //     << " != parent = " << parent.nuc() << endl;
            continue;
        }
        if (candidate->E_minus_E_ref() != parent.erel()) {
            //cerr << "from_parent: energies differ: " << candidate->E_minus_E_ref() 
            //     << " != " << parent.erel() << endl;
            continue;
        }
        if (candidate->i_E_ref() != parent.eref()) {
            //cerr << "from_parent: eref differ: " << candidate->i_E_ref()
            //     << " != " << parent.eref() << endl;
            continue;
        }
            
        return candidate;
    }
    return 0;
}

const ens::dataset& get_decay_dataset	(	NucState &	parent,
		ens::nucleus &	daughter,
		string	idstr,
		ens::rec_parent const *&	rparent,
		ens::rec_norm const *&	rnorm
	)

Definition at line 421 of file NucUtil.cc.

{
    static ens::dataset bogus;
    rparent = 0;

    //cerr << "Checking for " << parent << " -> " << daughter << " via \"" << idstr << "\"\n";

    for (ens::nucleus::dataset_iterator it_ds
             = daughter.dataset_begin ();
         it_ds != daughter.dataset_end (); ++it_ds) {
        std::string idn = it_ds->ident()->dataset_id_string();

        //cerr << "idn: \"" << idn << "\" idstr: \"" << idstr << "\"\n";
        
        if (idn.find(idstr) == std::string::npos) {
            //cerr << "get_decay_dataset: idstr \"" << idstr << "\" not in \"" << idn << "\"\n";
            continue;
        }
        ens::rec_norm const* n = get_norm(*it_ds);
        if (n) rnorm = n;
        ens::rec_parent const* p = from_parent(*it_ds,parent);
        if (! p) continue;
        rparent = p;
        return *it_ds;
    }
    //cerr << "Failed to get decay dataset for " << parent << " -> " << daughter
    //     << " for \"" << idstr  << "\"\n";
    return bogus;
}

bool dk_dataset_ok

(

const ens::dataset &

ds

)

Definition at line 454 of file NucUtil.cc.

{
    return ds.decay_info_begin() != ds.decay_info_end();
}

const ens::dataset& get_adopted_levels

(

ens::nucleus &

nuc

)

Definition at line 459 of file NucUtil.cc.

{
    static ens::dataset bogus;
    ens::dataset const* ds = adopted_levels_dataset(nuc);
    if (ds) return *ds;
    return bogus;
}

bool al_dataset_ok

(

const ens::dataset &

ds

)

Definition at line 467 of file NucUtil.cc.

{
    return ds.level_begin() != ds.level_end();
}

const ens::rec_level* get_level	(	const ens::dataset &	ds,
		ens::confiv_t	erel,
		int	eref
	)

Definition at line 477 of file NucUtil.cc.

{
    const double epsilon = 1*SI::keV;
    double min_dE = -1;
    const ens::rec_level* the_level = 0;

    ens::dataset::level_iterator it, done = ds.level_end();
    for (it = ds.level_begin(); it != done; ++it) {

        if (it->i_E_ref() != eref) continue;

        bool candidate = false;

        // level energy must be w/in errors of target
        double x = it->E_minus_E_ref().cent();
        if (erel.min() < x && x < erel.max()) candidate = true;

        // And must be w/in hard epsilon
        double dE = fabs(x-erel.cent());
        if (dE < epsilon) candidate = true;

        if (!candidate) continue;

        // Take closest, not first
        if (min_dE < 0 || dE < min_dE) {
            min_dE = dE;
            the_level = &(*it);
        }
    }

    if (the_level) return the_level;

    // See if daughter level exists with zero reference energy
    if (eref > 0) return get_level(ds,erel,0);
    return 0;
}

const ens::rec_level* get_closest_level	(	const ens::dataset &	ds,
		ens::confiv_t	erel,
		int	eref
	)

Definition at line 514 of file NucUtil.cc.

{
    double min_dE = -1;
    const ens::rec_level* the_level = 0;
    ens::dataset::level_iterator it, done = ds.level_end();
    for (it = ds.level_begin(); it != done; ++it) {
        if (it->i_E_ref() != eref) continue;

        double x = it->E_minus_E_ref().cent();
        double dE = fabs(x-erel.cent());
        if (min_dE < 0 || dE < min_dE) {
            min_dE = dE;
            the_level = &*it;
        }
    }

    const ens::rec_level* the_other_level = 0;
    if (eref > 0) {
        the_other_level = get_closest_level(ds,erel,0);
    }

    if (the_level && the_other_level) {
        double dE1 = fabs(the_level->E_minus_E_ref().cent() - erel.cent());
        double dE2 = fabs(the_other_level->E_minus_E_ref().cent() - erel.cent());
        if (dE1 < dE2) return the_level;
        return the_other_level;
    }
    if (!(the_level || the_other_level)) return 0;
    if (the_level) return the_level;
    return the_other_level;
}

bool is_only_gamma

(

const ens::rec_level &

lev

)

Definition at line 546 of file NucUtil.cc.

{
    int non_gamma = 0;

    for (ens::rec_level::radiation_iterator it_rad = lev.radiation_begin();
         it_rad != lev.radiation_end(); ++it_rad) {
        if (! it_rad->is_gamma()) ++non_gamma;
    }
    return non_gamma == 0;
}

const ens::rec_radiation* get_non_gamma

(

const ens::rec_level &

lev

)

Definition at line 557 of file NucUtil.cc.

{
    for (ens::rec_level::radiation_iterator it_rad = lev.radiation_begin();
         it_rad != lev.radiation_end(); ++it_rad) {
        if (! it_rad->is_gamma()) return &*it_rad;
    }
    return 0;    
}

int count_gammas

(

const ens::rec_level &

lev

)

Definition at line 566 of file NucUtil.cc.

{
    int ngammas = 0;
    for (ens::rec_level::radiation_iterator it_rad = lev.radiation_begin();
         it_rad != lev.radiation_end(); ++it_rad) {
        if (it_rad->is_gamma()) {
            ++ngammas;
        }
    }
    return ngammas;
}

vector<NucState*> get_daughters	(	NucState *	mother,
		phys::nucleus	daughter,
		string	idstr
	)

Definition at line 580 of file NucUtil.cc.

{
    vector<NucState*> ret;
    ens::nucleus candidate;
    if (!get_nucleus(daughter,candidate)) {
        cerr << "Failed to get nucleus for " << daughter << endl;
        return ret;
    }

    ens::rec_parent const* parent=0;
    ens::rec_norm const* norm=0;
    const ens::dataset& dk = get_decay_dataset(*mother,candidate,idstr,parent,norm);
    if (!dk_dataset_ok(dk)) {
        // can happen if there is no way to get there from here
        //cerr << "Failed to get okay data set for mother "
        //     << *mother << " and daughter " << candidate << endl;
        return ret;
    }

    const ens::dataset& al = get_adopted_levels(candidate);
    if (!al_dataset_ok(al)) {
        cerr << "Failed to get adopted levels for " << candidate << endl;
        return ret;
    }

    // cerr << "Searching for " << idstr <<" for "<<*mother<<":\n";
    //dump_dataset(dk);

    for (ens::dataset::level_iterator it_lev = dk.level_begin();
         it_lev != dk.level_end(); ++it_lev) {
        const ens::rec_level& dk_lev = *it_lev;

        //dump_level(dk_lev);
        // The decay info data set has levels that are not directly
        // reachable by alpha/beta but are entered through gamma
        // decay, skip them for now.
        const ens::rec_radiation* rad = get_non_gamma(dk_lev);
        if (!rad) {
            //cerr << "No non-gammas for level\n";
            continue;
        }

        // try to find energy
        double energy = 0;
        if (rad->E_minus_E_ref().is_known()) {
            energy = rad->E_minus_E_ref().cent();
        }
        else {
            energy = parent->QP().cent()         // available ground state energy
                + parent->E_minus_E_ref().cent() // any excitation
                - dk_lev.E_minus_E_ref().cent(); // less our energy
            if (idstr == "A DECAY") {
                int A = mother->nuc().n_part();
                double alpha_mod = (A-4.0)/A;
                energy *= alpha_mod;
                cerr << "Warning: alpha decay energy not found, calculate from Qvalue*"
                     << alpha_mod << " = " << energy << endl;
            }
        }
        if (energy <= 0.0) {
            cerr << "Got bogus energy for this decay, skipping:\n";
            cerr << "Radiation:\n";
            rad->dump(cerr);
            cerr << "Level:\n";
            dk_lev.dump(cerr);
            continue;
        }

        // try to find halflife
        ens::confiv_t halflife;
        if (dk_lev.T_half().is_known()) halflife = dk_lev.T_half();
        else {
            const ens::rec_level *al_lev = get_level(al,dk_lev.E_minus_E_ref(),
                                                     dk_lev.i_E_ref());
            if (!al_lev) {
                cerr << "Failed to get al_lev for dk_level = ";
                dump_level(dk_lev);
                cerr << "\tfrom adopted level dataset:\n";
                dump_dataset(al);
            }
            else if (al_lev->T_half().is_known()) 
                halflife = al_lev->T_half();
        }
        
        // ENSDF conflats electron capture and positron emission.
        // Datasets can be found with either "EC DECAY" or "B+ DECAY"
        // labels and in both cases the radiation line has branching
        // fractions for both decays.  This is related to #339.
        vector<string> idstrs;
        if (idstr == "EC DECAY" || idstr == "B+ DECAY") {
            idstrs.push_back("EC DECAY");
            idstrs.push_back("B+ DECAY");
        }
        else {
            idstrs.push_back(idstr);
        }

        for (size_t ind=0; ind < idstrs.size(); ++ind) {
            double fraction = rad_fraction(*rad,norm,idstrs[ind]);
        
            //dump_level(dk_lev);
            NucState* child = get_state(daughter,halflife,
                                        dk_lev.E_minus_E_ref(),
                                        dk_lev.i_E_ref());
            NucDecay* decay = get_decay(mother,child,idstrs[ind],energy,fraction);
            //cerr << "Decay by " << idstrs[ind] << ": "
            //     << *mother << " -> " << *child << " by " << *decay << endl;
            decay = 0;
        
            ret.push_back(child);
        }
    }

    //dump_dataset(dk);
    //dump_dataset(al);

    return ret;
}

vector<NucState*> get_alpha_daughters

(

NucState *

mother

)

Definition at line 699 of file NucUtil.cc.

{
    phys::nucleus daughter(mother->nuc().n_neut()-2,mother->nuc().n_prot()-2);
    return get_daughters(mother, daughter,"A DECAY");
}

vector<NucState*> get_betami_daughters

(

NucState *

mother

)

Definition at line 704 of file NucUtil.cc.

{
    phys::nucleus daughter(mother->nuc().n_neut()-1,mother->nuc().n_prot()+1);
    return get_daughters(mother, daughter,"B- DECAY");
}

vector<NucState*> get_betapl_daughters

(

NucState *

mother

)

Definition at line 709 of file NucUtil.cc.

{
    phys::nucleus daughter(mother->nuc().n_neut()+1,mother->nuc().n_prot()-1);
    return get_daughters(mother, daughter,"B+ DECAY");
}

vector<NucState*> get_ec_daughters

(

NucState *

mother

)

Definition at line 714 of file NucUtil.cc.

{
    phys::nucleus daughter(mother->nuc().n_neut()+1,mother->nuc().n_prot()-1);
    return get_daughters(mother, daughter,"EC DECAY");
}

vector<NucState*> get_it_daughters

(

NucState *

mother

)

Definition at line 719 of file NucUtil.cc.

{
    phys::nucleus daughter(mother->nuc());

    vector<NucState*> ret;
    ens::nucleus candidate;
    
    if (!get_nucleus(daughter,candidate)) return ret;

    string idstr = "IT DECAY";

    ens::rec_parent const* parent=0;
    ens::rec_norm const* norm=0;
    const ens::dataset& dk = get_decay_dataset(*mother,candidate,idstr,parent,norm);
    if (!dk_dataset_ok(dk)) return ret;

    const ens::dataset& al = get_adopted_levels(candidate);
    if (!al_dataset_ok(al)) return ret;


    const ens::rec_level *lev = get_level(dk,mother->erel(),mother->eref());
    if (!lev) {
        cerr << "Failed to get decay level for " << *mother << endl;
        return ret;
    }

    int ngamma = count_gammas(*lev);
    if (ngamma != 1) {
        cerr << "Too many gammas for an IT DECAY level, got: " << ngamma
             << " from decay of " << *mother << " -> " << candidate
             << endl;
        dump_level(*lev);
        return ret;
    }

    //cerr << "Found " << idstr <<" for "<<*mother<<":\n";

    const ens::rec_level *child_lev = get_level(al,mother->erel(),0);
    if (!child_lev) {
        cerr << "Failed to get child of IT DECAY of " << *mother << endl;
        dump_dataset(al);
        return ret;
    }

    const ens::rec_radiation& rad = *(lev->radiation_begin());

    // try to find energy
    double energy = 0;
    if (rad.E_minus_E_ref().is_known()) {
        energy = rad.E_minus_E_ref().cent();
    }

    // try to find halflife
    ens::confiv_t halflife;
    if (lev->T_half().is_known()) halflife = lev->T_half();
    else {
        const ens::rec_level *al_lev = get_level(al,lev->E_minus_E_ref(),
                                                 lev->i_E_ref());
        if (!al_lev) {
            cerr << "Failed to get al_lev for " 
                 << lev->E_minus_E_ref() / SI::keV
                 << " w.r.t. " << lev->i_E_ref() << endl;
        }
        else if (al_lev->T_half().is_known()) 
            halflife = al_lev->T_half();
    }
        
    double fraction = norm->mult_branch().cent();

    NucState* child = get_state(daughter,halflife,
                                child_lev->E_minus_E_ref(),
                                child_lev->i_E_ref());
    NucDecay* decay = get_decay(mother,child,idstr,energy,fraction);
    //cerr << "Decay: " << *mother << " -> " << *child << " by " << *decay << endl;
    decay = 0;                  // quell compiler warning

    ret.push_back(child);
    return ret;
}

vector<NucState*> get_gamma_daughters

(

NucState *

mother

)

Definition at line 799 of file NucUtil.cc.

{
    phys::nucleus daughter(mother->nuc());

    vector<NucState*> ret;
    ens::nucleus candidate;
    if (!get_nucleus(daughter,candidate)) return ret;

    const ens::dataset& al = get_adopted_levels(candidate);
    if (!al_dataset_ok(al)) return ret;

    const ens::rec_level* lev = get_level(al,mother->erel(),mother->eref());
    if (!lev) {
        cerr << "Failed to get level for " << *mother << endl;
        return ret;
    }

    if (0 == count_gammas(*lev) and mother->erel().cent() > 0) {
        // Sometimes there are no gammas given in the dataset, what
        // can I say?

        //cerr << "No gammas in level " << *mother << endl;
        //dump_level(*lev);
        return ret;
    }

    //cerr << "GAMMA decay from " << *mother << endl;

    for (ens::rec_level::radiation_iterator it_rad = lev->radiation_begin();
         it_rad != lev->radiation_end(); ++it_rad) {

        if (! it_rad->is_gamma()) continue;

        ens::confiv_t halflife;

        double energy = it_rad->E_minus_E_ref().cent();
        double fraction = rad_fraction(*it_rad);

        // fixme, this is bogus if i_E_ref is non-zero
        ens::confiv_t erel = mother->erel() - it_rad->E_minus_E_ref();
        if (erel.cent() < 0) erel = ens::confiv_t(0.0,0);

        // First look in same X-excited state
        const ens::rec_level* daughter_lev = get_level(al,erel,mother->eref());
        if (!daughter_lev) {
            daughter_lev = get_closest_level(al,erel,mother->eref());
            double de = daughter_lev->E_minus_E_ref().cent();
            double diff = fabs(de-erel.cent())/erel.cent();

            if (daughter_lev) {
                cerr << "Warning inexact match for daughter of "<<*mother<<" for gamma of "
                     << it_rad->E_minus_E_ref()/SI::keV
                     << "\twanted:"<<erel/SI::keV<<" got:"
                     << de/SI::keV<<" ["<<daughter_lev->i_E_ref()<<"] diff="<<diff*100<<"%\n";
            }
        }
        if (!daughter_lev) {
            cerr << "Failed to get daughter energy ("<<erel/SI::keV<<") level for gamma from "<<*mother<<":\n";
            dump_radiation(*it_rad);
            dump_dataset(al);
            continue;
        }
        halflife = daughter_lev->T_half();

        NucState* child = get_state(mother->nuc(),halflife,
                                    daughter_lev->E_minus_E_ref(),
                                    daughter_lev->i_E_ref());
        NucDecay* decay = get_decay(mother,child,"Gamma",energy,fraction);
        //cerr << "Decay: " << *mother << " -> " << *child << " by " << *decay << endl;
        decay = 0;  // quell compiler warning

        ret.push_back(child);

    }
    return ret;
}

---

Variable Documentation

Nuc2state_t gsNuc2state

Definition at line 66 of file NucUtil.cc.

NucDecayMap_t gsNucDecays [static]

Definition at line 159 of file NucUtil.cc.

GetDaughterFunc get_xxx_daughters[]

Initial value:

 {
    get_alpha_daughters,
    get_betami_daughters,
    get_betapl_daughters,
    get_ec_daughters,
    get_it_daughters,
    get_gamma_daughters,
    0
}

Definition at line 877 of file NucUtil.cc.

const char* decay_names[]

Initial value:

 {
    "A DECAY",
    "B- DECAY",
    "B+ DECAY",
    "EC DECAY",
    "IT DECAY",
    "GAMMA DECAY",
    0
}

Definition at line 886 of file NucUtil.cc.

---