Ejemplo n.º 1
0
Archivo: iav_2.py Proyecto: gnafit/gna
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument('--dot', help='write graphviz output')
parser.add_argument('-s',
                    '--show',
                    action='store_true',
                    help='show the figure')
args = parser.parse_args()

#
# Initialize bundle
#
cfg = NestedDict(bundle='detector_iav_db_root_v01',
                 parname='OffdiagScale.{}',
                 scale=uncertain(1.0, 4, 'percent'),
                 ndiag=1,
                 filename='data/dayabay/tmp/detector_iavMatrix_P14A_LS.root',
                 matrixname='iav_matrix')
b, = execute_bundles(cfg=cfg, namespaces=['AD1', 'AD2', 'AD3'])
(smear1, smear2, smear3) = b.transformations_out.values()

env.globalns.printparameters(labels=True)

par1, par2, par3 = (b.common_namespace('OffdiagScale')[s]
                    for s in ('AD1', 'AD2', 'AD3'))
par1.set(1.5)
par2.set(1.0)
par3.set(0.5)

Ejemplo n.º 2
0
#
# Define the configuration
#
cfg = NestedDict()
cfg.detector = NestedDict(
        # the bundle name
        bundle = 'bundlechain_v01',
        detectors = [ 'AD11', 'AD21', 'AD31' ],
        bundlechain_list = [ 'iav', 'nonlinearity', 'eres', 'rebin' ],
        )
cfg.detector.nonlinearity = NestedDict(
        bundle = 'detector_nonlinearity_db_root_v01',
        names = [ 'nominal', 'pull0', 'pull1', 'pull2', 'pull3' ],
        filename = 'data/dayabay/tmp/detector_nl_consModel_450itr.root',
        parname = 'escale.{}',
        par = uncertain(1.0, 0.2, 'percent'),
        )
cfg.detector.iav = NestedDict(
        bundle = 'detector_iav_db_root_v01',
        parname = 'OffdiagScale.{}',
        scale   = uncertain(1.0, 4, 'percent'),
        ndiag = 1,
        filename = 'data/dayabay/tmp/detector_iavMatrix_P14A_LS.root',
        matrixname = 'iav_matrix'
        )
cfg.detector.eres = NestedDict(
        bundle = 'detector_eres_common3',
        # pars: sigma_e/e = sqrt( a^2 + b^2/E + c^2/E^2 ),
        pars = uncertaindict(
            [('Eres_a', 0.014764) ,
             ('Eres_b', 0.0869) ,
Ejemplo n.º 3
0
 def init_configuration(self):
     self.cfg = NestedDict(
         integral=NestedDict(
             bundle=dict(name='integral_2d1d', version='v03'),
             variables=('evis', 'ctheta'),
             edges=N.linspace(0.0, 12.0, 241, dtype='d'),
             xorders=4,
             yorder=2,
         ),
         ibd_xsec=NestedDict(bundle=dict(name='xsec_ibd', version='v02'),
                             order=1,
                             pdg_year='dyboscar'),
         oscprob=NestedDict(
             bundle=dict(name='oscprob', version='v04', major='rdc'),
             #  pdg_year='dyboscar',
             dm='23',
         ),
         anuspec=NestedDict(
             bundle=dict(name='reactor_anu_spectra', version='v04'),
             name='anuspec',
             filename=[
                 'data/reactor_anu_spectra/Huber/Huber_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat',
                 'data/reactor_anu_spectra/Mueller/Mueller_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat'
             ],
             free_params=True,  # enable free spectral model
             varmode='plain',
             varname='anue_weight_{index}',
             ns_name='spectral_weights',
             edges=N.concatenate((N.arange(1.8, 8.7, 0.5), [12.3])),
         ),
         offeq_correction=NestedDict(
             bundle=dict(name='reactor_offeq_spectra',
                         version='v04',
                         major='ir'),
             offeq_data=
             'data/reactor_anu_spectra/Mueller/offeq/mueller_offequilibrium_corr_{isotope}.dat',
         ),
         eff=NestedDict(
             bundle=dict(name='efficiencies',
                         version='v02',
                         names=dict(norm='global_norm'),
                         major=''),
             correlated=False,
             uncorrelated=True,
             norm=True,
             efficiencies='data/dayabay/efficiency/P15A_efficiency.py'),
         livetime=NestedDict(
             bundle=dict(name='dayabay_livetime_hdf', version='v02'),
             file=
             'data/dayabay/data/P15A/dubna/dayabay_data_dubna_v15_bcw_adsimple.hdf5',
         ),
         baselines=NestedDict(
             bundle=dict(name='reactor_baselines',
                         version='v01',
                         major='rd'),
             reactors=
             'data/dayabay/reactor/coordinates/coordinates_docDB_9757.py',
             detectors=
             'data/dayabay/ad/coordinates/coordinates_docDB_9757.py',
             unit='m'),
         thermal_power=NestedDict(
             bundle=dict(name='dayabay_reactor_burning_info_v02',
                         major='ri'),
             reactor_info=
             'data/dayabay/reactor/power/WeeklyAvg_P15A_v1.txt.npz',
             fission_uncertainty_info=
             'data/dayabay/reactor/fission_fraction/2013.12.05_djurcic.py',
             add_ff=True,
             nominal_power=False,
         ),
         nominal_thermal_power=NestedDict(
             bundle=dict(name="parameters", version="v01"),
             parameter='nominal_thermal_power',
             label='Nominal thermal power [Gw] for {reactor}',
             pars=uncertaindict(
                 [
                     ('DB1', 2.895),
                     ('DB2', 2.895),
                     ('LA1', 2.895),
                     ('LA2', 2.895),
                     ('LA3', 2.895),
                     ('LA4', 2.895),
                 ],
                 uncertainty=0.5,
                 mode='percent',
             ),
         ),
         snf_ff=NestedDict(
             bundle=dict(name="parameters", version="v01"),
             parameter='snf_fission_fractions',
             objectize=True,
             label='SNF fission fraction {isotope}',
             pars=uncertaindict(
                 [('U235', 0.563), ('U238', 0.079), ('Pu239', 0.301),
                  ('Pu241', 0.057)],
                 mode='fixed',
             ),
         ),
         snf_denom=NestedDict(
             bundle=dict(name="parameters", version="v01"),
             parameter='snf_denom',
             objectize=True,
             label='SNF inverse weight for average energy release per decay',
             pars=uncertain(snf_energy_per_decay, 'fixed'),
         ),
         snf_correction=NestedDict(
             bundle=dict(name='reactor_snf_spectra',
                         version='v04',
                         major='r'),
             snf_average_spectra=
             './data/reactor_anu_spectra/SNF/kopeikin_0412.044_spent_fuel_spectrum_smooth.dat',
         ),
         eper_fission=NestedDict(
             bundle=dict(name="parameters", version="v01"),
             parameter="eper_fission",
             label='Energy per fission for {isotope} in MeV',
             pars=uncertaindict([('Pu239', (211.12, 0.34)),
                                 ('Pu241', (214.26, 0.33)),
                                 ('U235', (202.36, 0.26)),
                                 ('U238', (205.99, 0.52))],
                                mode='absolute'),
         ),
         conversion_factor=NestedDict(
             bundle=dict(name="parameters", version="v01"),
             parameter='conversion_factor',
             label='Conversion factor from GWt to MeV',
             #taken from transformations/neutrino/ReactorNorm.cc
             pars=uncertain(R.NeutrinoUnits.reactorPowerConversion,
                            'fixed'),
         ),
         nprotons_nominal=NestedDict(
             bundle=dict(name="parameters", version="v01"),
             parameter='nprotons_nominal',
             label=
             'Daya Bay nominal number of protons (20 tons x GdLS Np/ton)',
             pars=uncertain(20.0 * 7.163e28, 'fixed'),
         ),
         nprotons_corr=NestedDict(
             bundle=dict(name="parameters", version="v01"),
             parameter='nprotons_corr',
             label='Correction to number of protons per AD',
             pars=uncertaindict(
                 [('AD11', 19941. / nominal_mass),
                  ('AD12', 19967. / nominal_mass),
                  ('AD21', 19891. / nominal_mass),
                  ('AD22', 19944. / nominal_mass),
                  ('AD31', 19917. / nominal_mass),
                  ('AD32', 19989. / nominal_mass),
                  ('AD33', 19892. / nominal_mass),
                  ('AD34', 19931. / nominal_mass)],
                 mode='fixed',
             ),
         ),
         iav=NestedDict(
             bundle=dict(name='detector_iav_db_root_v03', major='d'),
             parname='OffdiagScale',
             scale=uncertain(1.0, 4, 'percent'),
             ndiag=1,
             filename='data/dayabay/tmp/detector_iavMatrix_P14A_LS.root',
             matrixname='iav_matrix',
         ),
         eres=NestedDict(
             bundle=dict(name='detector_eres_normal',
                         version='v01',
                         major=''),
             # pars: sigma_e/e = sqrt( a^2 + b^2/E + c^2/E^2 ),
             parameter='eres',
             pars=uncertaindict(
                 [('a', 0.016), ('b', 0.081), ('c', 0.026)],
                 #  [('a', 0.014764) ,
                 #  ('b', 0.0869) ,
                 #  ('c', 0.0271)],
                 mode='percent',
                 uncertainty=30),
             expose_matrix=True),
         lsnl=NestedDict(
             bundle=dict(name='energy_nonlinearity_db_root',
                         version='v02',
                         major='dl'),
             names=['nominal', 'pull0', 'pull1', 'pull2', 'pull3'],
             filename='data/dayabay/tmp/detector_nl_consModel_450itr.root',
             par=uncertain(1.0, 0.2, 'percent'),
             edges='evis_edges',
             extrapolation_strategy='extrapolate',
             nonlin_range=(0.5, 12.)),
         rebin=NestedDict(bundle=dict(name='rebin', version='v03',
                                      major=''),
                          rounding=3,
                          edges=N.concatenate(
                              ([0.7], N.arange(1.2, 8.1, 0.2), [12.0])),
                          name='rebin',
                          label='Final histogram\n {detector}'),
         #
         # Spectra
         #
         bkg_spectrum_acc=NestedDict(
             bundle=dict(name='root_histograms_v03'),
             filename=
             'data/dayabay/data_spectra/P15A_IHEP_data/P15A_All_raw_sepctrum_coarse.root',
             format='{site}_AD{adnum_local}_singleTrigEnergy',
             name='bkg_spectrum_acc',
             label='Accidentals {detector}\n (norm spectrum)',
             groups=self.groups,
             normalize=True,
         ),
         bkg_spectrum_li=NestedDict(
             bundle=dict(name='root_histograms_v03'),
             filename='data/dayabay/bkg/lihe/toyli9spec_BCWmodel_v1.root',
             format='h_eVisAllSmeared',
             name='bkg_spectrum_li',
             label='9Li spectrum\n (norm)',
             normalize=True,
         ),
         bkg_spectrum_he=NestedDict(
             bundle=dict(name='root_histograms_v03'),
             filename='data/dayabay/bkg/lihe/toyhe8spec_BCWmodel_v1.root',
             format='h_eVisAllSmeared',
             name='bkg_spectrum_he',
             label='8He spectrum\n (norm)',
             normalize=True,
         ),
         bkg_spectrum_amc=NestedDict(
             bundle=dict(name='root_histograms_v03'),
             filename='data/dayabay/bkg/P12B_amc_expofit.root',
             format='hCorrAmCPromptSpec',
             name='bkg_spectrum_amc',
             label='AmC spectrum\n (norm)',
             normalize=True,
         ),
         bkg_spectrum_alphan=NestedDict(
             bundle=dict(name='root_histograms_v03'),
             filename='data/dayabay/bkg/P12B_alphan_coarse.root',
             format='AD{adnum_global_alphan_subst}',
             groups=self.groups,
             name='bkg_spectrum_alphan',
             label='C(alpha,n) spectrum\n {detector} (norm)',
             normalize=True,
         ),
         lihe_fractions=NestedDict(
             bundle=dict(name='var_fractions_v02'),
             names=['li', 'he'],
             format='frac_{component}',
             fractions=uncertaindict(li=(0.95, 0.05, 'relative')),
         ),
         bkg_spectrum_fastn=NestedDict(
             bundle=dict(name='dayabay_fastn_power',
                         version='v02',
                         major='s'),
             parameter='fastn_shape',
             name='bkg_spectrum_fastn',
             normalize=(0.7, 12.0),
             bins='evis_edges',
             order=2,
         ),
         #
         # Parameters
         #
         fastn_shape=NestedDict(
             bundle=dict(name="parameters", version="v01"),
             parameter='fastn_shape',
             label='Fast neutron shape parameter for {site}',
             pars=uncertaindict(
                 [('EH1', (67.79, 0.1132)), ('EH2', (58.30, 0.0817)),
                  ('EH3', (68.02, 0.0997))],
                 mode='relative',
             ),
         ),
         lihe_fracs=NestedDict(
             bundle=dict(name='dyb_lihe_fractions', version='v01'),
             frac_file_path='./data/dayabay/fractions/{site}_fractions.txt',
             mode=self.opts.lihe_fractions)
         if self.opts.lihe_fractions != 'no' else NestedDict(),
         #
         # Rates
         #
         bkg_rate_acc=NestedDict(
             bundle=dict(name="parameters", version="v01"),
             parameter='bkg_rate_acc',
             label='Acc rate at {detector}',
             pars=uncertaindict(
                 [
                     ('AD11', 8.463602),
                     ('AD12', 8.464611),
                     ('AD21', 6.290756),
                     ('AD22', 6.180896),
                     ('AD31', 1.273798),
                     ('AD32', 1.189542),
                     ('AD33', 1.197807),
                     ('AD34', 0.983096),
                 ],
                 uncertainty=1.0,
                 mode='percent',
             ),
             separate_uncertainty='acc_norm',
         ),
         bkg_rate_lihe=NestedDict(
             bundle=dict(name="parameters", version="v01"),
             parameter='bkg_rate_lihe',
             label='⁹Li/⁸He rate at {site}',
             pars=uncertaindict(
                 [('EH1', (2.46, 1.06)), ('EH2', (1.72, 0.77)),
                  ('EH3', (0.15, 0.06))],
                 mode='absolute',
             ),
         ),
         bkg_rate_fastn=NestedDict(
             bundle=dict(name="parameters", version="v01"),
             parameter='bkg_rate_fastn',
             label='Fast neutron rate at {site}',
             pars=uncertaindict(
                 [('EH1', (0.792, 0.103)), ('EH2', (0.566, 0.074)),
                  ('EH3', (0.047, 0.009))],
                 mode='absolute',
             ),
         ),
         bkg_rate_amc=NestedDict(
             bundle=dict(name="parameters", version="v01"),
             parameter='bkg_rate_amc',
             label='AmC rate at {detector}',
             pars=uncertaindict(
                 [
                     ('AD11', (0.18, 0.08)),
                     ('AD12', (0.18, 0.08)),
                     ('AD21', (0.16, 0.07)),
                     ('AD22', (0.15, 0.07)),
                     ('AD31', (0.07, 0.03)),
                     ('AD32', (0.06, 0.03)),
                     ('AD33', (0.07, 0.03)),
                     ('AD34', (0.05, 0.02)),
                 ],
                 mode='absolute',
             ),
         ),
         bkg_rate_alphan=NestedDict(
             bundle=dict(name="parameters", version="v01"),
             parameter='bkg_rate_alphan',
             label='C(alpha,n) rate at {detector}',
             pars=uncertaindict(
                 [
                     ('AD11', (0.08)),
                     ('AD12', (0.07)),
                     ('AD21', (0.05)),
                     ('AD22', (0.07)),
                     ('AD31', (0.05)),
                     ('AD32', (0.05)),
                     ('AD33', (0.05)),
                     ('AD34', (0.05)),
                 ],
                 uncertainty=50,
                 mode='percent',
             ),
         ),
     )
Ejemplo n.º 4
0
            ('SA.D2', 3.0),
            ('SB.D2', 4.0),
            ('SA.D3', 5.0),
            ('SB.D3', 6.0),
            ('SA.D4', 7.0),
            ('SB.D4', 8.0),
        ],
        uncertainty=1.0,
        mode='percent',
    ),
)

