def cs_Rincl(Z, A, yields): """Returns incl of residual production [description] Arguments: Z {[type]} -- [description] A {[type]} -- [description] """ Amax = max(yields.keys()) nuclist = [100, 101] csilist = [cs_nincl(Z, A), cs_pincl(Z, A)] sub_frags = {} for nz in range(0, int(Z / 2.) + 1): for nn in range(0, int((A - Z) / 2.) + 1): Ared = min(Amax, nn + nz) # print nn, nz, A-Z, Z if nn + nz == 0: # add pion contribution nuclist += [A * 100 + Z, A * 100 + Z - 1, A * 100 + Z + 1] csilist += [ cs_gpi(A) / 3, ] * 3 continue cs_incl = 0 new_frag = 0 if (nn == 1) and (nz == 0): cs_incl = cs_gn(A) elif (nn > 1) and (nz == 0): cs_incl = cs_gxn(A, nn) elif (nn == 0) and (nz == 1): cs_incl = cs_gp(Z) elif (nn >= 1) and (nz >= 1): cs_incl = cs_gSp(Z, A, nz, nn) new_frag = 100 * Ared + Ared / 2 - nz if new_frag > 0: csilist.append(cs_incl) nuclist.append(new_frag) sub_frags = yields[Ared] if cs_incl > 0: csilist.append(cs_incl) nuclist.append(100 * (A - nn - nz) + Z - nz) if sub_frags: suma = 0 for nuc, val in sub_frags.iteritems(): Af, _, _ = get_AZN(nuc) suma += Af * val norm = Ared / suma for nuc, val in sub_frags.iteritems(): if nuc in nuclist: csilist[nuclist.index(nuc)] += val * norm * cs_incl else: csilist.append(val * norm * cs_incl) return nuclist, csilist
def spallation_multiplicities(mother): '''Calculates the inclusive cross sections of all fragments of mothter species (moter is a neucos id) for spallation ''' Am, Zm, _ = get_AZN(mother) incl_tab = {} cs_sum = 0 for A_big_frag in range(Am / 2, Am - 1): for big_frag in species_by_mass[A_big_frag]: _, x, y = get_AZN(mother - big_frag) spalled_id = 100 * (x + y) + x if (x < 1) or (y < 1): # in spallation at least a neutron and proton escape continue cs_frag = cs_gSp(Zm, Am, x, y) cs_sum += cs_frag # sum of all cross sections to normalize incl_tab if big_frag in incl_tab: incl_tab[big_frag] += cs_frag else: incl_tab[big_frag] = cs_frag # get low fragment incl_tab from using Counter on a prepared list with x, y outputs for dau in resmul[spalled_id]: if dau in incl_tab: incl_tab[dau] += cs_frag * resmul[spalled_id][dau] else: incl_tab[dau] = cs_frag * resmul[spalled_id][dau] for dau in incl_tab: # all spallation cross section should match total spallation cross section incl_tab[dau] /= where(cs_sum == 0, inf, cs_sum) return incl_tab
def cs_gSp_all_inA(A): """Cross section summed for all possible spallation events """ n = 0 cs_summed = 0 cs_vals = [] if A in species_by_mass: for nuc in species_by_mass[A]: A, Z, N = get_AZN(nuc) cs_summed = cs_gSp_all(Z, A) cs_vals.append(cs_gSp_all(Z, A)) n += 1 # return cs_summed / n return max(cs_vals)
def list_species_by_mass(Amax, tau=inf): '''Returns a dictionary with the species stable enough to be produced in spallation. ''' species = {} for nuc in [k for k in sorted(spec_data.keys()) if isinstance(k, int)]: if (nuc < 100) or (spec_data[nuc]['lifetime'] < tau): continue At, _, _ = get_AZN(nuc) if At in species: species[At].append(nuc) else: species[At] = [nuc] return species
def combinations(x, y): '''Returns possible combinations of nuclei with mass A<=4 such that they contain x protons and y neutrons. ''' ncos_id = int((x + y) * 100 + x) mass_partitions = partitions(x + y) for mass_partition in mass_partitions: mass_partition = [f for f in mass_partition if f > 1] species = [ species_by_mass[Af] for Af in mass_partition if Af in species_by_mass ] for c in list(itertools.product(*species)): _, z, n = get_AZN(sum(c)) if (z <= x) and (n <= y): yield int(y - n) * (100, ) + int(x - z) * (101, ) + c
def cs_gSp_all(Z, A): """Cross section summed for all possible spallation events """ mother = 100 * A + Z cs_tot = 0 for A_big_frag in range(A / 2, A - 1): for big_frag in species_by_mass[A_big_frag]: _, x, y = get_AZN(mother - big_frag) spalled_id = 100 * (x + y) + x if (x < 1) or (y < 1): # in spallation at least a neutron and proton escape continue cs_frag = cs_gSp(Z, A, x, y) cs_tot += cs_frag return cs_tot
def gxn_multiplicities(mother): """Multiplicities for multineutron emission A(g,xn)X Arguments: A {int} -- Nucleon number of the target nucleus """ cs_sum = 0 cs_gxn_incl = {100: 0} Am, _, _ = get_AZN(mother) for xi in range(2, xm(Am)): cs = cs_gxn(Am, xi) cs_gxn_incl[100] += xi * cs cs_gxn_incl[mother - xi * 100] = cs cs_sum += cs for dau in cs_gxn_incl: if cs_gxn_incl[dau] != 0: cs_gxn_incl[dau] /= cs_sum return cs_gxn_incl
def residual_multiplicities(): '''Makes a dictionary where the ncos id with x,y number of protons and neutrons emitted are the keys, and the multiplicities of species between A=1-4 are given, normalized such that they add up to x protons and y neutrons. This is a function to precompute the table which is used to find the multiplicities of the empirical photomeson model. ''' spalled_nucleons = [] for Am in species_by_mass: for mother in species_by_mass[Am]: for A_big_frag in range(Am / 2, Am - 1): for big_frag in species_by_mass[A_big_frag]: if big_frag % 100 > mother % 100: continue spalled_frag = mother - big_frag spalled_nucleons.append(spalled_frag) # print spalled_nucleons[-1] residual_list = {} count = 0 last = 0 print 'Completed.... ', 0 cant = float(len(set(spalled_nucleons))) for tot in set(spalled_nucleons): count += 1 # print '--', tot, '--', '{:3.3f}'.format(count/cant) if int(100 * count / cant) >= last + 5: print 'Completed.... ', int(100 * count / cant) last += 5 _, x, y = get_AZN(tot) counts = Counter([e for elem in combinations(x, y) for e in elem]) suma = 0 for k, v in counts.iteritems(): suma += k * v for k in counts: counts[k] *= tot / float(suma) residual_list[tot] = counts.copy() return residual_list
def multiplicity_table(mother): '''Returns a dict with the multiplicities for all fragments from mother is contained. The differentence with spallation_inclusive is that here all processes are contained ''' gxn_mult = gxn_multiplicities(mother) sp_mult = spallation_multiplicities(mother) Am, Zm, _ = get_AZN(mother) cspi = cs_gpi(Am) csp = cs_gp(A=Am) csn = cs_gn(Am) csxn = cs_gxn_all(Am) cs_tot = .28 * Am csSp = cs_tot - (cspi + csp + csn + csxn) multiplicities = { 100: 1. * csn / cs_tot, 101: 1. * csp / cs_tot, mother - 100: 1. * csn / cs_tot, mother - 101: 1. * csp / cs_tot, } for dau, mult in gxn_mult.iteritems(): if dau in multiplicities: multiplicities[dau] += mult * csxn / cs_tot else: multiplicities[dau] = mult * csxn / cs_tot for dau, mult in sp_mult.iteritems(): if dau in multiplicities: multiplicities[dau] += mult * csSp / cs_tot else: multiplicities[dau] = mult * csSp / cs_tot return multiplicities