def build(self): model_edges_t = C.Points( self.model_edges, ns=self.namespace ) model_edges_t.points.setLabel('Spectra interpolation edges') self.context.objects['edges'] = model_edges_t self.shared.reactor_anu_edges = model_edges_t.single() if self.cfg.free_params: with self.reac_ns: tmp = C.VarArray(self.variables, ns=self.reac_ns, labels='Spec pars:\nlog(n_i)') if self.cfg.varmode == 'log': self.context.objects['npar_log'] = tmp self.free_weights = R.Exp(ns=self.reac_ns) self.free_weights.exp.points( tmp ) self.free_weights.exp.setLabel('n_i') else: tmp.vararray.setLabel('n_i') self.free_weights = tmp self.interp_expo = interp_expo = R.InterpExpo(ns=self.reac_ns) sampler = interp_expo.transformations.front() model_edges_t >> sampler.inputs.edges sampler_input = sampler.inputs.points interp_expo_t = interp_expo.transformations.back() for i, it in enumerate(self.nidx_major): isotope, = it.current_values() spectrum_raw_t = C.Points( self.spectra[isotope], ns=self.reac_ns ) spectrum_raw_t.points.setLabel('%s spectrum, original'%isotope) self.context.objects[('spectrum_raw', isotope)] = spectrum_raw_t if self.cfg.free_params: spectrum_t = C.Product(ns=self.reac_ns) spectrum_t.multiply( spectrum_raw_t ) spectrum_t.multiply( self.free_weights.single() ) spectrum_t.product.setLabel('%s spectrum, corrected'%isotope) else: spectrum_t = spectrum_raw_t if i>0: interp_expo_t = interp_expo.add_transformation() model_edges_t >> interp_expo_t.inputs.x interp_output = interp_expo.add_input(spectrum_t) interp_input = interp_expo_t.inputs.newx if i>0: self.set_input(self.cfg.name, it, interp_input, argument_number=0) else: self.set_input(self.cfg.name, it, (sampler_input, interp_input), argument_number=0) interp_expo_t.setLabel('%s spectrum, interpolated'%isotope) """Store data""" self.set_output(self.cfg.name, it, interp_output) self.context.objects[('spectrum', isotope)] = spectrum_t
def test_01(): arrays = ([[1.5, 1.5, 1.5], [1.5, 1.5, 1.5]], [[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]) objects = [C.Points(a) for a in arrays] prod = C.Product(outputs=[p.single() for p in objects]) prod.product.switchFunction('gpu') prod.print() print(prod.single().data()) entry = R.OpenHandle(prod.product).getEntry() entry.functionargs.gpu.dump()
def check_product(arrays): print('Test ', len(arrays), ':', sep='') for array in arrays: print(array) print() truth=1.0 for a in arrays: if a.size==1: truth*=a[0] else: truth*=a print('Truth:\n', truth, end='\n\n') points = [C.Points(array) for array in arrays] prod = C.Product(outputs=[p.points.points for p in points]) calc = prod.single().data() print('Result', calc, calc.dtype, end='\n\n') assert (calc==truth).all()
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())
#!/usr/bin/env python from load import ROOT as R import gna.constructors as C import numpy as np # Create several points instances n, n1, n2 = 12, 3, 4 points_list = [C.Points(np.arange(i, i + n).reshape(n1, n2)) for i in range(5)] # Create product instances tproduct_constructor = C.Product([p.points.points for p in points_list]) tproduct_multiply = C.Product() tproduct_add_input = C.Product() for i, p in enumerate(points_list): out = p.points.points tproduct_multiply.multiply(out) an_input = tproduct_add_input.add_input('input_{:02d}'.format(i)) an_input(out) # Print the structure of Product object print('Product, configured via constructor') tproduct_constructor.print() print() # Print the structure of Product object print('Product, configured via multiply() method') tproduct_multiply.print() print()
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 define_variables(self): daq = self.namespace('daq') daq.reqparameter('first_day', central=self.info['first_day'], fixed=True, label='First DAQ day start: %s' % self.info['str_first_day']) daq.reqparameter('last_day', central=self.info['last_day'], fixed=True, label='Last DAQ day end: %s' % self.info['str_last_day']) daq.reqparameter('ndays', central=self.info['days'], fixed=True, label='Total number of days') self.reqparameter('seconds_in_day', None, central=24. * 60. * 60., fixed=True, label='Number of seconds in day') self.reqparameter('days_in_second', None, central=1.0 / (24. * 60. * 60.), fixed=True, label='Number of days in a second') data_lt = 0.0 for it in self.nidx: ad, = it.current_values() data = self.data.get(ad, None) if data is None: raise self.exception('Failed to retrieve data for %s from %s' % (ad, self.cfg.file)) data_lt = data['livetime'] + data_lt if self.cfg.get('scale_to_ext_livetime'): scale = self.cfg.scale_to_ext_livetime livetime_external = scale[ad] scaled = data['livetime'] * (livetime_external / data['livetime'].sum()) livetime = C.Points( scaled, labels=it.current_format('Livetime\n{autoindex}')) else: livetime = C.Points( data['livetime'], labels=it.current_format('Livetime\n{autoindex}')) eff = C.Points( data['eff'], labels=it.current_format('Efficiency (mu*mult)\n{autoindex}')) efflivetime = C.Product( [livetime, eff], labels=it.current_format('Livetime (eff)\n{autoindex}')) self.context.objects[('livetime', ad)] = livetime self.context.objects[('eff', ad)] = eff self.context.objects[('efflivetime', ad)] = efflivetime self.set_output('eff_daily', it, eff.single()) self.set_output('livetime_daily', it, livetime.single()) self.set_output('efflivetime_daily', it, efflivetime.single()) ndays_daq = (data_lt > 0.0).sum() daq.reqparameter('ndays_daq', central=ndays_daq, fixed=True, sigma=0.01, label='Total number of DAQ days (exclude no DAQ)')
# Define two sets of scales to correct each value of y0 pars1 = env.globalns('pars1') pars2 = env.globalns('pars2') for ns in (pars1, pars2): for i in range(nsegments+1): ns.defparameter('par_{:02d}'.format(i), central=1, free=True, label='Scale for x_{}={}'.format(i, edges_data[i])) # Initialize transformations for scales with pars1: varray1=C.VarArray(list(pars1.keys()), labels='Scales 1\n(p1)') with pars2: varray2=C.VarArray(list(pars2.keys()), labels='Scales 2\n(p2)') # Make two products: y0 scaled by varray1 and varray2 y1 = C.Product([varray1.single(), y0.single()], labels='p1*y') y2 = C.Product([varray2.single(), y0.single()], labels='p2*y') # Initialize interpolator manual = False labels=('Segment index\n(fine x in coarse x)', 'Interpolator') if manual: # Bind transformations manually interpolator = R.InterpExpo(labels=labels) edges >> (interpolator.insegment.edges, interpolator.interp.x) points >> (interpolator.insegment.points, interpolator.interp.newx) interpolator.insegment.insegment >> interpolator.interp.insegment interpolator.insegment.widths >> interpolator.interp.widths y1 >> interpolator.interp.y y2 >> interpolator.add_input()
#!/usr/bin/env python from tutorial import tutorial_image_name, savegraph from load import ROOT as R import gna.constructors as C import numpy as np n, n1, n2 = 12, 3, 4 points_list = [C.Points(np.arange(i, i + n).reshape(n1, n2)) for i in range(5)] tfactor = C.Points(np.linspace(0.5, 2.0, n).reshape(n1, n2)) tsum = C.Sum([p.points.points for p in points_list]) tprod = C.Product([tsum.sum.sum, tfactor.points.points]) for i, p in enumerate(points_list): p.points.setLabel('Sum input:\nP{:d}'.format(i)) tfactor.points.setLabel('Scale S') tsum.sum.setLabel('Sum of matrices') tprod.product.setLabel('Scaled matrix') tprod.product.product.setLabel('result') tsum.print() print() tprod.print() print() print('The sum:') print(tsum.transformations[0].outputs[0].data()) print()