cfg3 = NestedDict(bundle=dict(
    name='parameters',
    version='v01',
),
                  parameter='constant',
                  label='some constant',
                  pars=uncertain(-1.0, uncertainty=4.0, mode='percent'))

b1 = execute_bundle(cfg1)
b2 = execute_bundle(cfg2)
b3 = execute_bundle(cfg3)

env.globalns.printparameters(labels=True)

print('Provides:')
print(b1.provides(cfg1))
print(b1.provides(cfg2))
print(b1.provides(cfg3))
Ejemplo n.º 5
0
    def init_configuration(self):
        edges    = np.arange(0.0, 12+1.e-8, self.opts.fine_step or 0.01)
        edges_final = np.concatenate( (
                                    [0.8],
                                    np.arange(1, 6.0, self.opts.fine_step_final or 0.02),
                                    np.arange(6, 7.0, 0.1),
                                    [7.0, 7.5, 12.0]
                                )
                            )
        if self.opts.final_emin is not None:
            print('Truncate final binning E>={}'.format(self.opts.final_emin))
            edges_final = edges_final[edges_final>=self.opts.final_emin]
        if self.opts.final_emax is not None:
            print('Truncate final binning E<={}'.format(self.opts.final_emax))
            edges_final = edges_final[edges_final<=self.opts.final_emax]
        if self.opts.final_emin is not None or self.opts.final_emax is not None:
            print('Final binning:', edges_final)

        self.cfg = NestedDict(
                #
                # Numbers
                #
                numbers0 = OrderedDict(
                    bundle = dict(name='parameters', version='v05'),
                    state='fixed',
                    labels=dict(
                        seconds_in_year   = 'Number of seconds in year',
                        days_in_second    = 'Number of days in a second',
                        conversion_factor = 'Conversion factor: W[GW]/[MeV] N[fissions]->N[fissions]/T[s]',
                        ),
                    pars =  dict(
                            seconds_in_year   = 365.0*24.0*60.0*60.0,
                            days_in_second    = 1.0/(24.0*60.0*60.0),
                            conversion_factor = R.NeutrinoUnits.reactorPowerConversion, #taken from transformations/neutrino/ReactorNorm.cc
                            ),
                    ),
                numbers = OrderedDict(
                    bundle = dict(name='parameters', version='v06'),
                    pars = 'data/data_juno/data-joint/2020-06-11-NMO-Analysis-Input/files/juno_input_numbers.py',
                    skip = ('percent',),
                    state= 'fixed'
                    ),
                bkg_shape_unc = OrderedDict(
                    bundle = dict(name='parameters', version='v06'),
                    pars = 'data/data_juno/data-joint/2020-06-11-NMO-Analysis-Input/files/bkg_bin2bin.yaml',
                    hooks = OrderedDict(bin_width_factor=lambda pars: (1.0/pars['bin_width'], '1/`bin width`')),
                    state= 'fixed'
                    ),
                # Detector and reactor
                norm = OrderedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "norm",
                        label = 'Reactor power/detection efficiency correlated normalization',
                        pars = uncertain(1.0, (2**2+1**2)**0.5, 'percent')
                        ),
                baselines = OrderedDict(
                        bundle = dict(name='reactor_baselines', version='v02', major = 'rd'),
                        reactors  = 'data/data_juno/data-joint/2020-06-11-NMO-Analysis-Input/files/reactor_baselines.yaml',
                        reactors_key = 'reactor_baseline',
                        detectors = dict(AD1=0.0),
                        unit = 'km'
                        ),
                # Reactor
                energy_per_fission =  OrderedDict(
                        bundle = dict(name="parameters", version = "v06"),
                        pars = 'data/data_juno/data-joint/2020-06-11-NMO-Analysis-Input/files/energy_per_fission.yaml',
                        separate_uncertainty = '{}_scale'
                        ),
                thermal_power =  OrderedDict(
                        bundle = dict(name="parameters", version = "v06", names=dict(thermal_power='thermal_power_nominal')),
                        pars = 'data/data_juno/data-joint/2020-06-11-NMO-Analysis-Input/files/thermal_power.yaml',
                        separate_uncertainty = '{}_scale'
                        ),
                # Backgrounds
                bkg_rate = OrderedDict(
                        bundle = dict(name="parameters", version = "v06"),
                        pars = 'data/data_juno/data-joint/2020-06-11-NMO-Analysis-Input/files/bkg_rates.yaml',
                        separate_uncertainty = '{}_norm'
                    ),
                #
                # Transformations
                #
                # General
                kinint2 = OrderedDict(
                    bundle    = dict(name='integral_2d1d', version='v03', names=dict(integral='kinint2')),
                    variables = ('evis', 'ctheta'),
                    edges     = edges,
                    #  edges   = np.linspace(0.0, 12.001, 601),
                    xorders   = 4,
                    yorder    = 5,
                    ),
                rebin = OrderedDict(
                    bundle = dict(name='rebin', version='v04', major=''),
                    rounding = 5,
                    edges = edges_final,
                    instances={
                        'rebin': 'Final histogram {detector}',
                        }
                    ),
                rebin_bkg = OrderedDict(
                    bundle = dict(name='rebin', version='v04', major=''),
                    rounding = 5,
                    edges = edges_final,
                    instances={
                        'rebin_acc': 'Accidentals {autoindex}',
                        'rebin_lihe': '9Li/8He {autoindex}',
                        'rebin_fastn': 'Fast neutrons {autoindex}',
                        'rebin_alphan': 'C(alpha,n)O {autoindex}',
                        'rebin_geonu': 'Geo-nu {autoindex}'
                        }
                    ),
                bkg_shape_uncertainty = OrderedDict(
                    bundle = dict(name='trans_sumsq', version='v01', major=''),
                    ninputs = 3,
                    instances={'sumsq_bkg': 'Bkg shape variance {autoindex}'}
                    ),
                bkg_edges = OrderedDict(
                    bundle = dict(name='trans_histedges', version='v01', major=''),
                    types = ('widths', ),
                    instances={'bkgbin': 'Bkg bins {autoindex}'}
                    ),
                variance = OrderedDict(
                    bundle = dict(name='trans_snapshot', version='v01', major=''),
                    instances={'sumsq_snapshot': 'Bkg shape variance snapshot, not corrected|{autoindex}',
                               'staterr2': 'Stat. errors (snapshot)'}
                    ),
                # Oscillations and detection
                ibd_xsec = OrderedDict(
                        bundle = dict(name='xsec_ibd', version='v02'),
                        order = 1,
                        ),
                oscprob = OrderedDict(
                        bundle = dict(name='oscprob', version='v05', major='rdc', inactive=self.opts.oscprob=='matter'),
                        parameters = dict(
                            DeltaMSq23    = 2.453e-03,
                            DeltaMSq12    = 7.53e-05,
                            SinSqDouble13 = (0.08529904, 0.00267792),
                            SinSqDouble12 = 0.851004,
                            # SinSq13 = (0.0218, 0.0007),
                            # SinSq12 = 0.307,
                            )
                        ),
                # oscprob_matter = OrderedDict(
                    # bundle = dict(name='oscprob_matter', version='v01', major='rd', inactive=self.opts.oscprob=='vacuum',
                                  # names=dict(oscprob='oscprob_matter')),
                    # density = 2.6, # g/cm3
                    # pdgyear = self.opts.pdgyear,
                    # dm      = '23'
                    # ),
                anuspec_hm = OrderedDict(
                        bundle = dict(name='reactor_anu_spectra', version='v05'),
                        name = 'anuspec',
                        filename = 'data/data_juno/data-joint/2020-06-11-NMO-Analysis-Input/deprecated/JUNOInputs2020_6_26.root',
                        objectnamefmt = 'HuberMuellerFlux_{isotope}',
                        free_params=False, # enable free spectral model
                        varmode='log',
                        varname='anue_weight_{index:02d}',
                        ns_name='spectral_weights',
                        edges = np.concatenate( ( np.arange( 1.8, 8.7, 0.025 ), [ 12.3 ] ) ),
                        ),
                offeq_correction = OrderedDict(
                        bundle = dict(name='reactor_offeq_spectra', version='v05', major=''),
                        offeq_data = 'data/data_juno/data-joint/2020-06-11-NMO-Analysis-Input/deprecated/JUNOInputs2020_6_26.root',
                        objectnamefmt = 'NonEq_FluxRatio',
                        relsigma = 0.3,
                        ),
                fission_fractions = OrderedDict(
                        bundle = dict(name="parameters_yaml_v01", major = 'i'),
                        parameter = 'fission_fractions_nominal',
                        separate_uncertainty = "fission_fractions_scale",
                        label = 'Fission fraction of {isotope} in reactor {reactor}',
                        objectize=True,
                        data = 'data/data_juno/data-joint/2020-06-11-NMO-Analysis-Input/files/fission_fractions.yaml'
                        ),
                snf_correction = OrderedDict(
                        bundle = dict(name='reactor_snf_spectra', version='v05', major='r'),
                        snf_average_spectra = 'data/data_juno/data-joint/2020-06-11-NMO-Analysis-Input/deprecated/JUNOInputs2020_6_26.root',
                        objectname = 'SNF_FluxRatio'
                        ),
                lsnl = OrderedDict(
                        bundle     = dict(name='energy_nonlinearity_db_root', version='v03', major='l'),
                        names      = OrderedDict( [
                            ('nominal', 'positronScintNL'),
                            ('pull0', 'positronScintNLpull0'),
                            ('pull1', 'positronScintNLpull1'),
                            ('pull2', 'positronScintNLpull2'),
                            ('pull3', 'positronScintNLpull3'),
                            ]),
                        filename   = 'data/data_juno/data-joint/2020-06-11-NMO-Analysis-Input/deprecated/JUNOInputs2020_6_26.root',
                        edges      = 'evis_edges',
                        extrapolation_strategy = 'extrapolate',
                        nonlin_range = (0.95, 12.),
                        expose_matrix = True
                        ),
                shape_uncertainty = OrderedDict(
                        unc = uncertain(1.0, 1.0, 'percent'),
                        nbins = 200 # number of bins, the uncertainty is defined to
                        ),
                snf_norm = OrderedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = 'snf_norm',
                        label='SNF norm',
                        pars = uncertain(1.0, 'fixed'),
                        ),
                reactor_active_norm = OrderedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = 'reactor_active_norm',
                        label='Reactor nu (active norm)',
                        pars = uncertain(1.0, 'fixed'),
                        ),
                #
                # Backgrounds
                #
                bkg_spectra = OrderedDict(
                    bundle    = dict(name='root_histograms_v05'),
                    filename  = 'data/data_juno/data-joint/2020-06-11-NMO-Analysis-Input/deprecated/JUNOInputs2020_6_26.root',
                    formats = ['AccBkgHistogramAD',           'Li9BkgHistogramAD',       'FnBkgHistogramAD',       'AlphaNBkgHistogramAD',   'GeoNuTh232'                 , 'GeoNuU238'],
                    names   = ['acc_spectrum',                'lihe_spectrum',           'fastn_spectrum',         'alphan_spectrum',        'geonu_Th232_spectrum'       , 'geonu_U238_spectrum'],
                    labels  = ['Accidentals|(norm spectrum)', '9Li/8He|(norm spectrum)', 'Fast n|(norm spectrum)', 'AlphaN|(norm spectrum)', 'GeoNu Th232|(norm spectrum)', 'GeoNu U238|(norm spectrum)'],
                    normalize = True,
                    ),
                geonu_fractions=OrderedDict(
                        bundle = dict(name='var_fractions_v02'),
                        names = [ 'Th232', 'U238' ],
                        format = 'frac_{component}',
                        fractions = uncertaindict(
                            Th232 = ( 0.23, 'fixed' )
                            ),
                        ),
                )

        if 'eres' in self.opts.energy_model:
            self.cfg.eres = OrderedDict(
                    bundle = dict(name='detector_eres_normal', version='v01', major=''),
                    # pars: sigma_e/e = sqrt(a^2 + b^2/E + c^2/E^2),
                    # a - non-uniformity
                    # b - statistical term
                    # c - noise
                    parameter = 'eres',
                    pars = uncertaindict([
                        ('a_nonuniform', (0.0082, 0.0001)),
                        ('b_stat',       (0.0261, 0.0002)),
                        ('c_noise',      (0.0123, 0.0004))
                        ],
                        mode='absolute'),
                    expose_matrix = False
                    )
        elif 'multieres' in self.opts.energy_model:
            self.cfg.subdetector_fraction = OrderedDict(
                    bundle = dict(name="parameters", version = "v03"),
                    parameter = "subdetector_fraction",
                    label = 'Subdetector fraction weight for {subdetector}',
                    pars = uncertaindict(
                        [(subdet_name, (0.2, 0.04, 'relative')) for subdet_name in self.subdetectors_names],
                        ),
                    covariance = 'data/data_juno/energy_resolution/2019_subdetector_eres_n200_proper/subdetector5_cov.txt'
                    )
            self.cfg.multieres = OrderedDict(
                    bundle = dict(name='detector_multieres_stats', version='v01', major='s'),
                    # pars: sigma_e/e = sqrt(b^2/E),
                    parameter = 'eres',
                    relsigma = self.opts.eres_b_relsigma,
                    nph = 'data/data_juno/energy_resolution/2019_subdetector_eres_n200_proper/subdetector5_nph.txt',
                    rescale_nph = self.opts.eres_npe,
                    expose_matrix = False
                    )

        if not 'lsnl' in self.opts.correlation:
            self.cfg.lsnl.correlations = None
            self.cfg.lsnl.correlations_pars = None
        if not 'subdetectors' in self.opts.correlation:
            self.cfg.subdetector_fraction.correlations = None
