def run_analysis(self, argv): """Run this analysis""" args = self._parser.parse_args(argv) limitfile = args.limitfile first = args.seed last = first + args.nsims flist = [limitfile.replace("_SEED.fits", "_%06i.fits" % seed)\ for seed in range(first, last)] spec_config = load_yaml(args.specconfig) specs = spec_config['specs'] sum_specs = specs.copy() outfile = args.outfile summaryfile = args.summaryfile hdus = sum_specs + ['INDICES'] out_tables, out_names = vstack_tables(flist, hdus) if is_not_null(outfile): fits_utils.write_tables_to_fits(outfile, out_tables, namelist=out_names) if is_not_null(summaryfile): summary_tables = [] for ot in out_tables[0:-1]: summary_table = summarize_limits_results(ot) summary_tables.append(summary_table) summary_tables.append(Table(out_tables[-1][0])) fits_utils.write_tables_to_fits(summaryfile, summary_tables, namelist=out_names)
def write_fits(self, filepath, clobber=False): """ Write this object to a FITS file Paramters --------- filepath : str Path to output file clobber : bool Flag to allow overwriting existing files """ tables = [self._e_table] tablenames = ["EBOUNDS"] ref_cards = [{}] for key, val in self._s_tables.items(): tables.append(val) tablenames.append(key) ref_cards.append(self._ref_val_dict[key]) fits_utils.write_tables_to_fits(filepath, tables, clobber=clobber, namelist=tablenames, cardslist=ref_cards)
def write_stacked(basedir, roster_name, stacked_dict, jprior_key, clobber): """ Write the stacked DMCastroData object to a FITS file """ outdir = os.path.join(basedir, "stacked") try: os.makedirs(outdir) except OSError: pass outpath = os.path.join( outdir, "results_%s_%s.fits" % (roster_name, jprior_key)) print("Writing stacked results %s" % outpath) channels = stacked_dict.keys() t_list = [] n_list = [] mass_table = None for chan in channels: stacked = stacked_dict[chan] if mass_table is None: mass_table = stacked.build_mass_table() t_list.append(stacked.build_scandata_table()) n_list.append(chan) t_list.append(mass_table) n_list.append("MASSES") fits_utils.write_tables_to_fits(outpath, t_list, clobber=clobber, namelist=n_list)
def run_analysis(self, argv): """Run this analysis""" args = self._parser.parse_args(argv) channels = [ 'ee', 'mumu', 'tautau', 'bb', 'tt', 'gg', 'ww', 'zz', 'cc', 'uu', 'dd', 'ss' ] norm_type = 'eflux' spec_table = DMSpecTable.create_from_fits(args.spec) profile = load_yaml(args.profile_yaml) j_value = profile.get('j_integ') j_sigma = profile.get('j_sigma', None) if args.jprior is None or args.jprior == 'None' or j_sigma is None or j_sigma == 0.0: j_factor = j_value j_prior_key = 'none' else: j_factor = dict(functype=args.jprior, j_value=j_value, mu=j_value, sigma=j_sigma) j_prior_key = args.jprior sed = CastroData.create_from_sedfile(args.sed_file, norm_type) c_list, t_list, n_list = DMCastroConvertor.convert_sed_to_dm( spec_table, sed, channels, norm_type, j_factor) fits_utils.write_tables_to_fits(args.outfile, t_list, clobber=args.clobber, namelist=n_list)
def write_fits(self, filepath, clobber=False): """ Write this object to a FITS file """ fits_utils.write_tables_to_fits(filepath, [self._e_table, self._s_table], clobber=clobber, namelist=["EBOUNDS", "SPECDATA"], cardslist=[{}, self._ref_vals])
def write_fits_files(stacked_dict, resultsfile, limitfile, clobber=False): """ Write the stacked DMCastroData object and limits a FITS files Parameters ---------- stacked_dict : dict Dictionary of `DMCastroData` objects, keyed by channel resultsfile : str Path to the output file to write the `DMCastroData` objects to limitfile : str Path to write the upper limits to clobber : bool Overwrite existing files """ channels = list(stacked_dict.keys()) t_list = [] n_list = [] lim_list = [] lim_table_list = [] mass_table = None alphas = [0.68, 0.95] for chan in channels: is_decay = chan.find('_decay') >= 0 stacked = stacked_dict[chan] mles = stacked.mles() limit_dict = dict(mles=mles) for alpha in alphas: if is_decay: limits = stacked.getLimits(1. - alpha) limit_dict['ll_%.02f' % alpha] = limits else: limits = stacked.getLimits(alpha) limit_dict['ul_%.02f' % alpha] = limits tab_limits = stacked.build_limits_table(limit_dict) if mass_table is None: mass_table = stacked.build_mass_table() t_list.append(stacked.build_scandata_table()) n_list.append(chan) lim_list.append(limit_dict) lim_table_list.append(tab_limits) t_list.append(mass_table) lim_table_list.append(mass_table) n_list.append("MASSES") fits_utils.write_tables_to_fits(resultsfile, t_list, clobber=clobber, namelist=n_list) fits_utils.write_tables_to_fits(limitfile, lim_table_list, clobber=clobber, namelist=n_list)
def write_table_file(self, table_file=None): """Write the table to self._table_file""" if self._table is None: raise RuntimeError("No table to write") if table_file is not None: self._table_file = table_file if self._table_file is None: raise RuntimeError("No output file specified for table") write_tables_to_fits(self._table_file, [self._table], clobber=True, namelist=['FILE_ARCHIVE'])
def write_table_file(self, job_table_file=None, file_table_file=None): """Write the table to self._table_file""" if self._table is None: raise RuntimeError("No table to write") if self._table_ids is None: raise RuntimeError("No ID table to write") if job_table_file is not None: self._table_file = table_file if self._table_file is None: raise RuntimeError("No output file specified for table") write_tables_to_fits(self._table_file, [self._table, self._table_ids], clobber=True, namelist=['JOB_ARCHIVE', 'FILE_IDS']) self._file_archive.write_table_file(file_table_file)
def write_table_file(self, job_table_file=None, file_table_file=None): """Write the table to self._table_file""" if self._table is None: raise RuntimeError("No table to write") if self._table_ids is None: raise RuntimeError("No ID table to write") if job_table_file is not None: self._table_file = job_table_file if self._table_file is None: raise RuntimeError("No output file specified for table") write_tables_to_fits(self._table_file, [self._table, self._table_ids], clobber=True, namelist=['JOB_ARCHIVE', 'FILE_IDS']) self._file_archive.write_table_file(file_table_file)
def write_fits(self, filepath, clobber=False): """ Write this object to a FITS file Paramters --------- filepath : str Path to output file clobber : bool Flag to allow overwriting existing files """ fits_utils.write_tables_to_fits(filepath, [self._e_table, self._s_table], clobber=clobber, namelist=["EBOUNDS", "SPECDATA"], cardslist=[{}, self._ref_vals])
def write_fits_files(stacked_dict, resultsfile, limitfile, clobber=False): """ Write the stacked StackCastroData object and limits a FITS files Parameters ---------- stacked_dict : dict Dictionary of `StackCastroData` objects, keyed by spec resultsfile : str Path to the output file to write the `StackCastroData` objects to limitfile : str Path to write the upper limits to clobber : bool Overwrite existing files """ specs = stacked_dict.keys() t_list = [] n_list = [] lim_list = [] lim_table_list = [] alphas = [0.68, 0.95] for spec in specs: stacked = stacked_dict[spec] mles = stacked.mles() limit_dict = dict(mles=mles) for alpha in alphas: limits = stacked.getLimits(alpha) limit_dict['ul_%.02f' % alpha] = limits tab_limits = stacked.build_limits_table(limit_dict) t_list.append(stacked.build_scandata_table()) n_list.append(spec) lim_list.append(limit_dict) lim_table_list.append(tab_limits) fits_utils.write_tables_to_fits(resultsfile, t_list, clobber=clobber, namelist=n_list) fits_utils.write_tables_to_fits(limitfile, lim_table_list, clobber=clobber, namelist=n_list)
def run_analysis(self, argv): """Run this analysis""" args = self._parser.parse_args(argv) limitfile = args.limitfile first = args.seed last = first + args.nsims flist = [limitfile.replace("_SEED.fits", "_%06i.fits" % seed)\ for seed in range(first, last)] spec_config = load_yaml(args.specconfig) channels = spec_config['channels'] sum_chans = CollectLimits.select_channels(channels, limitfile) outfile = args.outfile summaryfile = args.summaryfile hdus = sum_chans + ['MASSES'] out_tables, out_names = vstack_tables(flist, hdus) if is_not_null(outfile): fits_utils.write_tables_to_fits(outfile, out_tables, namelist=out_names) if is_not_null(summaryfile): summary_tables = [] for ot, chan in zip(out_tables[0:-1], sum_chans): decay = chan.find('_decay') >= 0 summary_table = summarize_limits_results(ot, decay) summary_tables.append(summary_table) summary_tables.append(Table(out_tables[-1][0])) fits_utils.write_tables_to_fits(summaryfile, summary_tables, namelist=out_names)
def main(): """ Hook for command line access """ # Argument defintion usage = "usage: %(prog)s [input]" description = "Collect all the new source" parser = argparse.ArgumentParser(usage=usage, description=description) parser.add_argument('--input', '-i', default='roi_set.yaml', help='ROI set definition file.') parser.add_argument('--output', '-o', type=argparse.FileType('w'), help='Output file.') parser.add_argument('--clobber', action='store_true', help='Overwrite output file.') parser.add_argument('--targets', '-t', type=str, help='Target file.') parser.add_argument('--filestr', '-f', default="tscube.fits", help="Name of file within each ROI sub-directory") # Argument parsing args = parser.parse_args() # Read the target file targ_type = os.path.splitext(args.targets)[1] print targ_type if targ_type in ['.fit', '.fits']: targets = DMTargetFactory.read_table(args.targets) roster = None else: targets, roster = DMTargetFactory.make_table([args.targets]) # Get the sky_crds sky_crds = DMTargetFactory.get_sky_crds(targets) # Make the roi_set object roi_set, basedir = dmp_roi.DMROISet.create_from_yaml(args.input) # extract the data out_table = roi_set.extract_table_data(sky_crds, args.filestr, basedir=basedir, tables=["SCANDATA", "FITDATA"]) # add_names_column(out_table,targets['name']) col_names = [ 'name', 'ra', 'dec', 'distance', 'proftype', 'glat', 'glon', 'j_integ', 'd_integ' ] add_columns(out_table, targets, col_names) ebounds_table = roi_set.extract_single_table(args.filestr, basedir=basedir, table="EBOUNDS") # Write the output fits_utils.write_tables_to_fits(args.output, [out_table, ebounds_table], clobber=args.clobber, namelist=["SCANDATA", "EBOUNDS"])
def convert_sed(spec_table, channels, sed_file, outfile, limitfile, **kwargs): """Convert a single SED to DM space. Parameters ---------- spec_table : `DMSpecTable` Object with all the DM spectra channels : list List of the channels to convert sed_file : str Path to the SED file outfile : str Path to write the output `DMCastroData` object to limitfile : str Path to write the output limits to. Keyword arguments ----------------- norm_type : str Normalization type to use j_factor : dict Dictionary with information about the J-factor d_factor : dict Dictionary with information about the J-factor clobber : bool Flag to overwrite existing files. """ norm_type = kwargs.get('norm_type', 'eflux') j_factor = kwargs.get('j_factor', None) d_factor = kwargs.get('d_factor', None) clobber = kwargs.get('clobber', False) use_chans = ConvertCastro.select_channels(channels, sed_file) exttype = os.path.splitext(sed_file)[-1] if exttype in ['.fits', '.npy']: sed = CastroData.create_from_sedfile(sed_file, norm_type) elif exttype in ['.yaml']: sed = CastroData.create_from_yamlfile(sed_file) else: raise ValueError("Can not read file type %s for SED" % exttype) c_list, t_list, n_list = ConvertCastro.convert_sed_to_dm( spec_table, sed, use_chans, norm_type=norm_type, j_val=j_factor, d_val=d_factor) if is_not_null(outfile): fits_utils.write_tables_to_fits(outfile, t_list, clobber=clobber, namelist=n_list) if is_not_null(limitfile): mass_table = t_list[-1] _, t_list_lim, n_list_lim = ConvertCastro.extract_dm_limits( c_list, use_chans, [0.68, 0.95], mass_table) fits_utils.write_tables_to_fits(limitfile, t_list_lim, clobber=clobber, namelist=n_list_lim)
def convert_sed(spec_table, specs, sed_file, outfile, limitfile, **kwargs): """Convert a single SED to stacking space. Parameters ---------- spec_table : `StackSpecTable` Object with all the stacking spectra specs : list List of the specs to convert sed_file : str Path to the SED file outfile : str Path to write the output `StackCastroData` object to limitfile : str Path to write the output limits to. Keyword arguments ----------------- norm_type : str Normalization type to use astro_val : dict Dictionary with information about the astrophysical norm clobber : bool Flag to overwrite existing files. """ norm_type = kwargs.get('norm_type', 'eflux') astro_val = kwargs.get('astro_val', None) clobber = kwargs.get('clobber', False) use_specs = specs exttype = os.path.splitext(sed_file)[-1] if exttype in ['.fits', '.npy']: sed = CastroData.create_from_sedfile(sed_file, norm_type) elif exttype in ['.yaml']: sed = CastroData.create_from_yamlfile(sed_file) else: raise ValueError("Can not read file type %s for SED" % exttype) c_list, t_list, n_list = ConvertCastro.convert_sed_to_stack_var( spec_table, sed, norm_type=norm_type, astro_val=astro_val) if is_not_null(outfile): fits_utils.write_tables_to_fits(outfile, t_list, clobber=clobber, namelist=n_list) if is_not_null(limitfile): stacked_lists = ConvertCastro.extract_stack_limits( c_list, use_specs, [0.68, 0.95]) fits_utils.write_tables_to_fits(limitfile, stacked_lists[1], clobber=clobber, namelist=stacked_lists[2])