def get_gradients(data_tag, param, template_maker, fiducial_params,
grid_settings, store_dir):
"""
Use the template maker to create all the templates needed to obtain the gradients.
"""
logging.info("Working on parameter %s."%param)
steps = get_steps(param, grid_settings, fiducial_params)
pmaps = {}
# Generate one template for each value of the parameter in question and store in pmaps
for param_value in steps:
# Make the template corresponding to the current value of the parameter
with Timer() as t:
maps = template_maker.get_template(
get_values(dict(fiducial_params,**{param:dict(fiducial_params[param],
**{'value': param_value})})))
tprofile.info("==> elapsed time for template: %s sec"%t.secs)
pmaps[param_value] = maps
# Store the maps used to calculate partial derivatives
if store_dir != tempfile.gettempdir():
logging.info("Writing maps for parameter %s to %s"%(param,store_dir))
to_json(pmaps, os.path.join(store_dir,param+"_"+data_tag+".json"))
gradient_map = get_derivative_map(pmaps,fiducial_params[param],degree=2)
return gradient_map
def get_hierarchy_gradients(data_tag, fiducial_maps, fiducial_params,
grid_settings, store_dir):
"""
Use the hierarchy interpolation between the two fiducial maps to obtain the
gradients.
"""
logging.info("Working on parameter hierarchy.")
steps = get_steps('hierarchy', grid_settings, fiducial_params)
hmap = {step:{'trck':{},'cscd':{}} for step in steps}
for h in steps:
for channel in ['trck','cscd']:
# Superpose bin counts
hmap[h][channel]['map'] = fiducial_maps['NMH'][channel]['map']*h + fiducial_maps['IMH'][channel]['map']*(1.-h)
# Obtain binning from one of the maps, since identical by construction (cf. FisherAnalysis)
hmap[h][channel]['ebins'] = fiducial_maps['NMH'][channel]['ebins']
hmap[h][channel]['czbins'] = fiducial_maps['NMH'][channel]['czbins']
# TODO: give hmap the same structure as pmaps?
# Get_derivative_map works even if 'params' and 'ebins','czbins' not in 'data'
# Store the maps used to calculate partial derivatives
if store_dir != tempfile.gettempdir():
logging.info("Writing maps for parameter 'hierarchy' to %s"%store_dir)
to_json(hmap,os.path.join(store_dir,"hierarchy_"+data_tag+".json"))
gradient_map = get_derivative_map(hmap, fiducial_params['hierarchy'],degree=2)
return gradient_map
def assemble_interpolated_fits(fit_directory, output_file):
"""After all of the fits on the cluster are done, assemble the results to one JSON.
The JSON produced by this function is what `load_interpolated_hypersurfaces`
expects.
"""
assert os.path.isdir(fit_directory), "fit directory does not exist"
metadata = from_json(os.path.join(fit_directory, "metadata.json"))
combined_data = collections.OrderedDict()
combined_data["interpolation_param_spec"] = metadata["interpolation_param_spec"]
hs_fits = []
grid_shape = tuple(metadata["grid_shape"])
for job_idx, grid_idx in enumerate(np.ndindex(grid_shape)):
gridpoint_json = os.path.join(fit_directory, f"gridpoint_{job_idx:06d}.json.bz2")
logging.info(f"Reading {gridpoint_json}")
gridpoint_data = from_json(gridpoint_json)
assert job_idx == gridpoint_data["job_idx"]
assert np.all(grid_idx == gridpoint_data["grid_idx"])
# TODO: Offer to run incomplete fits locally
assert gridpoint_data["fit_successful"], f"job no. {job_idx} not finished"
hs_fits.append(collections.OrderedDict(
param_values=gridpoint_data["param_values"],
hs_fit=gridpoint_data["hs_fit"]
))
combined_data["hs_fits"] = hs_fits
to_json(combined_data, output_file)
def saveFile(self, filename):
"""
Write Fisher matrix to json file
"""
dict_to_write = {}
dict_to_write['matrix'] = self.matrix
dict_to_write['parameters'] = self.parameters
dict_to_write['best_fits'] = self.best_fits
dict_to_write['labels'] = self.labels
dict_to_write['priors'] = self.priors
to_json(dict_to_write, filename)
def to_file(obj, fname, fmt=None, overwrite=True, warn=True, **kwargs):
"""Dispatch correct file writer based on fmt (if specified) or guess
based on file name's extension"""
if fmt is None:
rootname, ext = os.path.splitext(fname)
ext = ext.replace('.', '').lower()
else:
rootname = fname
ext = fmt.lower()
if ext in ZIP_EXTS or ext in XOR_EXTS:
rootname, inner_ext = os.path.splitext(rootname)
inner_ext = inner_ext.replace('.', '').lower()
ext = inner_ext
if ext in jsons.JSON_EXTS:
return jsons.to_json(obj,
fname,
overwrite=overwrite,
warn=warn,
**kwargs)
elif ext in hdf.HDF5_EXTS:
return hdf.to_hdf(obj, fname, overwrite=overwrite, warn=warn, **kwargs)
elif ext in PKL_EXTS:
return to_pickle(obj, fname, overwrite=overwrite, warn=warn, **kwargs)
elif ext in TXT_EXTS:
if kwargs:
raise ValueError('Following additional keyword arguments not'
' accepted when writing to text file: %s' %
kwargs.keys())
return to_txt(obj, fname)
else:
errmsg = 'Unrecognized file type/extension: ' + ext
log.logging.error(errmsg)
raise TypeError(errmsg)
def to_json(self, filename, **kwargs):
"""Serialize the state to a JSON file that can be instantiated as a new
object later.
Parameters
----------
filename : str
Filename; must be either a relative or absolute path (*not
interpreted as a PISA resource specification*)
**kwargs
Further keyword args are sent to `pisa.utils.jsons.to_json()`
See Also
--------
from_json : Intantiate new object from the file written by this method
pisa.utils.jsons.to_json
"""
jsons.to_json(self.serializable_state, filename=filename, **kwargs)
def get_gradients(data_tag, param, template_maker, fiducial_params,
grid_settings, store_dir):
"""
Use the template maker to create all the templates needed to obtain the gradients.
"""
logging.info("Working on parameter %s." % param)
steps = get_steps(param, grid_settings, fiducial_params)
pmaps = {}
# Generate one template for each value of the parameter in question and store in pmaps
for param_value in steps:
# Make the template corresponding to the current value of the parameter
with Timer() as t:
maps = template_maker.get_template(
get_values(
dict(
fiducial_params, **{
param:
dict(fiducial_params[param],
**{'value': param_value})
})))
tprofile.info("==> elapsed time for template: %s sec" % t.secs)
pmaps[param_value] = maps
# Store the maps used to calculate partial derivatives
if store_dir != tempfile.gettempdir():
logging.info("Writing maps for parameter %s to %s" %
(param, store_dir))
to_json(pmaps, os.path.join(store_dir, param + "_" + data_tag + ".json"))
gradient_map = get_derivative_map(pmaps, fiducial_params[param], degree=2)
return gradient_map
def get_hierarchy_gradients(data_tag, fiducial_maps, fiducial_params,
grid_settings, store_dir):
"""
Use the hierarchy interpolation between the two fiducial maps to obtain the
gradients.
"""
logging.info("Working on parameter hierarchy.")
steps = get_steps('hierarchy', grid_settings, fiducial_params)
hmap = {step: {'trck': {}, 'cscd': {}} for step in steps}
for h in steps:
for channel in ['trck', 'cscd']:
# Superpose bin counts
hmap[h][channel]['map'] = fiducial_maps['NMH'][channel][
'map'] * h + fiducial_maps['IMH'][channel]['map'] * (1. - h)
# Obtain binning from one of the maps, since identical by construction (cf. FisherAnalysis)
hmap[h][channel]['ebins'] = fiducial_maps['NMH'][channel]['ebins']
hmap[h][channel]['czbins'] = fiducial_maps['NMH'][channel][
'czbins']
# TODO: give hmap the same structure as pmaps?
# Get_derivative_map works even if 'params' and 'ebins','czbins' not in 'data'
# Store the maps used to calculate partial derivatives
if store_dir != tempfile.gettempdir():
logging.info("Writing maps for parameter 'hierarchy' to %s" %
store_dir)
to_json(hmap, os.path.join(store_dir, "hierarchy_" + data_tag + ".json"))
gradient_map = get_derivative_map(hmap,
fiducial_params['hierarchy'],
degree=2)
return gradient_map
def to_file(obj, fname, fmt=None):
"""Dispatch correct file writer based on fmt (if specified) or guess
based on file name's extension"""
if fmt is None:
base, ext = os.path.splitext(fname)
ext = ext.replace('.', '').lower()
else:
ext = fmt.lower()
if ext in JSON_EXTS:
return jsons.to_json(obj, fname)
elif ext in HDF5_EXTS:
return hdf.to_hdf(obj, fname)
elif ext in PKL_EXTS:
return cPickle.dump(obj, file(fname, 'wb'))
else:
errmsg = 'Unrecognized file type/extension: ' + ext
logging.error(errmsg)
raise TypeError(errmsg)
def to_file(obj, fname, fmt=None):
"""Dispatch correct file writer based on fmt (if specified) or guess
based on file name's extension"""
if fmt is None:
base, ext = os.path.splitext(fname)
ext = ext.replace('.', '').lower()
else:
ext = fmt.lower()
if ext in JSON_EXTS:
return jsons.to_json(obj, fname)
elif ext in HDF5_EXTS:
return hdf.to_hdf(obj, fname)
elif ext in PKL_EXTS:
return cPickle.dump(obj, file(fname, 'wb'))
else:
errmsg = 'Unrecognized file type/extension: ' + ext
logging.error(errmsg)
raise TypeError(errmsg)
def store_pid_kernels(self, filename):
"""
Store PID maps in JSON format
"""
to_json(self.pid_kernels, filename)
if iniargs['prop_height'] is None: iniargs['prop_height'] = 'sample'
osc_service = NucraftOscillationService(args.ebins, args.czbins,
**iniargs)
elif args.code == 'table':
osc_service = TableOscillationService(args.ebins, args.czbins,
**iniargs)
else:
raise NotImplementedError('Unknown oscillation service: %s' %
args.code)
#Do calculation
logging.info("Calculating oscillation probabilities")
settings.pop('ebins')
settings.pop('czbins')
osc_prob_maps = osc_service.get_osc_prob_maps(**settings)
#Remove irrelevant parameters from settings
for par in ['verbose', 'outfile']: #, 'ebins', 'czbins']:
settings.pop(par)
#Write out
logging.info("Saving output to: %s", args.outfile)
if fmt == 'JSON':
osc_prob_maps['params'] = settings
to_json(osc_prob_maps, args.outfile)
elif fmt == 'HDF5':
to_hdf5(osc_prob_maps, args.outfile, settings)
logging.debug('Wrote %.2f MBytes to %s' %
(os.path.getsize(args.outfile) /
(1024.**2), os.path.basename(args.outfile)))
{"nue_cc": {'czbins':[...], 'ebins':[...], 'map':[...]},
"numu_cc": {...},
"nutau_cc": {...},
"nuall_nc": {...} }''')
parser.add_argument('--settings',metavar='SETTINGS',type=from_json,
default=from_json(find_resource('pid/V15_pid.json')),
help='''json file containing parameterizations of the particle ID for each event type.''')
parser.add_argument('-o', '--outfile', dest='outfile', metavar='FILE', type=str,
action='store',default="pid.json",
help='''file to store the output''')
parser.add_argument('-v', '--verbose', action='count', default=0,
help='''set verbosity level''')
args = parser.parse_args()
#Set verbosity level
set_verbosity(args.verbose)
#Check binning
ebins, czbins = check_binning(args.reco_event_maps)
#Initialize the PID service
pid_service = PIDServicePar(args.settings,ebins,czbins)
#Galculate event rates after PID
event_rate_pid = get_pid_maps(args.reco_event_maps,pid_service)
logging.info("Saving output to: %s"%args.outfile)
to_json(event_rate_pid,args.outfile)
parser.add_argument('-o', '--outfile', dest='outfile', metavar='FILE', type=str,
action='store',default="template.json",
help='file to store the output')
args = parser.parse_args()
set_verbosity(args.verbose)
profile.info("start initializing")
#Load all the settings
model_settings = from_json(args.template_settings)
#Select a hierarchy
logging.info('Selected %s hierarchy'%
('normal' if args.normal else 'inverted'))
params = select_hierarchy(model_settings['params'],normal_hierarchy=args.normal)
#Intialize template maker
template_maker = TemplateMaker(get_values(params),**model_settings['binning'])
profile.info("stop initializing")
#Now get the actual template
profile.info("start template calculation")
template = template_maker.get_template(get_values(params))
profile.info("stop template calculation")
#Write out
logging.info("Saving output to: %s",args.outfile)
to_json(template, args.outfile)
xNO, yNO = np.loadtxt(args.normal,unpack=True)
xIO, yIO = np.loadtxt(args.inverted,unpack=True)
y = []
for NO,IO in zip(yNO,yIO):
y.append(min(NO,IO))
y = np.array(y)
f = scipy.interpolate.splrep(xNO,-y,s=0)
wholedict = {}
wholedict["params"] = {}
wholedict["params"]["param"] = {}
prior = {}
prior["coeffs"] = f[1]
prior["deg"] = f[2]
prior["knots"] = f[0]
prior["kind"] = "spline"
wholedict["params"]["param"]["prior"] = prior
to_json(wholedict, args.normal.split("NO.txt")[0]+"MarginalisedSplinePrior.json")
type=str,
action='store',
default='flux.json',
help='file to store the output')
parser.add_argument('-v',
'--verbose',
action='count',
default=None,
help='set verbosity level')
args = parser.parse_args()
#Set verbosity level
set_verbosity(args.verbose)
logging.debug("Using %u bins in energy from %.2f to %.2f GeV" %
(len(args.ebins) - 1, args.ebins[0], args.ebins[-1]))
logging.debug("Using %u bins in cos(zenith) from %.2f to %.2f" %
(len(args.czbins) - 1, args.czbins[0], args.czbins[-1]))
#Instantiate a flux model
flux_model = HondaFluxService(args.flux_file)
#get the flux
flux_maps = get_flux_maps(flux_model, args.ebins, args.czbins,
args.nue_numu_ratio, args.nu_nubar_ratio,
args.energy_scale, args.delta_index)
#write out to a file
logging.info("Saving output to: %s" % args.outfile)
to_json(flux_maps, args.outfile)
def run_interpolated_fit(fit_directory, job_idx, skip_successful=False):
"""Run the hypersurface fit for a grid point.
If `skip_successful` is true, do not run if the `fit_successful` flag is already
True.
"""
#TODO a lot of this is copied from fit_hypersurfaces in hypersurface.py, would be safer to make more OAOO
#TODO Copy the param value storage stuff from fit_hypersurfaces across in the meantime
assert os.path.isdir(fit_directory), "fit directory does not exist"
gridpoint_json = os.path.join(fit_directory,
f"gridpoint_{job_idx:06d}.json.bz2")
gridpoint_data = from_json(gridpoint_json)
if skip_successful and gridpoint_data["fit_successful"]:
logging.info(
f"Fit at job index {job_idx} already successful, skipping...")
return
metadata = from_json(os.path.join(fit_directory, "metadata.json"))
interpolation_param_spec = metadata["interpolation_param_spec"]
# this is a pipeline configuration in the form of an OrderedDict
nominal_dataset = metadata["nominal_dataset"]
# Why can we still not load PISA objects from JSON that are inside a dict?! Grrr...
nominal_dataset["pipeline_cfg"] = pipeline_cfg_from_states(
nominal_dataset["pipeline_cfg"])
# this is a list of pipeline configurations
sys_datasets = metadata["sys_datasets"]
for sys_dataset in sys_datasets:
sys_dataset["pipeline_cfg"] = pipeline_cfg_from_states(
sys_dataset["pipeline_cfg"])
# this is a dict of param_name : value pairs
param_values = gridpoint_data["param_values"]
# we do a redundant check to make sure the parameter values at this grid point are
# correct
interpolation_param_names = metadata["interpolation_param_names"]
grid_shape = tuple(metadata["grid_shape"])
# the grid point index of this job
grid_idx = list(np.ndindex(grid_shape))[job_idx]
for i, n in enumerate(interpolation_param_names):
ms = "Inconsistent parameter values at grid point!"
assert interpolation_param_spec[n]["values"][
grid_idx[i]] == param_values[n], ms
# now we need to adjust the values of the parameter in all pipelines for this point
logging.info(f"updating pipelines with parameter values: {param_values}")
for dataset in [nominal_dataset] + sys_datasets:
for stage_cfg in dataset["pipeline_cfg"].values():
if "params" not in stage_cfg.keys(): continue
for param in interpolation_param_names:
if param in stage_cfg["params"].names:
stage_cfg["params"][param].value = param_values[param]
# these are the parameters of the hypersurface, NOT the ones we interpolate them
# over!
hypersurface_params = []
for param_state in metadata["hypersurface_params"]:
hypersurface_params.append(HypersurfaceParam.from_state(param_state))
def find_hist_stage(pipeline):
"""Locate the index of the hist stage in a pipeline."""
hist_idx_found = False
for i, s in enumerate(pipeline.stages):
if s.__class__.__name__ == "hist":
hist_idx = i
hist_idx_found = True
break
if not hist_idx_found:
raise RuntimeError(
"Could not find histogram stage in pipeline, aborting.")
return hist_idx
# We create Pipeline objects, get their outputs and then forget about the Pipeline
# object on purpose! The memory requirement to hold all systematic sets at the same
# time is just too large, especially on the cluster. The way we do it below we
# only need enough memory for one dataset at a time.
for dataset in [nominal_dataset] + sys_datasets:
pipeline = Pipeline(dataset["pipeline_cfg"])
dataset["mapset"] = pipeline.get_outputs()
# get the un-weighted event counts as well so that we can exclude bins
# with too little statistics
# First, find out which stage is the hist stage
hist_idx = find_hist_stage(pipeline)
pipeline.stages[hist_idx].unweighted = True
dataset["mapset_unweighted"] = pipeline.get_outputs()
del pipeline
# Merge maps according to the combine regex, if one was provided
combine_regex = metadata["combine_regex"]
if combine_regex is not None:
for dataset in [nominal_dataset] + sys_datasets:
dataset["mapset"] = dataset["mapset"].combine_re(combine_regex)
dataset["mapset_unweighted"] = dataset[
"mapset_unweighted"].combine_re(combine_regex)
minimum_mc = metadata["minimum_mc"]
# Remove bins (i.e. set their count to zero) that have too few MC events
for dataset in sys_datasets + [nominal_dataset]:
for map_name in dataset["mapset"].names:
insuff_mc = dataset["mapset_unweighted"][
map_name].nominal_values < minimum_mc
# Setting the hist to zero sets both nominal value and std_dev to zero
dataset["mapset"][map_name].hist[insuff_mc] = 0.
hypersurface_fit_kw = metadata["hypersurface_fit_kw"]
hypersurfaces = collections.OrderedDict()
log = metadata[
"log"] # flag determining whether hs fit is run in log-space or not
for map_name in nominal_dataset["mapset"].names:
nominal_map = nominal_dataset["mapset"][map_name]
nominal_param_values = nominal_dataset["sys_params"]
sys_maps = [
sys_dataset["mapset"][map_name] for sys_dataset in sys_datasets
]
sys_param_values = [
sys_dataset["sys_params"] for sys_dataset in sys_datasets
]
hypersurface = Hypersurface(
# Yes, this MUST be a deepcopy! Otherwise weird memory overwrites happen
# and all the numbers get jumbled across the hypersurfaces of different maps
params=copy.deepcopy(hypersurface_params),
initial_intercept=0. if log else 1., # Initial value for intercept
log=log)
hypersurface.fit(
nominal_map=nominal_map,
nominal_param_values=nominal_param_values,
sys_maps=sys_maps,
sys_param_values=sys_param_values,
norm=True,
# Is the space or loading time really a problem?
# keep_maps=False, # it would take a lot more space otherwise
**hypersurface_fit_kw)
logging.debug("\nFitted hypersurface report:\n%s" % hypersurface)
hypersurfaces[map_name] = hypersurface
gridpoint_data["hs_fit"] = hypersurfaces
gridpoint_data["fit_successful"] = True
to_json(gridpoint_data, gridpoint_json)
templates[str(run_num)]['trck'] = template['trck']['map']
templates[str(run_num)]['cscd'] = template['cscd']['map']
templates[str(run_num)]['dom_eff'] = run_dict[str(run_num)]['dom_eff']
templates[str(run_num)]['hole_ice'] = run_dict[str(run_num)]['hole_ice']
# Get MC events map
MCMap = GetMCError(get_values(DH_template_settings['params']), DH_template_settings['binning']['ebins'], DH_template_settings['binning']['czbins'], reco_mc_file)
tmap_MC = MCMap.get_mc_events_map(True, get_values(DH_template_settings['params']), reco_mc_file)
MCmaps[str(run_num)]['trck'] = tmap_MC['trck']['map']
MCmaps[str(run_num)]['cscd'] = tmap_MC['cscd']['map']
#Assemble output dict
output_template = {'templates' : templates,
'MCmaps': MCmaps,
'template_settings' : template_settings}
to_json(output_template, outdir+'%s_%s_DomEff_HoleIce_templates_%i_by_%i.json'%(OutputFilePrefix, MC_name,len(ebin_edges)-1,len(czbin_edges)-1))
# if templates already saved
else:
output_template = from_json(outdir+ '%s_DomEff_HoleIce_templates_10_by_16.json'%args.sim)
templates = output_template['templates']
MCmaps = output_template['MCmaps']
# Do fits (linear and quadratic) for each bin
for flav in ['trck','cscd']:
templ_list = []
templ_err_list = []
dom_eff_list = []
hole_ice_list = []
k_DE_linear = np.empty(np.shape(templates[run_nominal][flav]))
k_DE_quad = np.empty(np.shape(templates[run_nominal][flav]))
def run_interpolated_fit(fit_directory, job_idx, skip_successful=False):
"""Run the hypersurface fit for a grid point.
If `skip_successful` is true, do not run if the `fit_successful` flag is already
True.
"""
assert os.path.isdir(fit_directory), "fit directory does not exist"
gridpoint_json = os.path.join(fit_directory, f"gridpoint_{job_idx:06d}.json.bz2")
gridpoint_data = from_json(gridpoint_json)
if skip_successful and gridpoint_data["fit_successful"]:
logging.info(f"Fit at job index {job_idx} already successful, skipping...")
return
metadata = from_json(os.path.join(fit_directory, "metadata.json"))
interpolation_param_spec = metadata["interpolation_param_spec"]
# this is a pipeline configuration in the form of an OrderedDict
nominal_dataset = metadata["nominal_dataset"]
# Why can we still not load PISA objects from JSON that are inside a dict?! Grrr...
nominal_dataset["pipeline_cfg"] = pipeline_cfg_from_states(
nominal_dataset["pipeline_cfg"]
)
# this is a list of pipeline configurations
sys_datasets = metadata["sys_datasets"]
for sys_dataset in sys_datasets:
sys_dataset["pipeline_cfg"] = pipeline_cfg_from_states(
sys_dataset["pipeline_cfg"]
)
# this is a dict of param_name : value pairs
param_values = gridpoint_data["param_values"]
# we do a redundant check to make sure the parameter values at this grid point are
# correct
interpolation_param_names = metadata["interpolation_param_names"]
grid_shape = tuple(metadata["grid_shape"])
# the grid point index of this job
grid_idx = list(np.ndindex(grid_shape))[job_idx]
for i, n in enumerate(interpolation_param_names):
ms = "Inconsistent parameter values at grid point!"
assert interpolation_param_spec[n]["values"][grid_idx[i]] == param_values[n], ms
# now we need to adjust the values of the parameter in all pipelines for this point
logging.info(f"updating pipelines with parameter values: {param_values}")
for dataset in [nominal_dataset] + sys_datasets:
for stage_cfg in dataset["pipeline_cfg"].values():
if "params" not in stage_cfg.keys(): continue
for param in interpolation_param_names:
if param in stage_cfg["params"].names:
stage_cfg["params"][param].value = param_values[param]
# these are the parameters of the hypersurface, NOT the ones we interpolate them
# over!
hypersurface_params = []
for param_state in metadata["hypersurface_params"]:
hypersurface_params.append(HypersurfaceParam.from_state(param_state))
# We create Pipeline objects, get their outputs and then forget about the Pipeline
# object on purpose! The memory requirement to hold all systematic sets at the same
# time is just too large, especially on the cluster. The way we do it below we
# only need enough memory for one dataset at a time.
nominal_dataset["mapset"] = Pipeline(nominal_dataset["pipeline_cfg"]).get_outputs()
for sys_dataset in sys_datasets:
sys_dataset["mapset"] = Pipeline(sys_dataset["pipeline_cfg"]).get_outputs()
# Merge maps according to the combine regex, if one was provided
combine_regex = metadata["combine_regex"]
if combine_regex is not None:
nominal_dataset["mapset"] = nominal_dataset["mapset"].combine_re(combine_regex)
for sys_dataset in sys_datasets:
sys_dataset["mapset"] = sys_dataset["mapset"].combine_re(combine_regex)
hypersurface_fit_kw = metadata["hypersurface_fit_kw"]
hypersurfaces = collections.OrderedDict()
log = metadata["log"] # flag determining whether hs fit is run in log-space or not
for map_name in nominal_dataset["mapset"].names:
nominal_map = nominal_dataset["mapset"][map_name]
nominal_param_values = nominal_dataset["sys_params"]
sys_maps = [sys_dataset["mapset"][map_name] for sys_dataset in sys_datasets]
sys_param_values = [sys_dataset["sys_params"] for sys_dataset in sys_datasets]
hypersurface = Hypersurface(
# Yes, this MUST be a deepcopy! Otherwise weird memory overwrites happen
# and all the numbers get jumbled across the hypersurfaces of different maps
params=copy.deepcopy(hypersurface_params),
initial_intercept=0. if log else 1., # Initial value for intercept
log=log
)
hypersurface.fit(
nominal_map=nominal_map,
nominal_param_values=nominal_param_values,
sys_maps=sys_maps,
sys_param_values=sys_param_values,
norm=True,
# Is the space or loading time really a problem?
# keep_maps=False, # it would take a lot more space otherwise
**hypersurface_fit_kw
)
logging.debug("\nFitted hypersurface report:\n%s" % hypersurface)
hypersurfaces[map_name] = hypersurface
gridpoint_data["hs_fit"] = hypersurfaces
gridpoint_data["fit_successful"] = True
to_json(gridpoint_data, gridpoint_json)
def store_pid_kernels(self, filename):
"""
Store PID maps in JSON format
"""
to_json(self.pid_kernels, filename)
papa_NC = parameterizations['NC']
egy_res = papa_NC['e']
papa_NC.pop('e')
papa_NC['energy'] = egy_res
pisa_reco_settings = {}
for flav in pisa_flavs:
papa_res = parameterizations[flav]
egy_res = papa_res['e']
papa_res.pop('e')
papa_res['energy'] = egy_res
for ID in mID:
pisa_reco_settings[flav + ID] = {'cc': {}, 'nc': {}}
pisa_reco_settings[flav + ID]['cc'] = copy(papa_res)
pisa_reco_settings[flav + ID]['nc'] = copy(papa_NC)
to_json(pisa_reco_settings, args.outfile)
# Now, read in the file as if it were a text file and replace n. with np.
fh = open(args.outfile, 'r')
output_lines = []
for line in fh.readlines():
output_lines.append(line.replace("n.", "np."))
fh.close()
fh = open(args.outfile, 'w')
for line in output_lines:
fh.write(line)
fh.close()
from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
from pisa.utils.jsons import from_json, to_json
import numpy as np
parser = ArgumentParser(description='''Determines the false_h_best fiducial distribution, under the Gaussian assumption.''',
formatter_class=ArgumentDefaultsHelpFormatter)
parser.add_argument('-p','--pisa_file', type=str, required=True,
help="File containing PISA V2 event by event data")
args = parser.parse_args()
pisa_dict = from_json(args.pisa_file)['pid']['reduced']
to_json(pisa_dict,'better.json')
if args.code=='prob3':
if iniargs['prop_height'] is None: iniargs['prop_height'] = 20.0
osc_service = Prob3OscillationService(ebins, czbins, **iniargs)
elif args.code=='nucraft':
if iniargs['prop_height'] is None: iniargs['prop_height'] = 'sample'
osc_service = NucraftOscillationService(ebins, czbins, **iniargs)
elif args.code=='gpu':
settings = vars(args)
osc_service = Prob3GPUOscillationService(ebins, czbins, **settings)
else:
osc_service = TableOscillationService(ebins, czbins, **iniargs)
logging.info("Getting osc prob maps")
with Timer(verbose=False) as t:
osc_flux_maps = get_osc_flux(args.flux_maps, osc_service,
deltam21 = args.deltam21,
deltam31 = args.deltam31,
deltacp = args.deltacp,
theta12 = args.theta12,
theta13 = args.theta13,
theta23 = args.theta23,
oversample_e = args.oversample_e,
oversample_cz = args.oversample_cz,
energy_scale = args.energy_scale,
YeI=args.YeI, YeO=args.YeO, YeM=args.YeM)
print " ==> elapsed time to get osc flux maps: %s sec"%t.secs
#Write out
logging.info("Saving output to: %s",args.outfile)
to_json(osc_flux_maps, args.outfile)
# Second for anti-neutrinos:
kNuBar = -1
barger_prop.SetMNS(sin2th12Sq, sin2th13Sq, sin2th23Sq, args.deltam21,
mAtm, args.deltacp, energy, kSquared, kNuBar)
barger_prop.DefinePath(coszen, args.prod_height)
barger_prop.propagate(kNuBar)
for nu in ['nue_bar', 'numu_bar']:
nu_i = nu_barger[nu]
for to_nu in anti_neutrinos:
nu_f = nu_barger[to_nu]
osc_prob_dict[nu +
'_maps'][to_nu][ie][icz] = barger_prop.GetProb(
nu_i, nu_f)
logging.info("Saving to file: %s" % args.outfile)
to_json(osc_prob_dict, args.outfile)
logging.info("Finished in %s seconds!" % (datetime.now() - start_time))
if args.plot:
from matplotlib import pyplot as plt
from pisa.utils.plot import show_map
pmap = {
'map': osc_prob_dict['numu_maps']['numu'],
'ebins': osc_prob_dict['ebins'],
'czbins': osc_prob_dict['czbins']
}
show_map(pmap)
plt.show()
def get_fisher_matrices(template_settings,
grid_settings,
IMH=True,
NMH=False,
dump_all_stages=False,
save_templates=False,
outdir=None):
'''
Main function that runs the Fisher analysis for the chosen hierarchy(ies) (inverted by default).
Returns a dictionary of Fisher matrices, in the format:
{'IMH': {'cscd': [...],
'trck': [...],
'comb': [...],
},
'NMH': {'cscd': [...],
'trck': [...],
'comb': [...],
}
}
If save_templates=True and no hierarchy is given, only fiducial templates will be written out;
if one is given, then the templates used to obtain the gradients will be written out in
addition.
'''
if outdir is None and (save_templates or dump_all_stages):
logging.info(
"No output directory specified. Will save templates to current working directory."
)
outdir = os.getcwd()
tprofile.info("start initializing")
# Get the parameters
params = template_settings['params']
bins = template_settings['binning']
# Artifically add the hierarchy parameter to the list of parameters
# The method get_hierarchy_gradients below will know how to deal with it
params['hierarchy_nh'] = {
"value": 1.,
"range": [0., 1.],
"fixed": False,
"prior": None
}
params['hierarchy_ih'] = {
"value": 0.,
"range": [0., 1.],
"fixed": False,
"prior": None
}
chosen_data = []
if IMH:
chosen_data.append(('IMH', False))
logging.info("Fisher matrix will be built for IMH.")
if NMH:
chosen_data.append(('NMH', True))
logging.info("Fisher matrix will be built for NMH.")
if chosen_data == []:
# In this case, only the fiducial maps (for both hierarchies) will be written
logging.info("No Fisher matrices will be built.")
# There is no sense in performing any of the following steps if no Fisher matrices are to be built
# and no templates are to be saved.
if chosen_data != [] or dump_all_stages or save_templates:
# Initialise return dict to hold Fisher matrices
fisher = {
data_tag: {
'cscd': [],
'trck': [],
'comb': []
}
for data_tag, data_normal in chosen_data
}
# Get a template maker with the settings used to initialize
template_maker = TemplateMaker(get_values(params), **bins)
tprofile.info("stop initializing\n")
# Generate fiducial templates for both hierarchies (needed for partial derivatives
# w.r.t. hierarchy parameter)
fiducial_maps = {}
for hierarchy in ['NMH', 'IMH']:
logging.info("Generating fiducial templates for %s." % hierarchy)
# Get the fiducial parameter values corresponding to this hierarchy
fiducial_params = select_hierarchy(
params, normal_hierarchy=(hierarchy == 'NMH'))
# Generate fiducial maps, either all of them or only the ultimate one
tprofile.info("start template calculation")
with Timer() as t:
fid_maps = template_maker.get_template(
get_values(fiducial_params), return_stages=dump_all_stages)
tprofile.info("==> elapsed time for template: %s sec" % t.secs)
fiducial_maps[
hierarchy] = fid_maps[4] if dump_all_stages else fid_maps
# save fiducial map(s)
# all stages
if dump_all_stages:
stage_names = ("0_unoscillated_flux", "1_oscillated_flux",
"2_oscillated_counts", "3_reco", "4_pid")
stage_maps = {}
for stage in xrange(0, len(fid_maps)):
stage_maps[stage_names[stage]] = fid_maps[stage]
logging.info(
"Writing fiducial maps (all stages) for %s to %s." %
(hierarchy, outdir))
to_json(stage_maps,
os.path.join(outdir, "fid_map_" + hierarchy + ".json"))
# only the final stage
elif save_templates:
logging.info(
"Writing fiducial map (final stage) for %s to %s." %
(hierarchy, outdir))
to_json(fiducial_maps[hierarchy],
os.path.join(outdir, "fid_map_" + hierarchy + ".json"))
# Get_gradients and get_hierarchy_gradients will both (temporarily)
# store the templates used to generate the gradient maps
store_dir = outdir if save_templates else tempfile.gettempdir()
# Calculate Fisher matrices for the user-defined cases (NHM true and/or IMH true)
for data_tag, data_normal in chosen_data:
logging.info("Running Fisher analysis for %s." % (data_tag))
# The fiducial params are selected from the hierarchy case that does NOT match
# the data, as we are varying from this model to find the 'best fit'
fiducial_params = select_hierarchy(params, not data_normal)
# Get the free parameters (i.e. those for which the gradients should be calculated)
free_params = select_hierarchy(get_free_params(params),
not data_normal)
gradient_maps = {}
for param in free_params.keys():
# Special treatment for the hierarchy parameter
if param == 'hierarchy':
gradient_maps[param] = get_hierarchy_gradients(
data_tag=data_tag,
fiducial_maps=fiducial_maps,
fiducial_params=fiducial_params,
grid_settings=grid_settings,
store_dir=store_dir)
else:
gradient_maps[param] = get_gradients(
data_tag=data_tag,
param=param,
template_maker=template_maker,
fiducial_params=fiducial_params,
grid_settings=grid_settings,
store_dir=store_dir)
logging.info("Building Fisher matrix for %s." % (data_tag))
# Build Fisher matrices for the given hierarchy
fisher[data_tag] = build_fisher_matrix(
gradient_maps=gradient_maps,
fiducial_map=fiducial_maps['IMH']
if data_normal else fiducial_maps['NMH'],
template_settings=fiducial_params)
# If Fisher matrices exist for both channels, add the matrices to obtain
# the combined one.
if len(fisher[data_tag].keys()) > 1:
fisher[data_tag]['comb'] = FisherMatrix(
matrix=np.array([
f.matrix for f in fisher[data_tag].itervalues()
]).sum(axis=0),
parameters=gradient_maps.keys(), #order is important here!
best_fits=[
fiducial_params[par]['value']
for par in gradient_maps.keys()
],
priors=[
Prior.from_param(fiducial_params[par])
for par in gradient_maps.keys()
],
)
return fisher
else:
logging.info("Nothing to be done.")
return {}
# Second for anti-neutrinos:
kNuBar = -1
barger_prop.SetMNS(sin2th12Sq,sin2th13Sq,sin2th23Sq,args.deltam21,mAtm,
args.deltacp,energy,kSquared,kNuBar)
barger_prop.DefinePath(coszen, args.prod_height)
barger_prop.propagate(kNuBar)
for nu in ['nue_bar','numu_bar']:
nu_i = nu_barger[nu]
for to_nu in anti_neutrinos:
nu_f = nu_barger[to_nu]
osc_prob_dict[nu+'_maps'][to_nu][ie][icz]=barger_prop.GetProb(nu_i, nu_f)
logging.info("Saving to file: %s"%args.outfile)
to_json(osc_prob_dict,args.outfile)
logging.info("Finished in %s seconds!"%(datetime.now() - start_time))
if args.plot:
from matplotlib import pyplot as plt
from pisa.utils.plot import show_map
pmap = {'map':osc_prob_dict['numu_maps']['numu'],
'ebins':osc_prob_dict['ebins'],
'czbins': osc_prob_dict['czbins']}
show_map(pmap)
plt.show()
def prepare_interpolated_fit(nominal_dataset,
sys_datasets,
params,
fit_directory,
interpolation_param_spec,
combine_regex=None,
log=False,
minimum_mc=0,
**hypersurface_fit_kw):
'''
Writes steering files for fitting hypersurfaces on a grid of arbitrary parameters.
The fits can then be run on a cluster with `run_interpolated_fit`.
Parameters
----------
nominal_dataset : dict
Definition of the nominal dataset. Specifies the pipleline with which the maps
can be created, and the values of all systematic parameters used to produced the
dataset.
Format must be:
nominal_dataset = {
"pipeline_cfg" = <pipeline cfg file (either cfg file path or dict)>),
"sys_params" = { param_0_name : param_0_value_in_dataset, ..., param_N_name : param_N_value_in_dataset }
}
Sys params must correspond to the provided HypersurfaceParam instances provided
in the `params` arg.
sys_datasets : list of dicts
List of dicts, where each dict defines one of the systematics datasets to be
fitted. The format of each dict is the same as explained for `nominal_dataset`
params : list of HypersurfaceParams
List of HypersurfaceParams instances that define the hypersurface. Note that
this defined ALL hypersurfaces fitted in this function, e.g. only supports a
single parameterisation for all maps (this is almost always what you want).
output_directory : str
Directory in which the fits will be run. Steering files for the fits to be run
will be stored here.
combine_regex : list of str, or None
List of string regex expressions that will be used for merging maps. Used to
combine similar species. Must be something that can be passed to the
`MapSet.combine_re` function (see that functions docs for more details). Choose
`None` is do not want to perform this merging.
interpolation_param_spec : collections.OrderedDict
Specification of parameter grid that hypersurfaces should be interpolated over.
The dict should have the following form::
interpolation_param_spec = {
'param1': {"values": [val1_1, val1_2, ...], "scales_log": True/False}
'param2': {"values": [val2_1, val2_2, ...], "scales_log": True/False}
...
'paramN': {"values": [valN_1, valN_2, ...], "scales_log": True/False}
}
The hypersurfaces will be fit on an N-dimensional rectilinear grid over
parameters 1 to N. The flag `scales_log` indicates that the interpolation over
that parameter should happen in log-space.
minimum_mc : int, optional
Minimum number of un-weighted MC events required in each bin.
hypersurface_fit_kw : kwargs
kwargs will be passed on to the calls to `Hypersurface.fit`
'''
# Take (deep) copies of lists/dicts to avoid modifying the originals
# Useful for cases where this function is called in a loop (e.g. leave-one-out tests)
nominal_dataset = copy.deepcopy(nominal_dataset)
sys_datasets = copy.deepcopy(sys_datasets)
params = copy.deepcopy(params)
# Check types
assert isinstance(sys_datasets, collections.Sequence)
assert isinstance(params, collections.Sequence)
assert isinstance(fit_directory, str)
# there must not be any ambiguity between fitting the hypersurfaces and
# interpolating them later
msg = "interpolation params must be specified as a dict with ordered keys"
assert isinstance(interpolation_param_spec, collections.OrderedDict), msg
for k, v in interpolation_param_spec.items():
assert set(v.keys()) == {"values", "scales_log"}
assert isinstance(v["values"], collections.Sequence)
# We need to extract the magnitudes from the Quantities to avoid a
# UnitStrippedWarning. For some reason, doing `np.min(v["values"])` messes up
# the data structure inside the values in a way that can cause a crash when we
# try to serialize the values later. Lesson: Stripping units inadvertently can
# have strange, unforeseen consequences.
mags = [x.m for x in v["values"]]
if v["scales_log"] and np.min(mags) <= 0:
raise ValueError(
"A log-scaling parameter cannot be equal to or less "
"than zero!")
# Check output format and path
assert os.path.isdir(fit_directory), "fit directory does not exist"
# Check formatting of datasets is as expected
all_datasets = [nominal_dataset] + sys_datasets
for dataset in all_datasets:
assert isinstance(dataset, collections.Mapping)
assert "pipeline_cfg" in dataset
assert isinstance(dataset["pipeline_cfg"], (str, collections.Mapping))
assert "sys_params" in dataset
assert isinstance(dataset["sys_params"], collections.Mapping)
dataset["pipeline_cfg"] = serialize_pipeline_cfg(
dataset["pipeline_cfg"])
# Check params
assert len(params) >= 1
for p in params:
assert isinstance(p, HypersurfaceParam)
# Report inputs
msg = "Hypersurface fit details :\n"
msg += f" Num params : {len(params)}\n"
msg += f" Num fit coefficients : {sum([p.num_fit_coeffts for p in params])}\n"
msg += f" Num datasets : 1 nominal + {len(sys_datasets)} systematics\n"
msg += f" Nominal values : {nominal_dataset['sys_params']}\n"
msg += "Hypersurface fits are prepared on the following grid:\n"
msg += str(interpolation_param_spec)
logging.info(msg)
# because we require this to be an OrderedDict, there is no ambiguity in the
# construction of the mesh here
param_names = list(interpolation_param_spec.keys())
grid_shape = tuple(
len(v["values"]) for v in interpolation_param_spec.values())
# We store all information needed to run a fit in metadata
metadata = collections.OrderedDict(
interpolation_param_spec=interpolation_param_spec,
interpolation_param_names=param_names, # convenience
grid_shape=grid_shape, # convenience
nominal_dataset=nominal_dataset,
sys_datasets=sys_datasets,
hypersurface_params=params,
combine_regex=combine_regex,
log=log,
minimum_mc=minimum_mc,
hypersurface_fit_kw=hypersurface_fit_kw)
to_json(metadata, os.path.join(fit_directory, "metadata.json"))
# we write on JSON file for each grid point
for job_idx, grid_idx in enumerate(np.ndindex(grid_shape)):
# Although this is technically redundant, we store the parameter values
# explicitly for each grid point.
param_values = {}
for i, n in enumerate(param_names):
param_values[n] = interpolation_param_spec[n]["values"][
grid_idx[i]]
gridpoint_data = {
"param_values": param_values,
"hs_fit": None,
"job_idx": job_idx,
"grid_idx": grid_idx,
"fit_successful": False
}
to_json(
gridpoint_data,
os.path.join(fit_directory, f"gridpoint_{job_idx:06d}.json.bz2"))
logging.info(
f"Grid fit preparation complete! Total number of jobs: {job_idx+1}")
return job_idx + 1 # zero-indexing
help='JSON file containing parameterizations '
'of the particle ID \nfor each event type.')
parser.add_argument('--kernel_file', metavar='JSON', type=str, default=None,
help='JSON file containing pre-calculated PID kernels')
parser.add_argument('-o', '--outfile', dest='outfile', metavar='FILE', type=str,
action='store',default="pid.json",
help='''file to store the output''')
parser.add_argument('-v', '--verbose', action='count', default=None,
help='''set verbosity level''')
args = parser.parse_args()
#Set verbosity level
set_verbosity(args.verbose)
#Check binning
ebins, czbins = check_binning(args.reco_event_maps)
#Initialize the PID service
if args.mode=='param':
pid_service = PIDServiceParam(ebins, czbins,
pid_paramfile=args.param_file, **vars(args))
elif args.mode=='stored':
pid_service = PIDServiceKernelFile(ebins, czbins,
pid_kernelfile=args.kernel_file, **vars(args))
#Calculate event rates after PID
event_rate_pid = get_pid_maps(args.reco_event_maps, pid_service=pid_service)
logging.info("Saving output to: %s"%args.outfile)
to_json(event_rate_pid,args.outfile)
llh_data = find_max_llh_bfgs(fmap,
template_maker,
template_settings['params'],
minimizer_settings,
args.save_steps,
normal_hierarchy=hypo_normal)
profile.info("==> elapsed time for optimizer: %s sec" % t.secs)
# Store the LLH data
results[data_tag][hypo_tag] = llh_data
# Store this trial
trials += [results]
profile.info("stop trial %d" % itrial)
except:
logging.warn("ERROR IN TRIAL %i, so outputting what we have now!!" %
itrial)
#Assemble output dict
output = {
'trials': trials,
'template_settings': template_settings,
'minimizer_settings': minimizer_settings
}
if args.pseudo_data_settings is not None:
output['pseudo_data_settings'] = pseudo_data_settings
#And write to file
to_json(output, args.outfile)
title=flavInt.tex(grp, d=1) + leg_sfx,
)
leg.get_title().set_fontsize(16)
# Derive output filename
outfname = ('pid_energy_dependence__%s_%s__runs_%s__proc_%s__pid_%s.json' %
(
events.metadata['detector'],
events.metadata['geom'],
utils.list2hrlist(events.metadata['runs']),
events.metadata['proc_ver'],
args.pid_ver,
))
outfpath = os.path.join(outdir, outfname)
logging.info('Saving PID energy dependence info to file "%s"' % outfpath)
jsons.to_json(esmooth_store, outfpath)
if make_plots:
fig.tight_layout(rect=(0, 0, 1, 0.96))
basefname = ('pid_energy_dependence__%s_%s__runs_%s__proc_%s__pid_%s' %
(events.metadata['detector'], events.metadata['geom'],
utils.list2hrlist(events.metadata['runs']),
events.metadata['proc_ver'], args.pid_ver))
fig.savefig(os.path.join(outdir, basefname + '.pdf'))
fig.savefig(os.path.join(outdir, basefname + '.png'))
#===============================================================================
# COSZEN
#===============================================================================
single_ebin = [1, 80]
pidmc = PIDServiceMC(ebins=single_ebin,
parser.add_argument('-o', '--outfile', dest='outfile', metavar='FILE',
type=str, action='store',default="template.json",
help='file to store the output')
args = parser.parse_args()
set_verbosity(args.verbose)
with Timer() as t:
#Load all the settings
model_settings = from_json(args.template_settings)
#Select a hierarchy
logging.info('Selected %s hierarchy'%
('normal' if args.normal else 'inverted'))
params = select_hierarchy(model_settings['params'],
normal_hierarchy=args.normal)
#Intialize template maker
template_maker = TemplateMaker(get_values(params),
**model_settings['binning'])
profile.info(" ==> elapsed time to initialize templates: %s sec"%t.secs)
#Now get the actual template
with Timer(verbose=False) as t:
template_maps = template_maker.get_template(get_values(params),
return_stages=args.save_all)
profile.info("==> elapsed time to get template: %s sec"%t.secs)
logging.info("Saving file to %s"%args.outfile)
to_json(template_maps, args.outfile)
steps['llh'] = []
# Iterate over the cartesian product, and set fixed parameter to value
for pos in product(*steplist):
pos_dict = dict(list(pos))
print "Running at params-pos dict: ",pos_dict
for k,v in pos_dict.items():
hypo_params[k]['value'] = v
steps[k].append(v)
with Timer() as t:
llh_data = find_max_llh_bfgs(asimov_data_set,template_maker,hypo_params,
minimizer_settings,args.save_steps,
normal_hierarchy=hypo_normal)
profile.info("==> elapsed time for optimizer: %s sec"%t.secs)
steps['llh'].append(llh_data['llh'][-1])
# Then save the minimized free params later??
#print "\n\nsteps: ",steps
#Store the LLH data
results[data_tag][hypo_tag] = steps
except:
print "error message: ",sys.exc_info()
logging.warn("ERROR: outputting what we have now...")
logging.warn("FINISHED. Saving to file: %s"%args.outfile)
to_json(results,args.outfile)
"fixed": True
}
for key, val in vars(args).items()
if key not in template_settings['binning'].keys()
}
# Add aeff part:
stem = 'a_eff_'
aeff_dict = {
'NC': stem + 'nuall_nc.dat',
'NC_bar': stem + 'nuallbar_nc.dat',
'nue': stem + 'nue.dat',
'nue_bar': stem + 'nuebar.dat',
'numu': stem + 'numu.dat',
'numu_bar': stem + 'numubar.dat',
'nutau': stem + 'nutau.dat',
'nutau_bar': stem + 'nutaubar.dat'
}
aeff_dir = template_settings['params']['aeff_egy_par_dir']['value']
template_settings['params'].pop('aeff_egy_par_dir')
template_settings['params']['aeff_egy_par'] = {'value': {}, 'fixed': True}
for key, val in aeff_dict.items():
template_settings['params']['aeff_egy_par']['value'][key] = aeff_dir + val
for key, val in dbparams.items():
template_settings['params'][key] = val
print "Writing all settings to: ", outfile
to_json(template_settings, outfile)
default="template.json",
help='file to store the output')
args = parser.parse_args()
set_verbosity(args.verbose)
with Timer() as t:
#Load all the settings
model_settings = from_json(args.template_settings)
#Select a hierarchy
logging.info('Selected %s hierarchy' %
('normal' if args.normal else 'inverted'))
params = select_hierarchy(model_settings['params'],
normal_hierarchy=args.normal)
#Intialize template maker
template_maker = TemplateMaker(get_values(params),
**model_settings['binning'])
tprofile.info(" ==> elapsed time to initialize templates: %s sec" %
t.secs)
#Now get the actual template
with Timer(verbose=False) as t:
template_maps = template_maker.get_template(
get_values(params), return_stages=args.save_all)
tprofile.info("==> elapsed time to get template: %s sec" % t.secs)
logging.info("Saving file to %s" % args.outfile)
to_json(template_maps, args.outfile)
dest="outfile",
metavar="FILE",
type=str,
action="store",
default="event_rate.json",
help="""file to store the output""",
)
parser.add_argument("-v", "--verbose", action="count", default=None, help="""set verbosity level""")
args = parser.parse_args()
# Set verbosity level
set_verbosity(args.verbose)
# Check binning
ebins, czbins = check_binning(args.osc_flux_maps)
logging.info("Defining aeff_service...")
if args.mc_mode:
logging.info(" Using effective area from EVENT DATA...")
aeff_service = AeffServiceMC(ebins, czbins, aeff_weight_file=args.weighted_aeff_file)
else:
logging.info(" Using effective area from PARAMETRIZATION...")
aeff_settings = from_json(find_resource(args.settings_file))
aeff_service = AeffServicePar(ebins, czbins, **aeff_settings)
event_rate_maps = get_event_rates(args.osc_flux_maps, aeff_service, args.livetime, args.aeff_scale)
logging.info("Saving output to: %s" % args.outfile)
to_json(event_rate_maps, args.outfile)
}
if args.code == 'prob3':
if iniargs['prop_height'] is None: iniargs['prop_height'] = 20.0
osc_service = Prob3OscillationService(ebins, czbins, **iniargs)
elif args.code == 'nucraft':
if iniargs['prop_height'] is None: iniargs['prop_height'] = 'sample'
osc_service = NucraftOscillationService(ebins, czbins, **iniargs)
elif args.code == 'gpu':
settings = vars(args)
osc_service = Prob3GPUOscillationService(ebins, czbins, **settings)
else:
osc_service = TableOscillationService(ebins, czbins, **iniargs)
logging.info("Getting osc prob maps")
osc_flux_maps = get_osc_flux(args.flux_maps,
osc_service,
deltam21=args.deltam21,
deltam31=args.deltam31,
deltacp=args.deltacp,
theta12=args.theta12,
theta13=args.theta13,
theta23=args.theta23,
oversample_e=args.oversample_e,
oversample_cz=args.oversample_cz,
energy_scale=args.energy_scale)
#Write out
logging.info("Saving output to: %s", args.outfile)
to_json(osc_flux_maps, args.outfile)
arg_dict = vars(args)
for key in (template_settings['binning'].keys()+['free_params','dbfile','outfile']):
arg_dict.pop(key)
# Now params:
template_settings['params'] = {key: {"value": val, "fixed": True}
for key,val in vars(args).items()
if key not in template_settings['binning'].keys()}
# Add aeff part:
stem = 'a_eff_'
aeff_dict = {'NC': stem+'nuall_nc.dat',
'NC_bar': stem+'nuallbar_nc.dat',
'nue': stem+'nue.dat',
'nue_bar': stem+'nuebar.dat',
'numu': stem+'numu.dat',
'numu_bar': stem+'numubar.dat',
'nutau': stem+'nutau.dat',
'nutau_bar': stem+'nutaubar.dat'}
aeff_dir = template_settings['params']['aeff_egy_par_dir']['value']
template_settings['params'].pop('aeff_egy_par_dir')
template_settings['params']['aeff_egy_par'] = {'value':{},'fixed':True}
for key,val in aeff_dict.items():
template_settings['params']['aeff_egy_par']['value'][key] = aeff_dir+val
for key,val in dbparams.items(): template_settings['params'][key] = val
print "Writing all settings to: ",outfile
to_json(template_settings,outfile)
def get_fisher_matrices(template_settings, grid_settings, IMH=True, NMH=False, dump_all_stages=False,
save_templates=False, outdir=None):
'''
Main function that runs the Fisher analysis for the chosen hierarchy(ies) (inverted by default).
Returns a dictionary of Fisher matrices, in the format:
{'IMH': {'cscd': [...],
'trck': [...],
'comb': [...],
},
'NMH': {'cscd': [...],
'trck': [...],
'comb': [...],
}
}
If save_templates=True and no hierarchy is given, only fiducial templates will be written out;
if one is given, then the templates used to obtain the gradients will be written out in
addition.
'''
if outdir is None and (save_templates or dump_all_stages):
logging.info("No output directory specified. Will save templates to current working directory.")
outdir = os.getcwd()
profile.info("start initializing")
# Get the parameters
params = template_settings['params']
bins = template_settings['binning']
# Artifically add the hierarchy parameter to the list of parameters
# The method get_hierarchy_gradients below will know how to deal with it
params['hierarchy_nh'] = { "value": 1., "range": [0.,1.],
"fixed": False, "prior": None}
params['hierarchy_ih'] = { "value": 0., "range": [0.,1.],
"fixed": False, "prior": None}
chosen_data = []
if IMH:
chosen_data.append(('IMH',False))
logging.info("Fisher matrix will be built for IMH.")
if NMH:
chosen_data.append(('NMH',True))
logging.info("Fisher matrix will be built for NMH.")
if chosen_data == []:
# In this case, only the fiducial maps (for both hierarchies) will be written
logging.info("No Fisher matrices will be built.")
# There is no sense in performing any of the following steps if no Fisher matrices are to be built
# and no templates are to be saved.
if chosen_data!=[] or dump_all_stages or save_templates:
# Initialise return dict to hold Fisher matrices
fisher = { data_tag:{'cscd':[],'trck':[],'comb':[]} for data_tag, data_normal in chosen_data }
# Get a template maker with the settings used to initialize
template_maker = TemplateMaker(get_values(params),**bins)
profile.info("stop initializing\n")
# Generate fiducial templates for both hierarchies (needed for partial derivatives
# w.r.t. hierarchy parameter)
fiducial_maps = {}
for hierarchy in ['NMH','IMH']:
logging.info("Generating fiducial templates for %s."%hierarchy)
# Get the fiducial parameter values corresponding to this hierarchy
fiducial_params = select_hierarchy(params,normal_hierarchy=(hierarchy=='NMH'))
# Generate fiducial maps, either all of them or only the ultimate one
profile.info("start template calculation")
with Timer() as t:
fid_maps = template_maker.get_template(get_values(fiducial_params),
return_stages=dump_all_stages)
profile.info("==> elapsed time for template: %s sec"%t.secs)
fiducial_maps[hierarchy] = fid_maps[4] if dump_all_stages else fid_maps
# save fiducial map(s)
# all stages
if dump_all_stages:
stage_names = ("0_unoscillated_flux","1_oscillated_flux","2_oscillated_counts","3_reco","4_pid")
stage_maps = {}
for stage in xrange(0,len(fid_maps)):
stage_maps[stage_names[stage]] = fid_maps[stage]
logging.info("Writing fiducial maps (all stages) for %s to %s."%(hierarchy,outdir))
to_json(stage_maps,os.path.join(outdir,"fid_map_"+hierarchy+".json"))
# only the final stage
elif save_templates:
logging.info("Writing fiducial map (final stage) for %s to %s."%(hierarchy,outdir))
to_json(fiducial_maps[hierarchy],os.path.join(outdir,"fid_map_"+hierarchy+".json"))
# Get_gradients and get_hierarchy_gradients will both (temporarily)
# store the templates used to generate the gradient maps
store_dir = outdir if save_templates else tempfile.gettempdir()
# Calculate Fisher matrices for the user-defined cases (NHM true and/or IMH true)
for data_tag, data_normal in chosen_data:
logging.info("Running Fisher analysis for %s."%(data_tag))
# The fiducial params are selected from the hierarchy case that does NOT match
# the data, as we are varying from this model to find the 'best fit'
fiducial_params = select_hierarchy(params,not data_normal)
# Get the free parameters (i.e. those for which the gradients should be calculated)
free_params = select_hierarchy(get_free_params(params),not data_normal)
gradient_maps = {}
for param in free_params.keys():
# Special treatment for the hierarchy parameter
if param=='hierarchy':
gradient_maps[param] = get_hierarchy_gradients(data_tag,
fiducial_maps,
fiducial_params,
grid_settings,
store_dir,
)
else:
gradient_maps[param] = get_gradients(data_tag,
param,
template_maker,
fiducial_params,
grid_settings,
store_dir
)
logging.info("Building Fisher matrix for %s."%(data_tag))
# Build Fisher matrices for the given hierarchy
fisher[data_tag] = build_fisher_matrix(gradient_maps,fiducial_maps['IMH'] if data_normal else fiducial_maps['NMH'],fiducial_params)
# If Fisher matrices exist for both channels, add the matrices to obtain the combined one.
if len(fisher[data_tag].keys()) > 1:
fisher[data_tag]['comb'] = FisherMatrix(matrix=np.array([f.matrix for f in fisher[data_tag].itervalues()]).sum(axis=0),
parameters=gradient_maps.keys(), #order is important here!
best_fits=[fiducial_params[par]['value'] for par in gradient_maps.keys()],
priors=[fiducial_params[par]['prior'] for par in gradient_maps.keys()],
)
return fisher
else:
logging.info("Nothing to be done.")
return {}
egy_res = papa_NC['e']
papa_NC.pop('e')
papa_NC['energy'] = egy_res
pisa_reco_settings = {}
for flav in pisa_flavs:
papa_res = parameterizations[flav]
egy_res = papa_res['e']
papa_res.pop('e')
papa_res['energy'] = egy_res
for ID in mID:
pisa_reco_settings[flav+ID] = {'cc':{},'nc':{}}
pisa_reco_settings[flav+ID]['cc'] = copy(papa_res)
pisa_reco_settings[flav+ID]['nc'] = copy(papa_NC)
to_json(pisa_reco_settings,args.outfile)
# Now, read in the file as if it were a text file and replace n. with np.
fh = open(args.outfile,'r')
output_lines = []
for line in fh.readlines():
output_lines.append(line.replace("n.","np."))
fh.close()
fh = open(args.outfile,'w')
for line in output_lines:
fh.write(line)
fh.close()
help="File containing CAKE (PISA V3) data")
args = parser.parse_args()
cake_array = from_json(args.cake_file)['maps']
output_array = []
total_trck_dict = {}
total_cscd_dict = {}
for cake_dict in cake_array:
if 'trck' in cake_dict['name']:
if len(total_trck_dict.keys()) == 0:
total_trck_dict = cake_dict
total_trck_dict['name'] = 'trck'
else:
total_trck_dict['hist'] += cake_dict['hist']
elif 'cscd' in cake_dict['name']:
if len(total_cscd_dict.keys()) == 0:
total_cscd_dict = cake_dict
total_cscd_dict['name'] = 'cscd'
else:
total_cscd_dict['hist'] += cake_dict['hist']
outputarray = []
outputarray.append(total_trck_dict)
outputarray.append(total_cscd_dict)
to_json(np.array(outputarray),'merged.json')
# 1) get a pseudo data fmap from fiducial model (best fit vals of params).
fmap = get_pseudo_data_fmap(template_maker,
get_values(select_hierarchy(params,
normal_hierarchy=data_normal)),
seed=results[data_tag]['seed'])
# 2) find max llh (and best fit free params) from matching pseudo data
# to templates.
for hypo_tag, hypo_normal in [('hypo_NMH',True),('hypo_IMH',False)]:
physics.info("Finding best fit for %s under %s assumption"%(data_tag,hypo_tag))
profile.info("start optimizer")
llh_data = find_max_llh_bfgs(fmap,template_maker,params,
minimizer_settings,args.save_steps,normal_hierarchy=hypo_normal)
profile.info("stop optimizer")
#Store the LLH data
results[data_tag][hypo_tag] = llh_data
#Store this trial
trials += [results]
profile.info("stop trial %d"%itrial)
#Assemble output dict
output = {'trials' : trials,
'template_settings' : template_settings,
'minimizer_settings' : minimizer_settings}
#And write to file
to_json(output,args.outfile)
asimov_data_set = get_asimov_fmap(template_maker,
asimov_params,
channel=asimov_params['channel'])
# Store injected true values in result:
for key in free_params.keys():
if 'theta23' in key: continue
result['true_' + key].append(asimov_params[key])
result['true_theta23'].append(step)
result['asimov_data'].append(asimov_data_set)
# now get fitted values of opposite hierarchy:
hypo_normal = False if true_normal else True
hypo_tag = 'hypo_IMH' if true_normal else 'hypo_NMH'
llh_data = find_alt_hierarchy_fit(asimov_data_set,
template_maker,
params,
hypo_normal,
minimizer_settings,
only_atm_params=False,
check_octant=args.check_octant)
for key in free_params.keys():
result['fit_' + key].append(llh_data[key][-1])
results[true_tag] = result
logging.warn("FINISHED. Saving to file: %s" % args.outfile)
to_json(results, args.outfile)
parser.add_argument('-v',
'--verbose',
action='count',
default=None,
help='''set verbosity level''')
args = parser.parse_args()
#Set verbosity level
set_verbosity(args.verbose)
#Check binning
ebins, czbins = check_binning(args.osc_flux_maps)
logging.info("Defining aeff_service...")
if args.mc_mode:
logging.info(" Using effective area from EVENT DATA...")
aeff_service = AeffServiceMC(ebins,
czbins,
aeff_weight_file=args.weighted_aeff_file)
else:
logging.info(" Using effective area from PARAMETRIZATION...")
aeff_settings = from_json(find_resource(args.settings_file))
aeff_service = AeffServicePar(ebins, czbins, **aeff_settings)
event_rate_maps = get_event_rates(args.osc_flux_maps, aeff_service,
args.livetime, args.aeff_scale)
logging.info("Saving output to: %s" % args.outfile)
to_json(event_rate_maps, args.outfile)
parser.add_argument('--delta_index',metavar='FLOAT',type=float,
default=0.0,help='''Shift in spectral index of numu''')
parser.add_argument('--energy_scale',metavar='FLOAT',type=float,
help='''Factor to scale TRUE energy by''',default=1.0)
parser.add_argument('-o', '--outfile', dest='outfile', metavar='FILE',
type=str, action='store', default='flux.json',
help='file to store the output')
parser.add_argument('-v', '--verbose', action='count', default=None,
help='set verbosity level')
args = parser.parse_args()
#Set verbosity level
set_verbosity(args.verbose)
logging.debug("Using %u bins in energy from %.2f to %.2f GeV"%
(len(args.ebins)-1,args.ebins[0],args.ebins[-1]))
logging.debug("Using %u bins in cos(zenith) from %.2f to %.2f"%
(len(args.czbins)-1,args.czbins[0],args.czbins[-1]))
#Instantiate a flux model
flux_model = HondaFluxService(args.flux_file)
#get the flux
flux_maps = get_flux_maps(
flux_model, args.ebins, args.czbins, args.nue_numu_ratio, args.nu_nubar_ratio,
args.energy_scale, args.delta_index)
#write out to a file
logging.info("Saving output to: %s"%args.outfile)
to_json(flux_maps, args.outfile)
def summarize_clsim_table(table_fpath,
table=None,
save_summary=True,
outdir=None):
"""
Parameters
----------
table_fpath : string
Path to table (or just the table's filename if `outdir` is specified)
table : mapping, optional
If the table has already been loaded, it can be passed here to avoid
re-loading the table.
save_summary : bool
Whether to save the table summary to disk.
outdir : string, optional
If `save_summary` is True, write the summary to this directory. If
`outdir` is not specified and `save_summary` is True, the summary will
be written to the same directory that contains `table_fpath`.
Returns
-------
table
See `load_clsim_table` for details of the data structure
summary : OrderedDict
"""
t_start = time()
if save_summary:
from pisa.utils.jsons import from_json, to_json
table_fpath = expand(table_fpath)
srcdir, clsim_fname = dirname(table_fpath), basename(table_fpath)
invalid_fname = False
try:
fname_info = interpret_clsim_table_fname(clsim_fname)
except ValueError:
invalid_fname = True
fname_info = {}
if outdir is None:
outdir = srcdir
outdir = expand(outdir)
mkdir(outdir)
if invalid_fname:
metapath = None
else:
metaname = (CLSIM_TABLE_METANAME_PROTO[-1].format(
hash_val=fname_info['hash_val']))
metapath = join(outdir, metaname)
if metapath and isfile(metapath):
meta = from_json(metapath)
else:
meta = dict()
if table is None:
table = load_clsim_table(table_fpath)
summary = OrderedDict()
for key in table.keys():
if key == 'table':
continue
summary[key] = table[key]
if fname_info:
for key in ('hash_val', 'string', 'depth_idx', 'seed'):
summary[key] = fname_info[key]
# TODO: Add hole ice info when added to tray_kw_to_hash
if meta:
summary['n_events'] = meta['tray_kw_to_hash']['NEvents']
summary['ice_model'] = meta['tray_kw_to_hash']['IceModel']
summary['tilt'] = not meta['tray_kw_to_hash']['DisableTilt']
for key, val in meta.items():
if key.endswith('_binning_kw'):
summary[key] = val
elif 'fname_version' in fname_info and fname_info['fname_version'] == 1:
summary['n_events'] = fname_info['n_events']
summary['ice_model'] = 'spice_mie'
summary['tilt'] = False
summary['r_binning_kw'] = dict(min=0.0, max=400.0, n_bins=200, power=2)
summary['costheta_binning_kw'] = dict(min=-1, max=1, n_bins=40)
summary['t_binning_kw'] = dict(min=0.0, max=3000.0, n_bins=300)
summary['costhetadir_binning_kw'] = dict(min=-1, max=1, n_bins=20)
summary['deltaphidir_binning_kw'] = dict(min=0.0, max=np.pi, n_bins=20)
# Save marginal distributions and info to file
norm = (
1 / table['n_photons'] /
(SPEED_OF_LIGHT_M_PER_NS / table['phase_refractive_index'] *
np.mean(np.diff(table['t_bin_edges'])))
#* table['angular_acceptance_fract']
* (len(table['costheta_bin_edges']) - 1))
summary['norm'] = norm
dim_names = ('r', 'costheta', 't', 'costhetadir', 'deltaphidir')
n_dims = len(table['table_shape'])
assert n_dims == len(dim_names)
# Apply norm to underflow and overflow so magnitudes can be compared
# relative to plotted marginal distributions
for flow, idx in product(('underflow', 'overflow'), iter(range(n_dims))):
summary[flow][idx] = summary[flow][idx] * norm
wstderr('Finding marginal distributions...\n')
wstderr(' masking off zeros in table...')
t0 = time()
nonzero_table = np.ma.masked_equal(table['table'], 0)
wstderr(' ({} ms)\n'.format(np.round((time() - t0) * 1e3, 3)))
t0_marg = time()
summary['dimensions'] = OrderedDict()
for keep_axis, ax_name in zip(tuple(range(n_dims)), dim_names):
remove_axes = list(range(n_dims))
remove_axes.pop(keep_axis)
remove_axes = tuple(remove_axes)
axis = OrderedDict()
wstderr(' mean across non-{} axes...'.format(ax_name))
t0 = time()
axis['mean'] = norm * np.asarray(
np.mean(table['table'], axis=remove_axes))
wstderr(' ({} s)\n'.format(np.round(time() - t0, 3)))
wstderr(' median across non-{} axes...'.format(ax_name))
t0 = time()
axis['median'] = norm * np.asarray(
np.ma.median(nonzero_table, axis=remove_axes))
wstderr(' ({} s)\n'.format(np.round(time() - t0, 3)))
wstderr(' max across non-{} axes...'.format(ax_name))
t0 = time()
axis['max'] = norm * np.asarray(
np.max(table['table'], axis=remove_axes))
wstderr(' ({} s)\n'.format(np.round(time() - t0, 3)))
summary['dimensions'][ax_name] = axis
wstderr(' Total time to find marginal distributions: {} s\n'.format(
np.round(time() - t0_marg, 3)))
if save_summary:
ext = None
base_fname = clsim_fname
while ext not in ('', '.fits'):
base_fname, ext = splitext(base_fname)
ext = ext.lower()
outfpath = join(outdir, base_fname + '_summary.json.bz2')
to_json(summary, outfpath)
print('saved summary to "{}"'.format(outfpath))
wstderr('Time to summarize table: {} s\n'.format(
np.round(time() - t_start, 3)))
return table, summary
#Initialize an oscillation service
logging.info('Using %s oscillation code'%args.code)
if args.code=='prob3':
osc_service = Prob3OscillationService(**settings)
elif args.code=='table':
osc_service = TableOscillationService(**settings)
elif args.code=='nuCraft':
osc_service = NucraftOscillationService(**settings)
else:
raise NotImplementedError('Unknown oscillation service: %s'%args.code)
#Do calculation
logging.info("Calculating oscillation probabilities")
osc_prob_maps = osc_service.get_osc_prob_maps(**vars(args))
#Remove irrelevant parameters from settings
for par in ['verbose', 'outfile', 'ebins', 'czbins']:
settings.pop(par)
#Write out
logging.info("Saving output to: %s",args.outfile)
if fmt=='JSON':
osc_prob_maps['params'] = settings
to_json(osc_prob_maps, args.outfile)
elif fmt=='HDF5':
to_hdf5(osc_prob_maps, args.outfile, settings)
logging.debug('Wrote %.2f MBytes to %s'%
(os.path.getsize(args.outfile)/(1024.**2),
os.path.basename(args.outfile)))