Ejemplo n.º 6
0
    def init_configuration(self):
        if self.opts.eres_npe:
            self.opts.eres_sigma = self.opts.eres_npe**-0.5
        else:
            self.opts.eres_npe = self.opts.eres_sigma**-2
        print('Energy resolution at 1 MeV: {}% ({} pe)'.format(
            self.opts.eres_sigma * 100, self.opts.eres_npe))

        edges = np.arange(0.0, 12.001, 0.01)  #FIXME
        edges_final = np.concatenate(([0.7], np.arange(1, 6.0,
                                                       self.opts.estep),
                                      np.arange(6, 7.0, 0.1), [7.0, 7.5,
                                                               12.0]))
        if self.opts.final_emin is not None:
            print('Truncate final binning E>={}'.format(self.opts.final_emin))
            edges_final = edges_final[edges_final >= self.opts.final_emin]
        if self.opts.final_emax is not None:
            print('Truncate final binning E<={}'.format(self.opts.final_emax))
            edges_final = edges_final[edges_final <= self.opts.final_emax]
        if self.opts.final_emin is not None or self.opts.final_emax is not None:
            print('Final binning:', edges_final)
        self.cfg = NestedDict(
                kinint2 = NestedDict(
                    bundle    = dict(name='integral_2d1d', version='v03', names=dict(integral='kinint2')),
                    variables = ('evis', 'ctheta'),
                    edges     = edges,
                    #  edges   = np.linspace(0.0, 12.001, 601),
                    xorders   = 4,
                    yorder    = 5,
                    ),
                rebin = NestedDict(
                        bundle = dict(name='rebin', version='v04', major=''),
                        rounding = 5,
                        edges = edges_final,
                        instances={
                            'rebin': 'Final histogram {detector}',
                            }
                        ),
                rebin_bkg = NestedDict(
                        bundle = dict(name='rebin', version='v04', major=''),
                        rounding = 5,
                        edges = edges_final,
                        instances={
                            'rebin_acc': 'Accidentals {autoindex}',
                            'rebin_li': '9Li {autoindex}',
                            'rebin_he': '8He {autoindex}',
                            'rebin_fastn': 'Fast neutrons {autoindex}',
                            'rebin_alphan': 'C(alpha,n)O {autoindex}'
                            }
                        ),
                ibd_xsec = NestedDict(
                    bundle = dict(name='xsec_ibd', version='v02'),
                    order = 1,
                    ),
                oscprob = NestedDict(
                    bundle = dict(name='oscprob', version='v04', major='rdc', inactive=self.opts.oscprob=='matter'),
                    pdgyear = self.opts.pdgyear,
                    dm      = self.opts.dm
                    ),
                oscprob_matter = NestedDict(
                    bundle = dict(name='oscprob_matter', version='v01', major='rd', inactive=self.opts.oscprob=='vacuum',
                                  names=dict(oscprob='oscprob_matter')),
                    density = 2.6, # g/cm3
                    pdgyear = self.opts.pdgyear,
                    dm      = self.opts.dm
                    ),
                anuspec_hm = NestedDict(
                    bundle = dict(name='reactor_anu_spectra', version='v04', inactive=self.opts.flux!='huber-mueller'),
                    name = 'anuspec',
                    filename = ['data/reactor_anu_spectra/Huber/Huber_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat',
                                'data/reactor_anu_spectra/Mueller/Mueller_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat'],
                    free_params=False, # enable free spectral model
                    varmode='log',
                    varname='anue_weight_{index:02d}',
                    ns_name='spectral_weights',
                    debug = True,
                    edges = np.concatenate( ( np.arange( 1.8, 8.7, 0.025 ), [ 12.3 ] ) ),
                    ),
                anuspec_ill = NestedDict(
                    bundle = dict(name='reactor_anu_spectra', version='v04', inactive=self.opts.flux!='ill-vogel'),
                    name = 'anuspec',
                    filename = ['data/reactor_anu_spectra/ILL/ILL_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat',
                                'data/reactor_anu_spectra/Vogel/Vogel_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat'],
                    free_params=False, # enable free spectral model
                    varmode='log',
                    varname='anue_weight_{index:02d}',
                    ns_name='spectral_weights',
                    debug = True,
                    edges = np.concatenate( ( np.arange( 1.8, 8.7, 0.025 ), [ 12.3 ] ) ),
                    ),
                offeq_correction = NestedDict(
                    bundle = dict(name='reactor_offeq_spectra',
                                  version='v03', major='ir'),
                    offeq_data = 'data/reactor_anu_spectra/Mueller/offeq/mueller_offequilibrium_corr_{isotope}.dat',
                    ),
                geonu = NestedDict(
                    bundle = dict(name='geoneutrino_spectrum', version='v01'),
                    data   = 'data/data-common/geo-neutrino/2006-sanshiro/geoneutrino-luminosity_{isotope}_truncated.knt'
                ),
                eff = NestedDict(
                    bundle = dict(
                        name='parameters',
                        version='v01'),
                    parameter="eff",
                    label='Detection efficiency',
                    pars = uncertain(0.8, 'fixed')
                    ),
                global_norm = NestedDict(
                    bundle = dict(
                        name='parameters',
                        version='v01'),
                    parameter="global_norm",
                    label='Global normalization',
                    pars = uncertain(1, 'free'),
                    ),
                fission_fractions = NestedDict(
                    bundle = dict(name="parameters_yaml_v01", major = 'i'),
                    parameter = 'fission_fractions_nominal',
                    separate_uncertainty = "fission_fractions_scale",
                    label = 'Fission fraction of {isotope} in reactor {reactor}',
                    objectize=True,
                    data = 'data/data_juno/fission_fractions/2013.12.05_xubo.yaml'
                    ),
                snf_correction = NestedDict(
                    bundle = dict(name='reactor_snf_spectra', version='v04', major='r'),
                    snf_average_spectra = './data/data-common/snf/2004.12-kopeikin/kopeikin_0412.044_spent_fuel_spectrum_smooth.dat',
                    ),
                livetime = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "livetime",
                        label = 'Livetime of {detector} in seconds',
                        pars = uncertaindict(
                            [('AD1', (6*365*seconds_per_day, 'fixed'))],
                            ),
                        ),
                baselines = NestedDict(
                        bundle = dict(name='reactor_baselines', version='v01', major = 'rd'),
                        reactors  = 'near-equal' in self.opts.reactors \
                                     and 'data/juno_nominal/coordinates_reactors_equal.py' \
                                     or 'data/juno_nominal/coordinates_reactors.py',
                        detectors = 'data/juno_nominal/coordinates_det.py',
                        unit = 'km'
                        ),
                norm = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "norm",
                        label = 'Reactor power/detection efficiency correlated normalization',
                        pars = uncertain(1.0, (2**2+1**2)**0.5, 'percent')
                        ),
                thermal_power = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "thermal_power_nominal",
                        label = 'Thermal power of {reactor} in GWt',
                        pars = uncertaindict([
                            ('TS1',  4.6),
                            ('TS2',  4.6),
                            ('TS3',  4.6),
                            ('TS4',  4.6),
                            ('YJ1',  2.9),
                            ('YJ2',  2.9),
                            ('YJ3',  2.9),
                            ('YJ4',  2.9),
                            ('YJ5',  2.9),
                            ('YJ6',  2.9),
                            ('DYB', 17.4),
                            ('HZ',  17.4),
                            ],
                            uncertainty=0.8,
                            mode='percent'
                            ),
                        separate_uncertainty = 'thermal_power_scale'
                        ),
                target_protons = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "target_protons",
                        label = 'Number of protons in {detector}',
                        pars = uncertaindict(
                            [('AD1', (1.42e33, 'fixed'))],
                            ),
                        ),
                conversion_factor =  NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter='conversion_factor',
                        label='Conversion factor from GWt to MeV',
                        #taken from transformations/neutrino/ReactorNorm.cc
                        pars = uncertain(R.NeutrinoUnits.reactorPowerConversion, 'fixed'),
                        ),
                days_in_second =  NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter='days_in_second',
                        label='Number of days in a second',
                        pars = uncertain(1.0/(24.0*60.0*60.0), 'fixed'),
                        ),
                eper_fission =  NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = 'eper_fission_nominal',
                        label = 'Energy per fission for {isotope} in MeV',
                        pars = uncertaindict(
                            [
                              ('U235',  (201.92, 0.46)),
                              ('U238',  (205.52, 0.96)),
                              ('Pu239', (209.99, 0.60)),
                              ('Pu241', (213.60, 0.65))
                              ],
                            mode='absolute'
                            ),
                        separate_uncertainty = 'eper_fission_scale'
                        ),
                lsnl = NestedDict(
                        bundle = dict( name='energy_nonlinearity_birks_cherenkov', version='v01', major=''),
                        stopping_power='data/data_juno/energy_model/2019_birks_cherenkov_v01/stoppingpower.txt',
                        annihilation_electrons=dict(
                            file='data/data_juno/energy_model/2019_birks_cherenkov_v01/hgamma2e.root',
                            histogram='hgamma2e_1KeV',
                            scale=1.0/50000 # events simulated
                            ),
                        pars = uncertaindict(
                            [
                                ('birks.Kb0',               (1.0, 'fixed')),
                                ('birks.Kb1',           (15.2e-3, 0.1776)),
                                # ('birks.Kb2',           (0.0, 'fixed')),
                                ("cherenkov.E_0",         (0.165, 'fixed')),
                                ("cherenkov.p0",  ( -7.26624e+00, 'fixed')),
                                ("cherenkov.p1",   ( 1.72463e+01, 'fixed')),
                                ("cherenkov.p2",  ( -2.18044e+01, 'fixed')),
                                ("cherenkov.p3",   ( 1.44731e+01, 'fixed')),
                                ("cherenkov.p4",   ( 3.22121e-02, 'fixed')),
                                ("Npescint",            (1341.38, 0.0059)),
                                ("kC",                      (0.5, 0.4737)),
                                ("normalizationEnergy",   (11.99, 'fixed'))
                                ],
                            mode='relative'
                            ),
                        integration_order = 2,
                        correlations_pars = [ 'birks.Kb1', 'Npescint', 'kC' ],
                        correlations = [ 1.0,   0.94, -0.97,
                                         0.94,  1.0,  -0.985,
                                        -0.97, -0.985, 1.0   ],
                        fill_matrix=True,
                        labels = dict(
                            normalizationEnergy = 'Conservative normalization point at 12 MeV'
                            ),
                        ),
                shape_uncertainty = NestedDict(
                        unc = uncertain(1.0, 1.0, 'percent'),
                        nbins = 200 # number of bins, the uncertainty is defined to
                        ),
                snf_norm = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = 'snf_norm',
                        label='SNF norm',
                        pars = uncertain(1.0, 'fixed'),
                        ),
                reactor_active_norm = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = 'reactor_active_norm',
                        label='Reactor nu (active norm)',
                        pars = uncertain(1.0, 'fixed'),
                        ),
                #
                # Backgrounds
                #
                acc_spectrum_db = NestedDict(
                    bundle    = dict(name='root_histograms_v04', inactive=True),
                    filename  = 'data/data_juno/bkg/acc/2016_acc_dayabay_p15a/dayabay_acc_spectrum_p15a.root',
                    format    = 'accidentals',
                    name      = 'acc_spectrum',
                    label     = 'Accidentals|norm spectrum',
                    normalize = True
                    ),
                acc_spectrum = NestedDict(
                    bundle    = dict(name='root_histograms_v04'),
                    filename  = 'data/data_juno/bkg/acc/2019_acc_malyshkin/acc_bckg_FVcut.root',
                    format    = 'hAcc',
                    name      = 'acc_spectrum',
                    label     = 'Accidentals|norm spectrum',
                    normalize = slice(200,-1),
                    xscale    = 1.e-3,
                    ),
                fastn_spectrum=NestedDict(
                        bundle=dict(name='histogram_flat_v01'),
                        name='fastn_spectrum',
                        edges=edges,
                        label='Fast neutron|norm spectrum',
                        normalize=(0.7, 12.0),
                        ),
                li_spectrum=NestedDict(
                    bundle    = dict(name='root_histograms_v03'),
                    filename  = 'data/data_juno/bkg/lihe/2014_lihe_ochoa/toyli9spec_BCWmodel_v1_2400.root',
                    format    = 'h_eVisAllSmeared',
                    name      = 'li_spectrum',
                    label     = '9Li spectrum|norm',
                    normalize = True,
                    ),
                he_spectrum= NestedDict(
                    bundle    = dict(name='root_histograms_v03'),
                    filename  = 'data/data_juno/bkg/lihe/2014_lihe_ochoa/toyhe8spec_BCWmodel_v1_2400.root',
                    format    = 'h_eVisAllSmeared',
                    name      = 'he_spectrum',
                    label     = '8He spectrum|norm',
                    normalize = True,
                    ),
                alphan_spectrum = NestedDict(
                    bundle    = dict(name='root_histograms_v03'),
                    filename  = 'data/data_juno/bkg/alphan/2012_dayabay_alphan/P12B_alphan_2400.root',
                    format    = 'AD1',
                    name      = 'alphan_spectrum',
                    label     = 'C(alpha,n) spectrum|(norm)',
                    normalize = True,
                    ),
                lihe_fractions=NestedDict(
                        bundle = dict(name='var_fractions_v02'),
                        names = [ 'li', 'he' ],
                        format = 'frac_{component}',
                        fractions = uncertaindict(
                            li = ( 0.95, 0.05, 'relative' )
                            ),
                        ),
                    # bkg_spectra = NestedDict(
                    # bundle    = dict(name='root_histograms_v05'),
                    # filename  = 'data/data_juno/bkg/group/2020-05-JUNO-YB/JunoBkg_evis_2400.root',
                    # formats    = ['AccBkgHistogramAD',           'Li9BkgHistogramAD',   'FnBkgHistogramAD',       'AlphaNBkgHistogramAD',   'GeoNuHistogramAD'],
                    # names      = ['acc_spectrum',                'lihe_spectrum',       'fn_spectrum',            'alphan_spectrum',        'geonu_spectrum'],
                    # labels     = ['Accidentals|(norm spectrum)', '9Li|(norm spectrum)', 'Fast n|(norm spectrum)', 'AlphaN|(norm spectrum)', 'GeoNu combined|(norm spectrum)'],
                    # normalize = True,
                    # ),
                acc_rate = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = 'acc_rate',
                        label='Acc rate',
                        pars = uncertain(0.9, 1, 'percent'),
                        separate_uncertainty='acc_norm',
                        ),
                fastn_rate = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = 'fastn_rate',
                        label='Fast n rate',
                        pars = uncertain(0.1, 100, 'percent'),
                        separate_uncertainty='fastn_norm',
                        ),
                lihe_rate = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = 'lihe_rate',
                        label='9Li/8He rate',
                        pars = uncertain(1.6, 20, 'percent'),
                        separate_uncertainty='lihe_norm',
                        ),
                alphan_rate = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = 'alphan_rate',
                        label='C(alpha,n)O rate',
                        pars = uncertain(0.05, 50, 'percent'),
                        separate_uncertainty='alphan_norm',
                        ),
                )

        if 'eres' in self.opts.energy_model:
            bconf = self.opts.eres_b_relsigma and (self.opts.eres_b_relsigma,
                                                   'relative') or ('fixed', )
            self.cfg.eres = NestedDict(
                bundle=dict(name='detector_eres_normal',
                            version='v01',
                            major=''),
                # pars: sigma_e/e = sqrt( a^2 + b^2/E + c^2/E^2 ),
                parameter='eres',
                pars=uncertaindict([('a', (0.000, 'fixed')),
                                    ('b', (self.opts.eres_sigma, ) + bconf),
                                    ('c', (0.000, 'fixed'))]),
                expose_matrix=False)
        elif 'multieres' in self.opts.energy_model:
            self.cfg.subdetector_fraction = NestedDict(
                bundle=dict(name="parameters", version="v03"),
                parameter="subdetector_fraction",
                label='Subdetector fraction weight for {subdetector}',
                pars=uncertaindict(
                    [(subdet_name, (0.2, 0.04, 'relative'))
                     for subdet_name in self.subdetectors_names], ),
                covariance=
                'data/data_juno/energy_resolution/2019_subdetector_eres_n200_proper/subdetector5_cov.txt'
            )
            self.cfg.multieres = NestedDict(
                bundle=dict(name='detector_multieres_stats',
                            version='v01',
                            major='s'),
                # pars: sigma_e/e = sqrt(b^2/E),
                parameter='eres',
                relsigma=self.opts.eres_b_relsigma,
                nph=
                'data/data_juno/energy_resolution/2019_subdetector_eres_n200_proper/subdetector5_nph.txt',
                rescale_nph=self.opts.eres_npe,
                expose_matrix=False)

        if not 'lsnl' in self.opts.correlation:
            self.cfg.lsnl.correlations = None
            self.cfg.lsnl.correlations_pars = None
        if not 'subdetectors' in self.opts.correlation:
            self.cfg.subdetector_fraction.correlations = None

        self.cfg.eff.pars = uncertain(0.73, 'fixed')
        self.cfg.livetime.pars['AD1'] = uncertain(6 * 330 * seconds_per_day,
                                                  'fixed')
