def build(self): self.inputs = {} self.outputs = {} self.points = {} self.interp = {} for k, v in self.data.items(): x = C.Points(v[0], labels='{} geo-nu X0'.format(k)) y = C.Points(v[1], labels='{} geo-nu Y0'.format(k)) interp = C.InterpLinear( labels=('{} X insegment'.format(k), '{} geo-neutrino spectra'.format(k))) interp.set_underflow_strategy( R.GNA.Interpolation.Strategy.Constant) interp.set_overflow_strategy(R.GNA.Interpolation.Strategy.Constant) interp.set_fill_value(0.0) interp.setXY(x, y) self.points[k] = (x, y) self.interp[k] = interp for idx in self.nidx.iterate(): for k in self.data.keys(): interp = self.interp[k] self.set_input('geonu_spectrum_{}'.format(k), idx, (interp.insegment.points, interp.interp.newx), argument_number=0) self.set_output('geonu_spectrum_{}'.format(k), idx, interp.interp.interp)
def build(self): for idx in self.nidx: reac, = idx.current_values() name = "snf_correction" + idx.current_format() try: _snf_energy, _snf_spectra = list( map(C.Points, self.snf_raw_data[reac])) except KeyError: # U238 doesn't have offequilibrium correction so just pass 1. _snf_energy, _snf_spectra = list( map(C.Points, self.snf_raw_data['average'])) _snf_energy.points.setLabel( "Original energies for SNF spectrum of {}".format(reac)) snf_spectra = C.InterpLinear( labels='Correction for spectra in {}'.format(reac)) snf_spectra.set_overflow_strategy( R.GNA.Interpolation.Strategy.Constant) snf_spectra.set_underflow_strategy( R.GNA.Interpolation.Strategy.Constant) insegment = snf_spectra.transformations.front() insegment.setLabel("Segments") interpolator_trans = snf_spectra.transformations.back() interpolator_trans.setLabel( "Interpolated SNF correction for {}".format(reac)) passthrough = C.Identity( labels="Nominal spectra for {}".format(reac)) _snf_energy >> (insegment.edges, interpolator_trans.x) _snf_spectra >> interpolator_trans.y self.set_input('snf_correction', idx, (insegment.points, interpolator_trans.newx), argument_number=0) self.set_input('snf_correction', idx, (passthrough.single_input()), argument_number=1) snap = C.Snapshot( passthrough.single(), labels='Snapshot of nominal spectra for SNF in {}'.format( reac)) product = C.Product( outputs=[snap.single(), interpolator_trans.single()], labels='Product of nominal spectrum to SNF correction in {}'. format(reac)) par_name = "snf_scale" self.reqparameter(par_name, idx, central=1., relsigma=1, labels="SNF norm for reactor {0}".format(reac)) outputs = [product.single()] weights = ['.'.join((par_name, idx.current_format()))] with self.namespace: final_sum = C.WeightedSum( weights, outputs, labels='SNF spectrum from {0} reactor'.format(reac)) self.context.objects[name] = final_sum self.set_output("snf_correction", idx, final_sum.single())
def build(self): self.objects = NestedDict() data = self.load_data() # Correlated part of the energy nonlinearity factor # a weighted sum of input curves for i, itl in enumerate(self.component_idx.iterate()): name, = itl.current_values() if not name in data: raise self._exception( 'The nonlinearity curve {} is not provided'.format(name)) try: x, y = data[name] except: raise Exception( 'Unable to get x,y for nonlinearity {}'.format(name)) Y = C.Points(y * x) if i: label = itl.current_format('NL correction {autoindex}') else: label = itl.current_format('NL nominal ({autoindex})') X = C.Points(x) X.points.setLabel(label + ' X') self.set_output('lsnl_x', None, X.single()) self.objects[('curves', name, 'X')] = X Y.points.setLabel(label + ' Y') self.set_output('lsnl_component_y', itl, Y.single()) self.objects[('curves', name, 'Y')] = Y # # Create direct and inverse interpolators # interp_direct = C.InterpLinear(labels=('NL InSeg direct', 'NL interp direct')) interp_inverse = C.InterpLinear(labels=('NL InSeg inverse', 'NL interp inverse')) self.objects['interp_direct'] = interp_direct self.objects['interp_inverse'] = interp_inverse # # Interp_interpolator(xcoarse, ycoarse, newx) # x, y -> interp_direct -> interp_direct(bin edges) # y, x -> interp_inverse -> interp_direct(bin edges) self.set_input('lsnl_interpolator', None, (interp_direct.insegment.edges, interp_direct.interp.x, interp_inverse.interp.y), argument_number=0) self.set_input('lsnl_interpolator', None, (interp_direct.interp.y, interp_inverse.insegment.edges, interp_inverse.interp.x), argument_number=1) self.set_input( 'lsnl_interpolator', None, (interp_direct.insegment.points, interp_direct.interp.newx, interp_inverse.insegment.points, interp_inverse.interp.newx), argument_number=2) self.set_output('lsnl_direct', None, interp_direct.interp.interp) self.set_output('lsnl_inverse', None, interp_inverse.interp.interp) expose_matrix = self.cfg.get('expose_matrix', False) with self.namespace: for i, itd in enumerate(self.detector_idx.iterate()): """Finally, original bin edges multiplied by the correction factor""" """Construct the nonlinearity calss""" nonlin = R.HistNonlinearityB( expose_matrix, labels=itd.current_format('NL matrix {autoindex}')) try: nonlin.set_range(*self.cfg.nonlin_range) except KeyError: pass self.objects[('nonlinearity', ) + itd.current_values()] = nonlin self.set_input('lsnl_edges', itd, nonlin.matrix.Edges, argument_number=0) interp_direct.interp.interp >> nonlin.matrix.EdgesModified interp_inverse.interp.interp >> nonlin.matrix.BackwardProjection self.set_output('lsnl_matrix', itd, nonlin.matrix.FakeMatrix) trans = nonlin.smear for j, itother in enumerate(self.nidx_minor.iterate()): it = itd + itother if j: trans = nonlin.add_transformation() nonlin.add_input() trans.setLabel(it.current_format('NL {autoindex}')) self.set_input('lsnl', it, trans.Ntrue, argument_number=0) self.set_output('lsnl', it, trans.Nrec)
def build(self): for idx in self.nidx.iterate(): if 'isotope' in idx.names()[0]: iso, reac = idx.current_values() else: reac, iso = idx.current_values() name = "offeq_correction." + idx.current_format() try: _offeq_energy, _offeq_spectra = list( map(C.Points, self.offeq_raw_spectra[iso])) _offeq_energy.points.setLabel( "Original energies for offeq spectrum of {}".format(iso)) except KeyError: # U238 doesn't have offequilibrium correction so just pass 1. if iso != 'U238': raise ones = C.FillLike( 1., labels='Offeq correction to {0} spectrum in {1} reactor'. format(iso, reac)) self.context.objects[name] = ones self.set_input('offeq_correction', idx, ones.single_input(), argument_number=0) self.set_output("offeq_correction", idx, ones.single()) continue offeq_spectra = C.InterpLinear( labels='Correction for {} spectra'.format(iso)) offeq_spectra.set_overflow_strategy( R.GNA.Interpolation.Strategy.Constant) offeq_spectra.set_underflow_strategy( R.GNA.Interpolation.Strategy.Constant) insegment = offeq_spectra.transformations.front() insegment.setLabel("Segments") interpolator_trans = offeq_spectra.transformations.back() interpolator_trans.setLabel( "Interpolated spectral correction for {}".format(iso)) ones = C.FillLike(1., labels="Nominal spectra for {}".format(iso)) _offeq_energy >> (insegment.edges, interpolator_trans.x) _offeq_spectra >> interpolator_trans.y self.set_input('offeq_correction', idx, (insegment.points, interpolator_trans.newx, ones.single_input()), argument_number=0) par_name = "offeq_scale" self.reqparameter( par_name, idx, central=1., relsigma=0.3, labels="Offequilibrium norm for reactor {1} and iso " "{0}".format(iso, reac)) self.reqparameter("dummy_scale", idx, central=1, fixed=True, labels="Dummy weight for reactor {1} and iso " "{0} for offeq correction".format(iso, reac)) outputs = [ones.single(), interpolator_trans.single()] weights = [ '.'.join(("dummy_scale", idx.current_format())), '.'.join( (par_name, idx.current_format())) ] with self.namespace: final_sum = C.WeightedSum(weights, outputs, labels='Offeq correction to ' '{0} spectrum in {1} reactor'.format( iso, reac)) self.context.objects[name] = final_sum self.set_output("offeq_correction", idx, final_sum.single())
def build(self): self.objects = NestedDict() data, gradients = self.load_data() # Correlated part of the energy nonlinearity factor # a weighted sum of input curves for i, itl in enumerate(self.component_idx.iterate()): name, = itl.current_values() if not name in data: raise self._exception( 'The nonlinearity curve {} is not provided'.format(name)) try: x, y = data[name] except: raise Exception( 'Unable to get x,y for nonlinearity {}'.format(name)) Y = C.Points(y) Grad = C.Points(gradients[name]) if i: label = itl.current_format('NL correction {autoindex}') else: label = itl.current_format('NL nominal ({autoindex})') X = C.Points(x) X.points.setLabel(label + ' X') self.set_output('lsnl_x', None, X.single()) self.objects[('curves', name, 'X')] = X Y.points.setLabel(label + ' Y') Grad.points.setLabel(label + ' gradient') self.set_output('lsnl_component_y', itl, Y.single()) self.set_output('lsnl_component_grad', itl, Grad.single()) self.objects[('curves', name, 'Y')] = Y self.objects[('curves', name, 'Grad')] = Grad # # Create direct and inverse interpolators # interp_direct = C.InterpLinear(labels=('NL InSeg direct', 'NL interp direct')) interp_inverse = C.InterpLinear(labels=('NL InSeg inverse', 'NL interp inverse')) self.objects['interp_direct'] = interp_direct self.objects['interp_inverse'] = interp_inverse interp_evis = C.InterpLinear(labels=('NL InSeg Evis(Eq)', 'Evis(Eq)')) self.objects['interp_evis'] = interp_evis interp_deq_devis = C.InterpLinear(labels=('NL InSeg dEq/dEvis)', 'dEq/dEvis')) self.objects['interp_deq_devis'] = interp_deq_devis # Interp_interpolators # interp_evis acts similarly to interp_invers, but expects different interpolation points # # x, y -> interp_direct : interp_direct(bin edges) # y, x -> interp_inverse : interp_direct(bin edges) # y, x -> interp_evis : interp_evis(integration points of Eq) # x, dy/dx -> interp_grad : interp_grad(Evis(integration points of Eq)) # # Arguments: Evis, Eq, E edges, E integration points # Distribution: # Interpolator Xorig Yorig Xnew # interp_direct Evis Eq E edges # interp_inverse Eq Evis E edges # interp_evis Eq Evis E integration points # interp_grad Evis dEq/dEvis interp_evis: Evis(Eq=E integration points) # arg0 = (interp_direct.insegment.edges, interp_direct.interp.x) arg0 = arg0 + (interp_inverse.interp.y, ) arg0 = arg0 + (interp_evis.interp.y, ) arg0 = arg0 + (interp_deq_devis.insegment.edges, interp_deq_devis.interp.x) arg1 = (interp_direct.interp.y, ) arg1 = arg1 + (interp_inverse.insegment.edges, interp_inverse.interp.x) arg1 = arg1 + (interp_evis.insegment.edges, interp_evis.interp.x) arg2 = (interp_direct.insegment.points, interp_direct.interp.newx) arg2 = arg2 + (interp_inverse.insegment.points, interp_inverse.interp.newx) arg3 = (interp_evis.insegment.points, interp_evis.interp.newx) self.set_input('lsnl_interpolator', None, arg0, argument_number=0) self.set_input('lsnl_interpolator', None, arg1, argument_number=1) self.set_input('lsnl_interpolator', None, arg2, argument_number=2) self.set_input('lsnl_interpolator', None, arg3, argument_number=3) arg0 = interp_deq_devis.interp.y self.set_input('lsnl_interpolator_grad', None, arg0, argument_number=0) self.set_output('lsnl_direct', None, interp_direct.interp.interp) self.set_output('lsnl_inverse', None, interp_inverse.interp.interp) self.set_output('lsnl_evis', None, interp_evis.interp.interp) self.set_output('lsnl_interpolator_grad', None, interp_deq_devis.interp.interp) interp_evis.interp.interp >> (interp_deq_devis.insegment.points, interp_deq_devis.interp.newx) expose_matrix = self.cfg.get('expose_matrix', False) for i, itd in enumerate(self.detector_idx.iterate()): """Finally, original bin edges multiplied by the correction factor""" """Construct the nonlinearity calss""" with self.namespace: nonlin = R.HistNonlinearityB( expose_matrix, labels=itd.current_format('NL matrix {autoindex}')) try: nonlin.set_range(*self.cfg.nonlin_range) except KeyError: pass self.objects[('nonlinearity', ) + itd.current_values()] = nonlin self.set_input('lsnl_edges', itd, nonlin.matrix.Edges, argument_number=0) interp_direct.interp.interp >> nonlin.matrix.EdgesModified interp_inverse.interp.interp >> nonlin.matrix.BackwardProjection self.set_output('lsnl_matrix', itd, nonlin.matrix.FakeMatrix) trans = nonlin.smear for j, itother in enumerate(self.nidx_minor.iterate()): it = itd + itother if j: trans = nonlin.add_transformation() nonlin.add_input() trans.setLabel(it.current_format('NL {autoindex}')) self.set_input('lsnl', it, trans.Ntrue, argument_number=0) self.set_output('lsnl', it, trans.Nrec)
def build(self): for idx in self.nidx.iterate(): if 'isotope' in idx.names()[0]: iso, reac = idx.current_values() else: reac, iso = idx.current_values() name = "offeq_correction." + idx.current_format() try: _offeq_energy, _offeq_spectra = list(map(C.Points, self.offeq_raw_spectra[iso])) _offeq_energy.points.setLabel("Original energies for offeq spectrum of {}".format(iso)) except KeyError: # U238 doesn't have offequilibrium correction so just pass 1. if iso != 'U238': raise passthrough = C.Identity(labels='Nominal {0} spectrum in {1} reactor'.format(iso, reac)) self.context.objects[name] = passthrough dummy = C.Identity() #just to serve 1 input self.set_input('offeq_correction', idx, dummy.single_input(), argument_number=0) self.set_input('offeq_correction', idx, passthrough.single_input(), argument_number=1) self.set_output("offeq_correction", idx, passthrough.single()) continue offeq_spectra = C.InterpLinear(labels='Correction for {} spectra'.format(iso)) offeq_spectra.set_overflow_strategy(R.GNA.Interpolation.Strategy.Constant) offeq_spectra.set_underflow_strategy(R.GNA.Interpolation.Strategy.Constant) insegment = offeq_spectra.transformations.front() insegment.setLabel("Offequilibrium segments") interpolator_trans = offeq_spectra.transformations.back() interpolator_trans.setLabel("Interpolated spectral correction for {}".format(iso)) passthrough = C.Identity(labels="Nominal {0} spectrum in {1} reactor".format(iso, reac)) _offeq_energy >> (insegment.edges, interpolator_trans.x) _offeq_spectra >> interpolator_trans.y # Enu self.set_input('offeq_correction', idx, (insegment.points, interpolator_trans.newx), argument_number=0) # Anue spectra self.set_input('offeq_correction', idx, ( passthrough.single_input()), argument_number=1) par_name = "offeq_scale" self.reqparameter(par_name, idx, central=1., relsigma=0.3, labels="Offequilibrium norm for reactor {1} and iso " "{0}".format(iso, reac)) self.reqparameter("dummy_scale", idx, central=1, fixed=True, labels="Dummy weight for reactor {1} and iso " "{0} for offeq correction".format(iso, reac)) snap = C.Snapshot(passthrough.single(), labels='Snapshot of {} spectra in reac {}'.format(iso, reac)) prod = C.Product(labels='Product of initial {} spectra and ' 'offequilibrium corr in {} reactor'.format(iso, reac)) prod.multiply(interpolator_trans.single()) prod.multiply(snap.single()) outputs = [passthrough.single(), prod.single()] weights = ['.'.join(("dummy_scale", idx.current_format())), '.'.join((par_name, idx.current_format()))] with self.namespace: final_sum = C.WeightedSum(weights, outputs, labels='Corrected to offequilibrium ' '{0} spectrum in {1} reactor'.format(iso, reac)) self.context.objects[name] = final_sum self.set_output("offeq_correction", idx, final_sum.single())
def build(self): with entryContext(subgraph='LSNL'): self.init_data() # # Initialize bin edges # self.histoffset = C.HistEdgesOffset( self.doubleme, labels='Offset/threshold bin edges (Evis, Te+)') histedges = self.histoffset.histedges # Declare open input self.set_input('evis_edges_hist', None, histedges.hist_in, argument_number=0) histedges.points.setLabel('Evis (full range)') histedges.points_truncated.setLabel('Evis (truncated)') histedges.points_threshold.setLabel('Evis (threshold)') histedges.points_offset.setLabel('Te+') histedges.hist_truncated.setLabel('Hist Evis (truncated)') histedges.hist_threshold.setLabel('Hist Evis (threshold)') histedges.hist_offset.setLabel('Hist Te+') # # Birk's model integration # birks_e_input, birks_quenching_input = self.stopping_power[ 'e'], self.stopping_power['dedx'] self.birks_e_p, self.birks_quenching_p = C.Points( birks_e_input, labels='Te (input)'), C.Points(birks_quenching_input, labels='Stopping power (dE/dx)') birksns = self.namespace('birks') with birksns: self.birks_integrand_raw = C.PolyRatio( [], list(sorted(birksns.storage.keys())), labels="Birk's integrand") self.birks_quenching_p >> self.birks_integrand_raw.polyratio.points self.doubleemass_point = C.Points([-self.doubleme], labels='2me offset') self.integrator_ekin = C.IntegratorGL( self.histoffset.histedges.hist_offset, self.cfg.integration_order, labels=('Te sampler (GL)', "Birk's integrator (GL)")) self.birks_integrand_interpolator = C.InterpLogx( self.birks_e_p, self.integrator_ekin.points.x, labels=("Birk's InSegment", "Birk's interpolator")) self.birks_integrand_interpolated = self.birks_integrand_interpolator.add_input( self.birks_integrand_raw.polyratio.ratio) self.birks_integral = self.integrator_ekin.add_input( self.birks_integrand_interpolated) self.birks_accumulator = C.PartialSum(0., labels="Birk's Evis|[MeV]") self.birks_integral >> self.birks_accumulator.reduction # # Cherenkov model # with self.namespace('cherenkov'): self.cherenkov = C.Cherenkov_Borexino(labels='Npe Cherenkov') self.histoffset.histedges.points_offset >> self.cherenkov.cherenkov # # Electron energy model # with self.namespace: self.electron_model = C.WeightedSum( ['kC', 'Npescint'], [ self.cherenkov.cherenkov.ch_npe, self.birks_accumulator.reduction.out ], labels='Npe: electron responce') # # 2 511 keV gamma model # self.annihilation_electrons_centers = C.Points( self.annihilation_electrons_centers_input, labels='Annihilation gamma E centers') self.annihilation_electrons_p = C.Points( self.annihilation_electrons_p_input, labels='Annihilation gamma weights') self.view_lowe = C.ViewHistBased( self.histoffset.histedges.hist_offset, 0.0, self.annihilation_electrons_edges_input[-1], labels=('Low E indices', 'Low E view')) self.ekin_edges_lowe = self.view_lowe.add_input( self.histoffset.histedges.points_offset) self.electron_model_lowe = self.view_lowe.add_input( self.electron_model.single()) self.ekin_edges_lowe.setLabel('Te+ edges (low Te view)') self.electron_model_lowe.setLabel( 'Npe: electron responce (low Te view)') self.electron_model_lowe_interpolator = C.InterpLinear( self.ekin_edges_lowe, self.annihilation_electrons_centers, labels=('Annihilation E InSegment', 'Annihilation gamma interpolator')) self.electron_model_lowe_interpolated = self.electron_model_lowe_interpolator.add_input( self.electron_model_lowe) with self.namespace: self.npe_positron_offset = C.Convolution( 'ngamma', labels='e+e- annihilation Evis [MeV]') self.electron_model_lowe_interpolated >> self.npe_positron_offset.normconvolution.fcn self.annihilation_electrons_p >> self.npe_positron_offset.normconvolution.weights # # Total positron model # self.positron_model = C.SumBroadcast( outputs=[ self.electron_model.sum.sum, self.npe_positron_offset.normconvolution.result ], labels='Npe: positron responce') self.positron_model_scaled = C.FixedPointScale( self.histoffset.histedges.points_truncated, self.namespace['normalizationEnergy'], labels=('Fixed point index', 'Positron energy model|Evis, MeV')) self.positron_model_scaled = self.positron_model_scaled.add_input( self.positron_model.sum.outputs[0]) self.positron_model_scaled_full_view = C.ViewRear( -1.0, labels='Positron Energy nonlinearity|full range') self.positron_model_scaled_full_view.determineOffset( self.histoffset.histedges.hist, self.histoffset.histedges.hist_truncated, True) self.histoffset.histedges.points >> self.positron_model_scaled_full_view.view.original self.positron_model_scaled >> self.positron_model_scaled_full_view.view.rear self.positron_model_scaled_full = self.positron_model_scaled_full_view.view.result # # Relative positron model # self.positron_model_relative = C.Ratio( self.positron_model_scaled, self.histoffset.histedges.points_truncated, labels='Positron energy nonlinearity') self.positron_model_relative_full_view = C.ViewRear( 0.0, labels='Positron Energy nonlinearity|full range') self.positron_model_relative_full_view.determineOffset( self.histoffset.histedges.hist, self.histoffset.histedges.hist_truncated, True) self.histoffset.histedges.points >> self.positron_model_relative_full_view.view.original self.positron_model_relative >> self.positron_model_relative_full_view.view.rear self.positron_model_relative_full = self.positron_model_relative_full_view.view.result # # Hist Smear # self.pm_histsmear = C.HistNonlinearity( self.cfg.get('fill_matrix', False), labels=('Nonlinearity matrix', 'Nonlinearity smearing')) self.pm_histsmear.set_range(-0.5, 20.0) self.positron_model_scaled_full >> self.pm_histsmear.matrix.EdgesModified self.histoffset.histedges.hist >> self.pm_histsmear.matrix.Edges trans = self.pm_histsmear.transformations.back() for i, it in enumerate(self.nidx.iterate()): # if i: # trans = self.pm_histsmear.add_transformation() inp = self.pm_histsmear.add_input() trans.setLabel( it.current_format('Nonlinearity smearing {autoindex}')) self.set_input('lsnl', it, inp, argument_number=0) self.set_output('lsnl', it, trans.outputs.back())