def __init__(self, n_cpu, **kwargs):
self.queue = JoinableQueue()
self.log_queue = Queue()
self.n_tasks = Value('i', 0)
kwargs["n_tasks"] = self.n_tasks
self.processes = [
Process(target=self.run_trial, kwargs=kwargs)
for _ in range(int(n_cpu))
]
self.mh = MinimisationHandler.create(kwargs["mh_dict"])
for season in self.mh.seasons.keys():
inj = self.mh.get_injector(season)
inj.calculate_n_exp()
self.mh_dict = kwargs["mh_dict"]
self.scales = []
handler = logging.StreamHandler()
handler.setFormatter(
logging.Formatter(
"%(levelname)s: %(asctime)s - %(process)s - %(message)s"))
# ql gets records from the queue and sends them to the handler
ql = QueueListener(self.log_queue, handler)
ql.start()
for p in self.processes:
p.start()
def do_asimov_scale_estimation(self):
"""estimate the injection scale using Asimov estimation"""
logger.info("doing asimov estimation")
mh = MinimisationHandler.create(self.mh_dict)
scale_estimate = mh.guess_scale()
logger.debug(f"estimated scale: {scale_estimate}")
self.disc_guess = scale_estimate
self.sens_guess = 0.3 * self.disc_guess
"name": name,
"mh_name": "fixed_weights",
"datasets": [IC86_1_dict],
"catalogue": ps_catalogue_name(sin_dec),
"llh_dict": llh_dict,
"inj kwargs": inj_dict,
"n_trials": 20,
"n_steps": 15,
"scale": scale,
}
pkl_file = make_analysis_pickle(mh_dict)
# rd.submit_to_cluster(pkl_file, n_jobs=150)
#
mh = MinimisationHandler.create(mh_dict)
# mh.iterate_run(n_steps=2, n_trials=20, scale=scale)
mh.run(10, scale=float(scale))
config_mh.append(mh_dict)
res_dict[key] = config_mh
all_res[gamma] = res_dict
rd.wait_for_cluster()
for (gamma, res_dict) in all_res.items():
gamma_name = basename + str(gamma) + "/"
try:
os.makedirs(analysis_path)
except OSError:
pass
pkl_file = analysis_path + "dict.pkl"
with open(pkl_file, "wb") as f:
Pickle.dump(mh_dict, f)
start = datetime.datetime.now()
n_trials = 10
mh = MinimisationHandler(mh_dict)
mh.run(n_trials=n_trials, scale=0.0)
mh.clear()
end = datetime.datetime.now()
diff = (end - start).total_seconds() / n_trials
times.append(diff)
savepath = plot_output_dir(name_root) + "scale.pdf"
try:
os.makedirs(os.path.dirname(savepath))
except OSError:
pass
plt.figure()
os.makedirs(os.path.dirname(ts_path))
except OSError:
pass
if os.path.isfile(ts_path):
with open(ts_path, "r") as f:
print("Loading ts_array")
ts_array = Pickle.load(f)
else:
print("Empty TS array")
ts_array = []
# Creates a Minimisation Handler using the dictionary, and runs the trials
mh_pl = MinimisationHandler.create(mh_dict_pl)
mh_tm = MinimisationHandler.create(mh_dict_tm)
n_trials = 100
for i in range(n_trials):
seed = random.randint(0, 999999)
mh_pl.set_random_seed(seed)
res_pl = mh_pl.run_trial(scale=1.0)
mh_tm.set_random_seed(seed)
res_tm = mh_tm.run_trial(scale=1.0)
ts = res_tm["TS"] - res_pl["TS"]
print(i, seed, res_tm, res_pl, ts)
ts_array.append(ts)
def __init__(self, rh_dict, do_sens=True, do_disc=True, bias_error="std"):
self.sources = load_catalogue(rh_dict["catalogue"])
self.name = rh_dict["name"]
self.mh_name = rh_dict["mh_name"]
self.scale = rh_dict["scale"]
self.results = dict()
self.pickle_output_dir = name_pickle_output_dir(self.name)
self.plot_dir = plot_output_dir(self.name)
self.merged_dir = os.path.join(self.pickle_output_dir, "merged")
self.allow_extrapolation = rh_dict.get(
"allow_extrapolated_sensitivity", True)
# Checks if the code should search for flares. By default, this is
# not done.
# self.flare = self.mh_name == "flare"
# if self.flare:
# self.make_plots = self.flare_plots
# else:
self.make_plots = self.noflare_plots
self.bias_error = bias_error
# Checks whether negative n_s is fit or not
#
# try:
# self.negative_n_s = llh_kwargs["Fit Negative n_s?"]
# except KeyError:
# self.negative_n_s = False
#
# try:
# self.fit_weights = llh_kwargs["Fit Weights?"]
# except KeyError:
# self.fit_weights = False
# Sets default Chi2 distribution to fit to background trials
#
# if self.fit_weights:
# self.ts_type = "Fit Weights"
# elif self.flare:
# self.ts_type = "Flare"
# elif self.negative_n_s:
# self.ts_type = "Negative n_s"
# else:
self.ts_type = get_ts_fit_type(rh_dict)
# print "negative_ns", self.negative_n_s
p0, bounds, names = MinimisationHandler.find_parameter_info(rh_dict)
# p0, bounds, names = fit_setup(llh_kwargs, self.sources, self.flare)
self.param_names = names
self.bounds = bounds
self.p0 = p0
# if cleanup:
# self.clean_merged_data()
# this will have the TS threshold values as keys and a tuple containing
# (injection scale, relative overfluctuations, error on overfluctuations)
# as values
self.overfluctuations = dict()
self.sensitivity = np.nan
self.sensitivity_err = np.nan
self.bkg_median = np.nan
self.frac_over = np.nan
self.disc_potential = np.nan
self.disc_err = np.nan
self.disc_potential_25 = np.nan
self.disc_ts_threshold = np.nan
self.extrapolated_sens = False
self.extrapolated_disc = False
self.flux_to_ns = np.nan
# if self.show_inj:
self.inj = self.load_injection_values()
self._inj_dict = rh_dict["inj_dict"]
self._dataset = rh_dict["dataset"]
# else:
# self.inj = None
try:
self.merge_pickle_data()
except FileNotFoundError:
logger.warning("No files found at {0}".format(
self.pickle_output_dir))
try:
self.find_ns_scale()
except ValueError as e:
logger.warning(
"RuntimeError for ns scale factor: \n {0}".format(e))
except IndexError as e:
logger.warning(
f"IndexError for ns scale factor. Only background trials?")
self.plot_bias()
if do_sens:
try:
self.find_sensitivity()
except ValueError as e:
logger.warning(
"RuntimeError for discovery potential: \n {0}".format(e))
if do_disc:
try:
self.find_disc_potential()
except RuntimeError as e:
logger.warning(
"RuntimeError for discovery potential: \n {0}".format(e))
except TypeError as e:
logger.warning(
"TypeError for discovery potential: \n {0}".format(e))
except ValueError as e:
logger.warning(
"TypeError for discovery potential: \n {0}".format(e))