Ejemplo n.º 7
0
cfg = NestedDict(
    # Bundle name
    bundle=dict(
        name='energy_nonlinearity_db_root',
        version='v02',
        nidx=[('d', 'detector', ['D1']),
              ('l', 'lsnl_component',
               ['nominal', 'pull0', 'pull1', 'pull2', 'pull3'])],
        major='dl',
    ),
    # file to read
    filename='data/data_dayabay/tmp/detector_nl_consModel_450itr.root',
    # TGraph names. First curve will be used as nominal
    names=['nominal', 'pull0', 'pull1', 'pull2', 'pull3'],
    # The uncorrelated energy scale uncertainty type (absolute/relative)
    par=uncertain(1.0, 0.2, 'percent'),
    parname='escale',
    extrapolation_strategy='extrapolate',
    nonlin_range=(0.5, 12.),
    edges='evis_edges',
)


#
# Make input histogram
#
def singularities(values, edges):
    indices = N.digitize(values, edges) - 1
    phist = N.zeros(edges.size - 1)
    phist[indices] = 1.0
    return phist
Ejemplo n.º 8
0
    def init_configuration(self):
        if self.opts.eres_npe:
            self.opts.eres_sigma = self.opts.eres_npe**-0.5
        else:
            self.opts.eres_npe = self.opts.eres_sigma**-2
        print('Energy resolution at 1 MeV: {}% ({} pe)'.format(
            self.opts.eres_sigma * 100, self.opts.eres_npe))

        self.cfg = NestedDict(
                kinint2 = NestedDict(
                    bundle   = dict(name='integral_2d1d', version='v03', names=dict(integral='kinint2')),
                    variables = ('evis', 'ctheta'),
                    edges    = np.arange(0.0, 12.001, 0.01), #FIXME
                    #  edges    = np.linspace(0.0, 12.001, 601),
                    xorders   = 4,
                    yorder   = 5,
                    ),
                rebin = NestedDict(
                        bundle = dict(name='rebin', version='v03', major=''),
                        rounding = 3,
                        edges = np.concatenate( (
                                    [0.7],
                                    np.arange(1, 6.0, self.opts.estep),
                                    np.arange(6, 7.0, 0.1),
                                    [7.0, 7.5, 12.0]
                                )
                            ),
                        name = 'rebin',
                        label = 'Final histogram {detector}'
                        ),
                ibd_xsec = NestedDict(
                    bundle = dict(name='xsec_ibd', version='v02'),
                    order = 1,
                    ),
                oscprob = NestedDict(
                    bundle = dict(name='oscprob', version='v04', major='rdc', inactive=self.opts.oscprob=='matter'),
                    pdgyear = self.opts.pdgyear,
                    dm      = self.opts.dm
                    ),
                oscprob_matter = NestedDict(
                    bundle = dict(name='oscprob_matter', version='v01', major='rd', inactive=self.opts.oscprob=='vacuum',
                                  names=dict(oscprob='oscprob_matter')),
                    density = 2.6, # g/cm3
                    pdgyear = self.opts.pdgyear,
                    dm      = self.opts.dm
                    ),
                anuspec_hm = NestedDict(
                    bundle = dict(name='reactor_anu_spectra', version='v03', inactive=self.opts.flux!='huber-mueller'),
                    name = 'anuspec',
                    filename = ['data/reactor_anu_spectra/Huber/Huber_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat',
                        'data/reactor_anu_spectra/Mueller/Mueller_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat'],
                    # strategy = dict( underflow='constant', overflow='extrapolate' ),
                    edges = np.concatenate( ( np.arange( 1.8, 8.7, 0.025 ), [ 12.3 ] ) ),
                    ),
                anuspec_ill = NestedDict(
                    bundle = dict(name='reactor_anu_spectra', version='v03', inactive=self.opts.flux!='ill-vogel'),
                    name = 'anuspec',
                    filename = ['data/reactor_anu_spectra/ILL/ILL_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat',
                                'data/reactor_anu_spectra/Vogel/Vogel_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat'],
                    # strategy = dict( underflow='constant', overflow='extrapolate' ),
                    edges = np.concatenate( ( np.arange( 1.8, 8.7, 0.025 ), [ 12.3 ] ) ),
                    ),
                offeq_correction = NestedDict(
                    bundle = dict(name='reactor_offeq_spectra',
                                  version='v03', major='ir'),
                    offeq_data = 'data/reactor_anu_spectra/Mueller/offeq/mueller_offequilibrium_corr_{isotope}.dat',
                    ),
                eff = NestedDict(
                    bundle = dict(
                        name='parameters',
                        version='v01'),
                    parameter="eff",
                    label='Detection efficiency',
                    pars = uncertain(0.8, 'fixed')
                    ),
                global_norm = NestedDict(
                    bundle = dict(
                        name='parameters',
                        version='v01'),
                    parameter="global_norm",
                    label='Global normalization',
                    pars = uncertain(1, 'free'),
                    ),
                fission_fractions = NestedDict(
                    bundle = dict(name="parameters_yaml_v01", major = 'i'),
                    parameter = "fission_fractions",
                    label = 'Fission fraction of {isotope} in reactor {reactor}',
                    objectize=True,
                    data = 'data/data_juno/fission_fractions/2013.12.05_xubo.yaml'
                    ),
                livetime = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "livetime",
                        label = 'Livetime of {detector} in seconds',
                        pars = uncertaindict(
                            [('AD1', (6*365*seconds_per_day, 'fixed'))],
                            ),
                        ),
                baselines = NestedDict(
                        bundle = dict(name='reactor_baselines', version='v01', major = 'rd'),
                        reactors  = 'near-equal' in self.opts.reactors \
                                     and 'data/juno_nominal/coordinates_reactors_equal.py' \
                                     or 'data/juno_nominal/coordinates_reactors.py',
                        detectors = 'data/juno_nominal/coordinates_det.py',
                        unit = 'km'
                        ),
                norm = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "norm",
                        label = 'Reactor power/detection efficiency correlated normalization',
                        pars = uncertain(1.0, (2**2+1**2)**0.5, 'percent')
                        ),
                thermal_power = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "thermal_power",
                        label = 'Thermal power of {reactor} in GWt',
                        pars = uncertaindict([
                            ('TS1',  4.6),
                            ('TS2',  4.6),
                            ('TS3',  4.6),
                            ('TS4',  4.6),
                            ('YJ1',  2.9),
                            ('YJ2',  2.9),
                            ('YJ3',  2.9),
                            ('YJ4',  2.9),
                            ('YJ5',  2.9),
                            ('YJ6',  2.9),
                            ('DYB', 17.4),
                            ('HZ',  17.4),
                            ],
                            uncertainty=0.8,
                            mode='percent'
                            ),
                        ),
                target_protons = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "target_protons",
                        label = 'Number of protons in {detector}',
                        pars = uncertaindict(
                            [('AD1', (1.42e33, 'fixed'))],
                            ),
                        ),
                conversion_factor =  NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter='conversion_factor',
                        label='Conversion factor from GWt to MeV',
                        #taken from transformations/neutrino/ReactorNorm.cc
                        pars = uncertain(R.NeutrinoUnits.reactorPowerConversion, 'fixed'),
                        ),
                eper_fission =  NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "eper_fission",
                        label = 'Energy per fission for {isotope} in MeV',
                        pars = uncertaindict(
                            [
                              ('U235',  (201.92, 0.46)),
                              ('U238',  (205.52, 0.96)),
                              ('Pu239', (209.99, 0.60)),
                              ('Pu241', (213.60, 0.65))
                              ],
                            mode='absolute'
                            ),
                        ),
                lsnl = NestedDict(
                        bundle = dict( name='energy_nonlinearity_birks_cherenkov', version='v01', major=''),
                        stopping_power='data/data_juno/energy_model/2019_birks_cherenkov_v01/stoppingpower.txt',
                        annihilation_electrons=dict(
                            file='data/data_juno/energy_model/2019_birks_cherenkov_v01/hgamma2e.root',
                            histogram='hgamma2e_1KeV',
                            scale=1.0/50000 # events simulated
                            ),
                        pars = uncertaindict(
                            [
                                ('birks.Kb0',               (1.0, 'fixed')),
                                ('birks.Kb1',           (15.2e-3, 0.1776)),
                                # ('birks.Kb2',           (0.0, 'fixed')),
                                ("cherenkov.E_0",         (0.165, 'fixed')),
                                ("cherenkov.p0",  ( -7.26624e+00, 'fixed')),
                                ("cherenkov.p1",   ( 1.72463e+01, 'fixed')),
                                ("cherenkov.p2",  ( -2.18044e+01, 'fixed')),
                                ("cherenkov.p3",   ( 1.44731e+01, 'fixed')),
                                ("cherenkov.p4",   ( 3.22121e-02, 'fixed')),
                                ("Npescint",            (1341.38, 0.0059)),
                                ("kC",                      (0.5, 0.4737)),
                                ("normalizationEnergy",   (11.99, 'fixed'))
                                ],
                            mode='relative'
                            ),
                        integration_order = 2,
                        correlations_pars = [ 'birks.Kb1', 'Npescint', 'kC' ],
                        correlations = [ 1.0,   0.94, -0.97,
                                         0.94,  1.0,  -0.985,
                                        -0.97, -0.985, 1.0   ],
                        fill_matrix=True,
                        labels = dict(
                            normalizationEnergy = 'Conservative normalization point at 12 MeV'
                            ),
                        ),
                shape_uncertainty = NestedDict(
                        unc = uncertain(1.0, 1.0, 'percent'),
                        nbins = 200 # number of bins, the uncertainty is defined to
                        )
                )

        if 'eres' in self.opts.energy_model:
            bconf = self.opts.eres_b_relsigma and (self.opts.eres_b_relsigma,
                                                   'relative') or ('fixed', )
            self.cfg.eres = NestedDict(
                bundle=dict(name='detector_eres_normal',
                            version='v01',
                            major=''),
                # pars: sigma_e/e = sqrt( a^2 + b^2/E + c^2/E^2 ),
                parameter='eres',
                pars=uncertaindict([('a', (0.000, 'fixed')),
                                    ('b', (self.opts.eres_sigma, ) + bconf),
                                    ('c', (0.000, 'fixed'))]),
                expose_matrix=False)
        elif 'multieres' in self.opts.energy_model:
            if self.opts.subdetectors_number == 200:
                self.cfg.subdetector_fraction = NestedDict(
                    bundle=dict(name="parameters", version="v02"),
                    parameter="subdetector_fraction",
                    label='Subdetector fraction weight for {subdetector}',
                    pars=uncertaindict(
                        [(subdet_name, (1.0 / self.opts.subdetectors_number,
                                        0.04, 'relative'))
                         for subdet_name in self.subdetectors_names], ),
                    correlations=
                    'data/data_juno/energy_resolution/2019_subdetector_eres_n200_proper/corrmap_xuyu.txt'
                )
                self.cfg.multieres = NestedDict(
                    bundle=dict(name='detector_multieres_stats',
                                version='v01',
                                major='s'),
                    # pars: sigma_e/e = sqrt(b^2/E),
                    parameter='eres',
                    relsigma=self.opts.eres_b_relsigma,
                    nph=
                    'data/data_juno/energy_resolution/2019_subdetector_eres_n200_proper/subdetector200_nph.txt',
                    rescale_nph=self.opts.eres_npe,
                    expose_matrix=False)
            elif self.opts.subdetectors_number == 5:
                self.cfg.subdetector_fraction = NestedDict(
                    bundle=dict(name="parameters", version="v03"),
                    parameter="subdetector_fraction",
                    label='Subdetector fraction weight for {subdetector}',
                    pars=uncertaindict(
                        [(subdet_name, (1.0 / self.opts.subdetectors_number,
                                        0.04, 'relative'))
                         for subdet_name in self.subdetectors_names], ),
                    covariance=
                    'data/data_juno/energy_resolution/2019_subdetector_eres_n200_proper/subdetector5_cov.txt'
                )
                self.cfg.multieres = NestedDict(
                    bundle=dict(name='detector_multieres_stats',
                                version='v01',
                                major='s'),
                    # pars: sigma_e/e = sqrt(b^2/E),
                    parameter='eres',
                    relsigma=self.opts.eres_b_relsigma,
                    nph=
                    'data/data_juno/energy_resolution/2019_subdetector_eres_n200_proper/subdetector5_nph.txt',
                    rescale_nph=self.opts.eres_npe,
                    expose_matrix=False)
            else:
                assert False

        if not 'lsnl' in self.opts.correlation:
            self.cfg.lsnl.correlations = None
            self.cfg.lsnl.correlations_pars = None
        if not 'subdetectors' in self.opts.correlation:
            self.cfg.subdetector_fraction.correlations = None

        self.cfg.eff.pars = uncertain(0.73, 'fixed')
        self.cfg.livetime.pars['AD1'] = uncertain(6 * 330 * seconds_per_day,
                                                  'fixed')
