def randomize_free_params(self, random_state=None):
if random_state is None:
random = np.random
else:
random = get_random_state(random_state)
n = len(self.params.free)
rand = random.rand(n)
self._set_rescaled_free_params(rand)
def unfold_mc(self):
logging.debug('Unfolding monte carlo sample')
regularisation = int(self.params['regularisation'].m)
unfold_bg = self.params['unfold_bg'].value
unfold_eff = self.params['unfold_eff'].value
unfold_unweighted = self.params['unfold_unweighted'].value
# Split data into signal, bg and all (signal+bg)
signal_data, bg_data, all_data = self.split_data()
# Load generator level data for signal
gen_data = self.load_gen_data()
# Return true map is regularisation is set to 0
if regularisation == 0:
logging.info('Returning baseline MapSet')
true = roounfold._histogram(events=gen_data,
binning=self.true_binning,
weights=gen_data['pisa_weight'],
errors=True,
name=self.output_str)
return MapSet([true])
# Get the inversed efficiency histogram
if not unfold_eff:
inv_eff = self.get_inv_eff(signal_data, gen_data)
# Set the reco and true data based on cfg file settings
reco_norm_data = None
true_norm_data = None
data = signal_data
if unfold_bg:
reco_norm_data = all_data
if unfold_eff:
true_norm_data = gen_data
if reco_norm_data is None:
reco_norm_data = signal_data
if true_norm_data is None:
true_norm_data = signal_data
if unfold_unweighted:
ones = np.ones(reco_norm_data['pisa_weight'].shape)
reco_norm_data['pisa_weight'] = ones
true_norm_data['pisa_weight'] = ones
data['pisa_weight'] = ones
# Create response object
response = self.create_response(reco_norm_data, true_norm_data, data)
# Make pseduodata
all_hist = self._histogram(events=all_data,
binning=self.reco_binning,
weights=all_data['pisa_weight'],
errors=False,
name='all',
tex=r'\rm{all}')
seed = int(self.params['stat_fluctuations'].m)
if seed != 0:
if self.random_state is None or seed != self.seed:
self.seed = seed
self.random_state = get_random_state(seed)
all_hist = all_hist.fluctuate('poisson', self.random_state)
else:
self.seed = None
self.random_state = None
all_hist.set_poisson_errors()
# Background Subtraction
if unfold_bg:
reco = all_hist
else:
bg_hist = self.get_bg_hist(bg_data)
reco = all_hist - bg_hist
reco.name = 'reco_signal'
reco.tex = r'\rm{reco_signal}'
r_flat = roounfold._flatten_to_1d(reco)
r_th1d = convert_to_th1d(r_flat, errors=True)
# Find optimum value for regularisation parameter
if self.params['optimize_reg'].value:
chisq = None
for r_idx in range(regularisation):
unfold = RooUnfoldBayes(response, r_th1d, r_idx + 1)
unfold.SetVerbose(0)
idx_chisq = unfold.Chi2(self.t_th1d, 1)
if chisq is None:
pass
elif idx_chisq > chisq:
regularisation = r_idx
break
chisq = idx_chisq
# Unfold
unfold = RooUnfoldBayes(response, r_th1d, regularisation)
unfold.SetVerbose(0)
unfolded_flat = unfold.Hreco(1)
unfold_map = unflatten_thist(in_th1d=unfolded_flat,
binning=self.true_binning,
name=self.output_str,
errors=True)
# Efficiency correction
if not unfold_eff:
unfold_map *= inv_eff
del r_th1d
del unfold
logging.info('Unfolded reco sum {0}'.format(
np.sum(unp.nominal_values(unfold_map.hist))))
return unfold_map