Ejemplo n.º 9
0
            ('Pu241', 0.057)
        ] )

cfg.anu = NestedDict(
    bundle = 'reactor_anu_spectra_v01',
    isotopes = [ 'U5', 'U8', 'Pu9', 'Pu1' ],
    filename = ['data/reactor_anu_spectra/Huber/Huber_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat',
                'data/reactor_anu_spectra/Mueller/Mueller_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat'],
    strategy = dict( underflow='constant', overflow='extrapolate' ),
    edges = N.concatenate( ( N.arange( 1.8, 8.7, 0.5 ), [ 12.3 ] ) ),
)

cfg.snf = NestedDict(
        bundle='reactor_snf_spectra_v01',
        filename = 'data/reactor_anu_spectra/SNF/kopeikin_0412.044_spent_fuel_spectrum_smooth.dat',
        norm=uncertain( 1.0, 100, mode='percent' ),
        edges = N.concatenate( ( N.arange( 1.8, 8.7, 0.25 ), [ 12.3 ] ) )
        )

cfg.offeq = NestedDict(
        bundle='reactor_offeq_spectra_v01',
        skip=['U238'],
        filename = 'data/reactor_anu_spectra/Mueller/offeq/mueller_offequilibrium_corr_{isotope}.dat',
        norm=uncertain( 1.0, 30, mode='percent' ),
        edges = N.concatenate( ( N.arange( 1.8, 8.7, 0.25 ), [ 12.3 ] ) )
        )

"""Init inputs"""
points = N.linspace( 0.0, 12.0, 241 )
points_t = C.Points(points)
points_t.points.setLabel('E (integr)')
Ejemplo n.º 10
0
def build_and_plot(expr, obj, suffix):
    # Initialize the expression and indices
    a = Expression(expr, indices)

    # Dump the information
    print(a.expressions_raw)
    print(a.expressions)

    # Parse the expression
    a.parse()
    # The next step is needed to name all the intermediate variables.
    a.guessname(lib, save=True)
    # Dump the tree.
    a.tree.dump(True)

    cfg = NestedDict(
        kinint2=NestedDict(
            bundle='integral_2d1d_v01',
            variables=('evis', 'ctheta'),
            edges=N.linspace(0.0, 12.0, 241, dtype='d'),
            xorders=3,
            yorder=5,
            provides=['evis', 'ctheta', 'evis_edges'],
        ),
        ibd_xsec=NestedDict(bundle='xsec_ibd_v01',
                            order=1,
                            provides=['ibd_xsec', 'ee', 'enu', 'jacobian']),
        oscprob=NestedDict(bundle='oscprob_v01',
                           name='oscprob',
                           provides=['oscprob', 'pmns']),
        anuspec=NestedDict(
            bundle='reactor_anu_spectra_v02',
            name='anuspec',
            filename=[
                'data/reactor_anu_spectra/Huber/Huber_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat',
                'data/reactor_anu_spectra/Mueller/Mueller_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat'
            ],
            # strategy = dict( underflow='constant', overflow='extrapolate' ),
            edges=N.concatenate((N.arange(1.8, 8.7, 0.5), [12.3])),
        ),
        eff=NestedDict(
            bundle='efficiencies_v01',
            correlated=False,
            uncorrelated=True,
            norm=True,
            names=dict(norm='global_norm'),
            provides=['eff', 'effunc_corr', 'effunc_uncorr', 'global_norm'],
            efficiencies='data/dayabay/efficiency/P15A_efficiency.py'),
        livetime=NestedDict(
            bundle='dayabay_livetime_hdf_v01',
            file=
            'data/dayabay/data/P15A/dubna/dayabay_data_dubna_v15_bcw_adsimple.hdf5',
            provides=['livetime_daily', 'efflivetime_daily']),
        baselines=NestedDict(
            bundle='baselines_v01',
            reactors=
            'data/dayabay/reactor/coordinates/coordinates_docDB_9757.py',
            detectors='data/dayabay/ad/coordinates/coordinates_docDB_9757.py',
            provides=['baseline', 'baselineweight'],
            units="meters"),
        thermal_power=NestedDict(
            bundle='dayabay_reactor_burning_info_v01',
            reactor_info='data/dayabay/reactor/power/WeeklyAvg_P15A_v1.txt.npz',
            provides=['thermal_power', 'fission_fractions']),
        iav=NestedDict(
            bundle='detector_iav_db_root_v02',
            parname='OffdiagScale',
            scale=uncertain(1.0, 4, 'percent'),
            ndiag=1,
            filename='data/dayabay/tmp/detector_iavMatrix_P14A_LS.root',
            matrixname='iav_matrix'),
        eres=NestedDict(
            bundle='detector_eres_common3_v02',
            # pars: sigma_e/e = sqrt( a^2 + b^2/E + c^2/E^2 ),
            pars=uncertaindict([('Eres_a', 0.014764), ('Eres_b', 0.0869),
                                ('Eres_c', 0.0271)],
                               mode='percent',
                               uncertainty=30),
            provides=['eres', 'eres_matrix'],
            expose_matrix=True),
        lsnl=NestedDict(
            bundle='detector_nonlinearity_db_root_v02',
            names=['nominal', 'pull0', 'pull1', 'pull2', 'pull3'],
            filename='data/dayabay/tmp/detector_nl_consModel_450itr.root',
            parnames=dict(lsnl='lsnl_weight', escale='escale'),
            par=uncertain(1.0, 0.2, 'percent'),
            edges='evis_edges',
            provides=[
                'lsnl', 'lsnl_component', 'escale', 'lsnl_weight', 'lsnl_edges'
            ]),
        rebin=NestedDict(bundle='rebin_v02',
                         rounding=3,
                         edges=N.concatenate(([0.7], N.arange(1.2, 8.1,
                                                              0.2), [12.0]))))
    #
    # Put the expression into context
    context = ExpressionContext(cfg, ns=env.globalns)
    a.build(context)

    # # Print the list of outputs, stored for the expression
    # from gna.bindings import OutputDescriptor
    # env.globalns.materializeexpressions(True)
    # env.globalns.printparameters( labels=True )
    # print( 'outputs:' )
    # print( context.outputs )

    try:
        from gna.graphviz import GNADot

        obj = context.outputs[obj]
        if isinstance(obj, NestedDict):
            obj = obj.values()
        if len(expr) < 4:
            label = expr[0]
            if label == 'evis()':
                label = expr[1]
        else:
            label = ''
        graph = GNADot(obj, joints=False, label=label)
        name = args.dot.replace('.dot', '_' + suffix + '.dot')
        graph.write(name)
        print('Write output to:', name)
    except Exception as e:
        print('\033[31mFailed to plot dot\033[0m')
        raise
Ejemplo n.º 11
0
    def init_configuration(self):
        mode_yb = self.opts.mode == 'yb'
        self.cfg = NestedDict(
                kinint2 = NestedDict(
                    bundle   = dict(name='integral_2d1d', version='v03', names=dict(integral='kinint2'), inactive=mode_yb),
                    variables = ('evis', 'ctheta'),
                    edges    = np.arange(0.6, 12.001, 0.01),
                    #  edges    = np.linspace(0.0, 12.001, 601),
                    xorders   = 4,
                    yorder   = 5,
                    ),
                rebin = NestedDict(
                        bundle = dict(name='rebin', version='v03', major='', inactive=mode_yb),
                        rounding = 3,
                        edges = np.concatenate(( [0.7], np.arange(1, 8.001, 0.02), [9.0, 12.0] )),
                        name = 'rebin',
                        label = 'Final histogram {detector}'
                        ),
                kinint2_enu = NestedDict(
                    bundle   = dict(name='integral_2d1d', version='v03', names=dict(integral='kinint2'), inactive=not mode_yb),
                    variables = ('enu_in', 'ctheta'),
                    edges     = np.linspace(1.8, 8.0, 601),
                    xorders   = 4,
                    yorder   = 5,
                    ),
                rebin_yb = NestedDict(
                        bundle = dict(name='rebin', version='v03', major='', inactive=not mode_yb),
                        rounding = 3,
                        edges = np.linspace(1.8, 8.0, 201),
                        name = 'rebin',
                        label = 'Final histogram {detector}'
                        ),
                ibd_xsec = NestedDict(
                    bundle = dict(name='xsec_ibd', version='v02'),
                    order = 1,
                    ),
                oscprob = NestedDict(
                    bundle = dict(name='oscprob', version='v03', major='rdc'),
                    pdgyear = self.opts.pdgyear
                    ),
                anuspec = NestedDict(
                    bundle = dict(name='reactor_anu_spectra', version='v03'),
                    name = 'anuspec',
                    filename = ['data/reactor_anu_spectra/Huber/Huber_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat',
                        'data/reactor_anu_spectra/Mueller/Mueller_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat'],
                    # strategy = dict( underflow='constant', overflow='extrapolate' ),
                    edges = np.concatenate( ( np.arange( 1.8, 8.7, 0.025 ), [ 12.3 ] ) ),
                    ),
                anuspec_1 = NestedDict(
                    bundle = dict(name='reactor_anu_spectra', version='v03'),
                    name = 'anuspec',
                    filename = ['data/reactor_anu_spectra/Huber/Huber_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat',
                                'data/reactor_anu_spectra/Mueller/Mueller_smooth_extrap_{isotope}_13MeV0.01MeVbin.dat'],
                    # strategy = dict( underflow='constant', overflow='extrapolate' ),
                    edges = np.concatenate( ( np.arange( 1.8, 8.7, 0.05 ), [ 12.3 ] ) ),
                    ),
                eff = NestedDict(
                    bundle = dict(
                        name='parameters',
                        version='v01'),
                    parameter="eff",
                    label='Detection efficiency',
                    pars = uncertain(0.8, 'fixed')
                    ),
                global_norm = NestedDict(
                    bundle = dict(
                        name='parameters',
                        version='v01'),
                    parameter="global_norm",
                    label='Global normalization',
                    pars = uncertain(1, 'free'),
                    ),
                fission_fractions = NestedDict(
                    bundle = dict(name="parameters",
                        version = "v01",
                        major = 'i'
                        ),
                    parameter = "fission_fractions",
                    label = 'Fission fraction of {isotope} in reactor {reactor}',
                    objectize=True,
                    pars = uncertaindict([
                        ('U235',  0.60),
                        ('Pu239', 0.27),
                        ('U238',  0.07),
                        ('Pu241', 0.06)
                        ],
                        # uncertainty = 30.0,
                        # mode = 'percent',
                        mode = 'fixed',
                        ),
                    ),
                livetime = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "livetime",
                        label = 'Livetime of {detector} in seconds',
                        pars = uncertaindict(
                            [('AD1', (6*365*seconds_per_day, 'fixed'))],
                            ),
                        ),
                baselines = NestedDict(
                        bundle = dict(name='reactor_baselines', version='v01', major = 'rd'),
                        reactors  = 'near-equal' in self.opts.reactors \
                                     and 'data/juno_nominal/coordinates_reactors_equal.py' \
                                     or 'data/juno_nominal/coordinates_reactors.py',
                        detectors = 'data/juno_nominal/coordinates_det.py',
                        unit = 'km'
                        ),
                norm = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "norm",
                        label = 'Reactor power/detection efficiency correlated normalization',
                        pars = uncertain(1.0, (2**2+1**2)**0.5, 'percent')
                        ),
                thermal_power = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "thermal_power",
                        label = 'Thermal power of {reactor} in GWt',
                        pars = uncertaindict([
                            ('TS1',  4.6),
                            ('TS2',  4.6),
                            ('TS3',  4.6),
                            ('TS4',  4.6),
                            ('YJ1',  2.9),
                            ('YJ2',  2.9),
                            ('YJ3',  2.9),
                            ('YJ4',  2.9),
                            ('YJ5',  2.9),
                            ('YJ6',  2.9),
                            ('DYB', 17.4),
                            ('HZ',  17.4),
                            ],
                            uncertainty=0.8,
                            mode='percent'
                            ),
                        ),
                target_protons = NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "target_protons",
                        label = 'Number of protons in {detector}',
                        pars = uncertaindict(
                            [('AD1', (1.42e33, 'fixed'))],
                            ),
                        ),
                conversion_factor =  NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter='conversion_factor',
                        label='Conversion factor from GWt to MeV',
                        #taken from transformations/neutrino/ReactorNorm.cc
                        pars = uncertain(R.NeutrinoUnits.reactorPowerConversion, 'fixed'),
                        ),
                eper_fission =  NestedDict(
                        bundle = dict(name="parameters", version = "v01"),
                        parameter = "eper_fission",
                        label = 'Energy per fission for {isotope} in MeV',
                        pars = uncertaindict(
                            [
                              # ('U235',  (201.92, 0.46)),
                              # ('U238',  (205.52, 0.96)),
                              # ('Pu239', (209.99, 0.60)),
                              # ('Pu241', (213.60, 0.65))
                              ('U235',  201.92),
                              ('U238',  205.52),
                              ('Pu239', 209.99),
                              ('Pu241', 213.60)
                              ],
                            # mode='absolute'
                            mode='fixed'
                            ),
                        ),
                lsnl = NestedDict(
                        bundle = dict( name='energy_nonlinearity_birks_cherenkov', version='v01', major=''),
                        stopping_power='data/data_juno/energy_model/2019_birks_cherenkov_v01/stoppingpower.txt',
                        annihilation_electrons=dict(
                            file='data/data_juno/energy_model/2019_birks_cherenkov_v01/hgamma2e.root',
                            histogram='hgamma2e_1KeV',
                            scale=1.0/50000 # events simulated
                            ),
                        pars = uncertaindict(
                            [
                                ('birks.Kb0',               (1.0, 'fixed')),
                                ('birks.Kb1',           (15.2e-3, 0.1776)),
                                # ('birks.Kb2',           (0.0, 'fixed')),
                                ("cherenkov.E_0",         (0.165, 'fixed')),
                                ("cherenkov.p0",  ( -7.26624e+00, 'fixed')),
                                ("cherenkov.p1",   ( 1.72463e+01, 'fixed')),
                                ("cherenkov.p2",  ( -2.18044e+01, 'fixed')),
                                ("cherenkov.p3",   ( 1.44731e+01, 'fixed')),
                                ("cherenkov.p4",   ( 3.22121e-02, 'fixed')),
                                ("Npescint",            (1341.38, 0.0059)),
                                ("kC",                      (0.5, 0.4737)),
                                ("normalizationEnergy",   (12.0, 'fixed'))
                                ],
                            mode='relative'
                            ),
                        integration_order = 2,
                        correlations_pars = [ 'birks.Kb1', 'Npescint', 'kC' ],
                        correlations = [ 1.0,   0.94, -0.97,
                                         0.94,  1.0,  -0.985,
                                        -0.97, -0.985, 1.0   ],
                        fill_matrix=True,
                        labels = dict(
                            normalizationEnergy = 'Conservative normalization point at 12 MeV'
                            ),
                        ),
                eres = NestedDict(
                        bundle = dict(name='detector_eres_normal', version='v01', major='', inactive='multieres' in self.opts.energy_model),
                        # pars: sigma_e/e = sqrt( a^2 + b^2/E + c^2/E^2 ),
                        parameter = 'eres',
                        pars = uncertaindict([
                            ('a', (0.000, 'fixed')),
                            ('b', (0.03, 'fixed')),
                            ('c', (0.000, 'fixed'))
                            ]),
                        expose_matrix = False
                        ),
                subdetector_fraction = NestedDict(
                        bundle = dict(name="parameters", version = "v02"),
                        parameter = "subdetector_fraction",
                        label = 'Subdetector fraction weight for {subdetector}',
                        pars = uncertaindict(
                            [(subdet_name, (1.0/self.subdetectors_number, 0.04, 'relative')) for subdet_name in self.subdetectors_names],
                            ),
                        correlations = 'data/data_juno/energy_resolution/2019_subdetector_eres_n200/corrmap_xuyu.txt'
                        ),
                multieres = NestedDict(
                        bundle = dict(name='detector_multieres_stats', version='v01', major='s', inactive='multieres' not in self.opts.energy_model),
                        # pars: sigma_e/e = sqrt(b^2/E),
                        parameter = 'eres',
                        nph = 'data/data_juno/energy_resolution/2019_subdetector_eres_n200/subdetector200_nph.txt',
                        expose_matrix = False
                        ),
                shape_uncertainty = NestedDict(
                        unc = uncertain(1.0, 1.0, 'percent'),
                        nbins = 200 # number of bins, the uncertainty is defined to
                        )
                )

        if mode_yb:
            from physlib import PhysicsConstants
            pc = PhysicsConstants(2016)
            shift = pc.DeltaNP - pc.ElectronMass
            histshift = R.HistEdgesLinear(1.0, -shift)
            self.cfg.enuToEvis0 = NestedDict(
                bundle=dict(name='predefined', version='v01'),
                name='enuToEvis0',
                inputs=(histshift.histedges.hist_in, ),
                outputs=histshift.histedges.hist,
                object=histshift)
        if not 'lsnl' in self.opts.correlation:
            self.cfg.lsnl.correlations = None
            self.cfg.lsnl.correlations_pars = None
        if not 'subdetectors' in self.opts.correlation:
            self.cfg.subdetector_fraction.correlations = None

        if self.opts.parameters in ['yb', 'yb-noosc']:
            self.cfg.eff.pars = uncertain(0.73, 'fixed')
            self.cfg.livetime.pars['AD1'] = uncertain(
                6 * 330 * seconds_per_day, 'fixed')
Ejemplo n.º 12
0
cfg = NestedDict()
cfg.detectors = [ 'AD11', 'AD12', 'AD21', 'AD22', 'AD31', 'AD32', 'AD33', 'AD34' ]
cfg.groups    = OrderedDict( [
                ( 'EH1', ('AD11', 'AD12') ),
                ( 'EH2', ('AD21', 'AD22') ),
                ( 'EH3', ('AD31', 'AD32', 'AD33', 'AD34') ),
                ] )

bkg = cfg.bkg = NestedDict([
    ('list', [ 'acc', 'lihe', 'fastn', 'amc', 'alphan' ]),
    # ('bundle', 'bundle_sum_v01')
    ])

bkg.acc = NestedDict(
        bundle = 'bkg_weighted_hist_v01'
        norm = uncertain( 1.0, 1.0, 'percent' ),
        spectra = NestedDict(
            bundle = 'root_histograms_v01',
            file   = 'data/dayabay/data_spectra/P15A_IHEP_data/data_IHEP_P15A_All.root',
            format = 'accidental_pred_{}',
            variants = OrderedDict([
                ( 'AD11', 'EH1_AD1' ), ( 'AD12', 'EH1_AD2' ),
                ( 'AD21', 'EH2_AD3' ), ( 'AD22', 'EH2_AD8' ),
                ( 'AD31', 'EH3_AD4' ), ( 'AD32', 'EH3_AD5' ), ( 'AD33', 'EH3_AD6' ), ( 'AD34', 'EH3_AD7' ),
                ])
            )
        )

cfg.lihe = NestedDict(
        rates = NestedDict(
            docdb = [10956],