fermipy.diffuse subpackage

fermipy.diffuse.binning module

Small helper class to represent the binning used for a single component of a summed likelihood in diffuse analysis

class fermipy.diffuse.binning.Component(**kwargs)[source]

Bases: object

Small helper class to represent the binning used for a single component of a summed likelihood in diffuse analysis

Parameters:
  • log_emin (float) – Log base 10 of minimum energy for this component
  • log_emax (float) – Log base 10 of maximum energy for this component
  • enumbins (int) – Number of energy bins for this component
  • zmax (float) – Maximum zenith angle cube for this component in degrees
  • mktimefilters (list) – Filters for gtmktime.
  • hpx_order (int) – HEALPix order to use for this component
classmethod build_from_energy_dict(ebin_name, input_dict)[source]

Build a list of components from a dictionary for a single energy range

classmethod build_from_yamlfile(yamlfile)[source]

Build a list of components from a yaml file

classmethod build_from_yamlstr(yamlstr)[source]

Build a list of components from a yaml string

emax

Maximum energy for this component

emin

Minimum energy for this component

evtype

Event type bit mask for this component

make_key(format_str)[source]

Make a key to identify this compoment

format_str is formatted using object __dict__

fermipy.diffuse.defaults module

Analysis framework for all-sky diffuse emission fitting

fermipy.diffuse.name_policy module

Handle the naming conventions for composite likelihood analysis

class fermipy.diffuse.name_policy.NameFactory(**kwargs)[source]

Bases: object

Helper class to define file names and keys consistently.

angprofile(**kwargs)[source]

return the file name for sun or moon angular profiles

angprofile_format = 'templates/profile_{sourcekey}.fits'
bexpcube(**kwargs)[source]

return the name of a binned exposure cube file

bexpcube_format = 'bexp_cubes/bexcube_{dataset}_{mktime}_{component}_{coordsys}_{irf_ver}.fits'
bexpcube_moon(**kwargs)[source]

return the name of a binned exposure cube file

bexpcube_sun(**kwargs)[source]

return the name of a binned exposure cube file

bexpcubemoon_format = 'bexp_cubes/bexcube_{dataset}_{mktime}_{component}_{irf_ver}_moon.fits'
bexpcubesun_format = 'bexp_cubes/bexcube_{dataset}_{mktime}_{component}_{irf_ver}_sun.fits'
catalog_split_yaml(**kwargs)[source]

return the name of a catalog split yaml file

catalog_split_yaml_format = 'models/{sourcekey}.yaml'
ccube(**kwargs)[source]

return the name of a counts cube file

ccube_format = 'counts_cubes/ccube_{dataset}_{mktime}_{component}_{coordsys}.fits'
comp_srcmdl_xml(**kwargs)[source]

return the name of a source model file

comp_srcmdl_xml_format = 'analysis/model_{modelkey}/srcmdl_{modelkey}_{component}.xml'
component(**kwargs)[source]

Return a key that specifies data the sub-selection

component_format = '{zcut}_{ebin}_{psftype}'
dataset(**kwargs)[source]

Return a key that specifies the data selection

dataset_format = '{data_pass}_{data_ver}_{data_time}_{evclass}'
diffuse_template(**kwargs)[source]

return the file name for other diffuse map templates

diffuse_template_format = 'templates/template_{sourcekey}.fits'
ft1file(**kwargs)[source]

return the name of the input ft1 file list

ft1file_format = '{dataset}_{zcut}.lst'
ft2file(**kwargs)[source]

return the name of the input ft2 file list

ft2file_format = 'ft2_files/ft2_{data_time}.lst'
fullpath(**kwargs)[source]

Return a full path name for a given file

fullpath_format = '{basedir}/{localpath}'
galprop_gasmap(**kwargs)[source]

return the file name for Galprop input gasmaps

galprop_gasmap_format = 'gasmap/{sourcekey}_{projtype}_{galprop_run}_{maptype}.fits.gz'
galprop_ringkey(**kwargs)[source]

return the sourcekey for galprop input maps : specifies the component and ring

galprop_ringkey_format = '{source_name}_{ringkey}'
galprop_rings_yaml(**kwargs)[source]

return the name of a galprop rings merging yaml file

galprop_rings_yaml_format = 'models/galprop_rings_{galkey}.yaml'
galprop_sourcekey(**kwargs)[source]

return the sourcekey for merged galprop maps : specifies the merged component and merging scheme

galprop_sourcekey_format = '{source_name}_{galpropkey}'
generic(input_string, **kwargs)[source]

return a generic filename for a given dataset and component

irfs(**kwargs)[source]

Get the name of IFRs associted with a particular dataset

ltcube(**kwargs)[source]

return the name of a livetime cube file

ltcube_format = 'lt_cubes/ltcube_{data_time}_{mktime}_{zcut}.fits'
ltcube_moon(**kwargs)[source]

return the name of a livetime cube file

ltcube_sun(**kwargs)[source]

return the name of a livetime cube file

ltcubemoon_format = 'sunmoon/ltcube_{data_time}_{mktime}_{zcut}_moon.fits'
ltcubesun_format = 'sunmoon/ltcube_{data_time}_{mktime}_{zcut}_sun.fits'
make_filenames(**kwargs)[source]

Make a dictionary of filenames for various types

master_srcmdl_xml(**kwargs)[source]

return the name of a source model file

master_srcmdl_xml_format = 'analysis/model_{modelkey}/srcmdl_{modelkey}_master.xml'
mcube(**kwargs)[source]

return the name of a model cube file

mcube_format = 'model_cubes/mcube_{sourcekey}_{dataset}_{mktime}_{component}_{coordsys}_{irf_ver}.fits'
merged_gasmap(**kwargs)[source]

return the file name for Galprop merged gasmaps

merged_gasmap_format = 'merged_gasmaps/{sourcekey}_{projtype}_{maptype}.fits'
merged_sourcekey(**kwargs)[source]

return the sourcekey for merged sets of point sources : specifies the catalog and merging rule

merged_sourcekey_format = '{catalog}_{rulekey}'
merged_srcmaps(**kwargs)[source]

return the name of a source map file

merged_srcmaps_format = 'analysis/model_{modelkey}/srcmaps_{dataset}_{mktime}_{component}_{coordsys}_{irf_ver}.fits'
mktime(**kwargs)[source]

return the name of a selected events ft1file

mktime_format = 'counts_cubes/mktime_{dataset}_{mktime}_{component}.fits'
model_yaml(**kwargs)[source]

return the name of a model yaml file

model_yaml_format = 'models/model_{modelkey}.yaml'
nested_srcmdl_xml(**kwargs)[source]

return the file name for source model xml files of nested sources

nested_srcmdl_xml_format = 'srcmdls/{sourcekey}_sources.xml'
residual_cr(**kwargs)[source]

Return the name of the residual CR analysis output files

residual_cr_format = 'residual_cr/residual_cr_{dataset}_{mktime}_{component}_{coordsys}_{irf_ver}.fits'
select(**kwargs)[source]

return the name of a selected events ft1file

select_format = 'counts_cubes/select_{dataset}_{component}.fits'
sourcekey(**kwargs)[source]

Return a key that specifies the name and version of a source or component

sourcekey_format = '{source_name}_{source_ver}'
spectral_template(**kwargs)[source]

return the file name for spectral templates

spectral_template_format = 'templates/spectral_{sourcekey}.txt'
srcmaps(**kwargs)[source]

return the name of a source map file

srcmaps_format = 'srcmaps/srcmaps_{sourcekey}_{dataset}_{mktime}_{component}_{coordsys}_{irf_ver}.fits'
srcmdl_xml(**kwargs)[source]

return the file name for source model xml files

srcmdl_xml_format = 'srcmdls/{sourcekey}.xml'
stamp(**kwargs)[source]

Return the path for a stamp file for a scatter gather job

stamp_format = 'stamps/{linkname}.stamp'
template_sunmoon(**kwargs)[source]

return the file name for sun or moon template files

templatesunmoon_format = 'templates/template_{sourcekey}_{zcut}.fits'
update_base_dict(yamlfile)[source]

Update the values in baseline dictionary used to resolve names

fermipy.diffuse.spectral module

Classes and utilities that manage spectral model specific to diffuse analyses

class fermipy.diffuse.spectral.SpectralLibrary(spectral_dict)[source]

Bases: object

A small helper class that serves as an alias dictionary for spectral models

classmethod create_from_yaml(yamlfile)[source]

Create the dictionary for a yaml file

classmethod create_from_yamlstr(yamlstr)[source]

Create the dictionary for a yaml file

update(spectral_dict)[source]

Update the dictionary

fermipy.diffuse.source_factory module

Classes and utilities that create fermipy source objects

class fermipy.diffuse.source_factory.SourceFactory[source]

Bases: object

Small helper class to build and keep track of sources

add_sources(source_info_dict)[source]

Add all of the sources in source_info_dict to this factory

static build_catalog(catalog_type, catalog_file, catalog_extdir, **kwargs)[source]

Build a fermipy.catalog.Catalog object

Parameters:
  • catalog_type (str) – Specifies catalog type, options include 2FHL | 3FGL | 4FGLP
  • catalog_file (str) – FITS file with catalog tables
  • catalog_extdir (str) – Path to directory with extended source templates
classmethod copy_selected_sources(roi, source_names)[source]

Build and return a fermipy.roi_model.ROIModel object by copying selected sources from another such object

static make_fermipy_roi_model_from_catalogs(cataloglist)[source]

Build and return a fermipy.roi_model.ROIModel object from a list of fermipy.catalog.Catalog objects

classmethod make_roi(sources={})[source]

Build and return a fermipy.roi_model.ROIModel object from a dict with information about the sources

source_info_dict

Return the dictionary of source_info objects used to build sources

sources

Return the dictionary of sources

fermipy.diffuse.source_factory.make_catalog_sources(catalog_roi_model, source_names)[source]

Construct and return dictionary of sources that are a subset of sources in catalog_roi_model.

Parameters:
  • catalog_roi_model (dict or fermipy.roi_model.ROIModel) – Input set of sources
  • source_names (list) – Names of sourcs to extract
  • dict mapping source_name to fermipy.roi_model.Source object (Returns) –
fermipy.diffuse.source_factory.make_composite_source(name, catalog_roi_model, spectrum, nested_source_names)[source]

Construct and return a fermipy.roi_model.CompositeSource object

fermipy.diffuse.source_factory.make_isotropic_source(name, Spectrum_Filename, spectrum)[source]

Construct and return a fermipy.roi_model.IsoSource object

fermipy.diffuse.source_factory.make_mapcube_source(name, Spatial_Filename, spectrum)[source]

Construct and return a fermipy.roi_model.MapCubeSource object

fermipy.diffuse.source_factory.make_point_source(name, src_dict)[source]

Construct and return a fermipy.roi_model.Source object

fermipy.diffuse.source_factory.make_sources(comp_key, comp_dict)[source]

Make dictionary mapping component keys to a source or set of sources

Parameters:
  • comp_key (str) – Key used to access sources
  • comp_dict (dict) – Information used to build sources
  • OrderedDict maping comp_key to fermipy.roi_model.Source (return) –

fermipy.diffuse.catalog_src_manager module

Classes and utilities that manage catalog sources

class fermipy.diffuse.catalog_src_manager.CatalogComponentChain(linkname)[source]

Bases: fermipy.jobs.chain.Chain

Small class to build srcmaps for diffuse components

default_options = {'sources': (None, 'Path to yaml file defining catalog components.', <type 'str'>), 'make_xml': (False, 'Make XML files for diffuse components', <type 'bool'>), 'data': (None, 'Path to yaml file defining dataset.', <type 'str'>), 'dry_run': (False, 'Print commands but do not run them', <type 'bool'>), 'comp': (None, 'Path to yaml file defining binning.', <type 'str'>)}
run_argparser(argv)[source]

Initialize a link with a set of arguments using argparser

class fermipy.diffuse.catalog_src_manager.CatalogSourceManager(**kwargs)[source]

Bases: object

Small helper class to keep track of how we deal with catalog sources

This keeps track of two dictionaries

One of the dictionaries is keyed by catalog name, and contains information about complete catalogs catalog_comp_info_dicts[catalog_name] : model_component.CatalogInfo

The other dictionary is keyed by [{catalog_name}_{split_ver}][{split_key}] Where: {catalog_name} is something like ‘3FGL’ {split_ver} is somthing like ‘v00’ and specifes how to divide sources in the catalog {split_key} refers to a specific sub-selection of sources

split_comp_info_dicts[splitkey] : model_component.ModelComponentInfo

build_catalog_info(catalog_info)[source]

Build a CatalogInfo object

catalog_comp_info_dict(catkey)[source]

Return the roi_model for an entire catalog

catalog_components(catalog_name, split_ver)[source]

Return the set of merged components for a particular split key

catalogs()[source]

Return the list of full catalogs used

make_catalog_comp_info(full_cat_info, split_key, rule_key, rule_val, sources)[source]

Make the information about a single merged component

Parameters:
  • full_cat_info (_model_component.CatalogInfo) – Information about the full catalog
  • split_key (str) – Key identifying the version of the spliting used
  • rule_key (str) – Key identifying the specific rule for this component
  • rule_val (list) – List of the cuts used to define this component
  • sources (list) – List of the names of the sources in this component
  • CompositeSourceInfo or CatalogSourcesInfo (Returns) –
make_catalog_comp_info_dict(catalog_sources)[source]

Make the information about the catalog components

Parameters:catalog_sources (dict) – Dictionary with catalog source defintions
Returns:
  • catalog_ret_dict (dict) – Dictionary mapping catalog_name to model_component.CatalogInfo
  • split_ret_dict (dict) – Dictionary mapping sourcekey to model_component.ModelComponentInfo
read_catalog_info_yaml(splitkey)[source]

Read the yaml file for a particular split key

split_comp_info(catalog_name, split_ver, split_key)[source]

Return the info for a particular split key

split_comp_info_dict(catalog_name, split_ver)[source]

Return the information about a particular scheme for how to handle catalog sources

splitkeys()[source]

Return the list of catalog split keys used

fermipy.diffuse.catalog_src_manager.create_chain_catalog_comps(**kwargs)[source]

Create and return a CatalogComponentChain object

fermipy.diffuse.catalog_src_manager.main_chain()[source]

Entry point for command line use for single job

fermipy.diffuse.catalog_src_manager.make_catalog_comp_dict(**kwargs)[source]

Build and return the information about the catalog components

fermipy.diffuse.catalog_src_manager.make_mask(cat_table, cut)[source]

Mask a bit mask selecting the rows that pass a selection

fermipy.diffuse.catalog_src_manager.mask_extended(cat_table)[source]

Remove rows representing extended sources from a catalog table

fermipy.diffuse.catalog_src_manager.select_extended(cat_table)[source]

Select only rows representing extended sources from a catalog table

fermipy.diffuse.catalog_src_manager.select_sources(cat_table, cuts)[source]

Select only rows passing a set of cuts from catalog table

fermipy.diffuse.diffuse_src_manager module

Classes and utilities that manage the diffuse emission background models

class fermipy.diffuse.diffuse_src_manager.DiffuseComponentChain(linkname, **kwargs)[source]

Bases: fermipy.jobs.chain.Chain

Small class to build srcmaps for diffuse components

default_options = {'make_xml': (False, 'Make XML files for diffuse components', <type 'bool'>), 'data': (None, 'Path to yaml file defining dataset.', <type 'str'>), 'diffuse': (None, 'Path to yaml file defining diffuse components.', <type 'str'>), 'dry_run': (False, 'Print commands but do not run them', <type 'bool'>), 'comp': (None, 'Path to yaml file defining binning.', <type 'str'>)}
run_argparser(argv)[source]

Initialize a link with a set of arguments using argparser

class fermipy.diffuse.diffuse_src_manager.DiffuseModelManager(**kwargs)[source]

Bases: object

Small helper class to keep track of diffuse component templates

This keeps track of the ‘diffuse component infomation’ dictionary

This keyed by: key = {source_name}_{source_ver} Where: {source_name} is something like ‘loopI’ {source_ver} is somthinng like v00

The dictioary is diffuse_comp_info_dict[key] - > model_component.ModelComponentInfo

Note that some components ( those that represent moving sources or are selection depedent ) will have a sub-dictionary of diffuse_comp_info_dict object for each sub-component

The compoents are defined in a file called config/diffuse_components.yaml

diffuse_comp_info(sourcekey)[source]

Return the Component info associated to a particular key

make_diffuse_comp_info(source_name, source_ver, diffuse_dict, components=None, comp_key=None)[source]

Make a dictionary mapping the merged component names to list of template files

Parameters:
  • source_name (str) – Name of the source
  • source_ver (str) – Key identifying the version of the source
  • diffuse_dict (dict) – Information about this component
  • comp_key (str) – Used when we need to keep track of sub-components, i.e., for moving and selection dependent sources.
  • model_component.ModelComponentInfo or (Returns) –
  • model_component.IsoComponentInfo
make_diffuse_comp_info_dict(diffuse_sources, components)[source]

Make a dictionary maping from diffuse component to information about that component

Parameters:
  • diffuse_sources (dict) – Dictionary with diffuse source defintions
  • components (dict) – Dictionary with event selection defintions, needed for selection depenedent diffuse components
Returns:

ret_dict – Dictionary mapping sourcekey to model_component.ModelComponentInfo

Return type:

dict

make_template_name(model_type, sourcekey)[source]

Make the name of a template file for particular component

Parameters:
  • model_type (str) – Type of model to use for this component
  • sourcekey (str) – Key to identify this component
  • filename or None if component does not require a template file (Returns) –
make_xml_name(sourcekey)[source]

Make the name of an xml file for a model definition of a single component

Parameters:sourcekey (str) – Key to identify this component
static read_diffuse_component_yaml(yamlfile)[source]

Read the yaml file for the diffuse components

sourcekeys()[source]

Return the list of source keys

class fermipy.diffuse.diffuse_src_manager.GalpropMapManager(**kwargs)[source]

Bases: object

Small helper class to keep track of Galprop gasmaps

This keeps track of two types of dictionaries. Both are keyed by: key = {source_name}_{ring}_{galkey}

Where: {source_name} is something like ‘merged_C0’ {ring} is the ring index {galkey} is a key specifying which version of galprop rings to use.

The two dictionaries are: ring_dict[key] = model_component.GalpropMergedRingInfo diffuse_comp_info_dict[key] ] model_component.ModelComponentInfo

The dictionaries are defined in files called. models/galprop_rings_{galkey}.yaml

diffuse_comp_info_dicts(galkey)[source]

Return the components info dictionary for a particular galprop key

galkeys()[source]

Return the list of galprop keys used

make_diffuse_comp_info(merged_name, galkey)[source]

Make the information about a single merged component

Parameters:
  • merged_name (str) – The name of the merged component
  • galkey (str) – A short key identifying the galprop parameters
  • odel_component.ModelComponentInfo (Returns) –
make_diffuse_comp_info_dict(galkey)[source]

Make a dictionary maping from merged component to information about that component

Parameters:galkey (str) – A short key identifying the galprop parameters
make_merged_name(source_name, galkey, fullpath)[source]

Make the name of a gasmap file for a set of merged rings

Parameters:
  • source_name (str) – The galprop component, used to define path to gasmap files
  • galkey (str) – A short key identifying the galprop parameters
  • fullpath (bool) – Return the full path name
make_ring_dict(galkey)[source]

Make a dictionary mapping the merged component names to list of template files

Parameters:
  • galkey (str) – Unique key for this ring dictionary
  • model_component.GalpropMergedRingInfo (Returns) –
make_ring_filelist(sourcekeys, rings, galprop_run)[source]

Make a list of all the template files for a merged component

Parameters:
  • sourcekeys (list-like of str) – The names of the componenents to merge
  • rings (list-like of int) – The indices of the rings to merge
  • galprop_run (str) – String identifying the galprop parameters
make_ring_filename(source_name, ring, galprop_run)[source]

Make the name of a gasmap file for a single ring

Parameters:
  • source_name (str) – The galprop component, used to define path to gasmap files
  • ring (int) – The ring index
  • galprop_run (str) – String identifying the galprop parameters
make_xml_name(source_name, galkey, fullpath)[source]

Make the name of an xml file for a model definition for a set of merged rings

Parameters:
  • source_name (str) – The galprop component, used to define path to gasmap files
  • galkey (str) – A short key identifying the galprop parameters
  • fullpath (bool) – Return the full path name
merged_components(galkey)[source]

Return the set of merged components for a particular galprop key

read_galprop_rings_yaml(galkey)[source]

Read the yaml file for a partiuclar galprop key

ring_dict(galkey)[source]

Return the ring dictionary for a particular galprop key

fermipy.diffuse.diffuse_src_manager.create_chain_diffuse_comps(**kwargs)[source]

Create and return a DiffuseComponentChain object

fermipy.diffuse.diffuse_src_manager.main_chain()[source]

Entry point for command line use for single job

fermipy.diffuse.diffuse_src_manager.make_diffuse_comp_info_dict(**kwargs)[source]

Build and return the information about the diffuse components

fermipy.diffuse.diffuse_src_manager.make_ring_dicts(**kwargs)[source]

Build and return the information about the Galprop rings

fermipy.diffuse.model_component module

Small helper classes that wrap information about model components

class fermipy.diffuse.model_component.CatalogInfo(**kwargs)[source]

Bases: object

Information about a source catalog

Parameters:
  • catalog_name (str) – The name given to the merged component, e.g., merged_CO or merged_HI
  • catalog_file (str) – Fits file with catalog data
  • catalog_extdir (str) – Directory with extended source templates
  • catalog_type (str) – Identifies the format of the catalog fits file: e.g., ‘3FGL’ or ‘4FGLP’
  • catalog (fermipy.catalog.Catalog) – Catalog object
  • roi_model (fermipy.roi_model.ROIModel) – Fermipy object describing all the catalog sources
  • srcmdl_name (str) – Name of xml file with the catalog source model
update(**kwargs)[source]

Update data members from keyword arguments

class fermipy.diffuse.model_component.CatalogSourcesInfo(**kwargs)[source]

Bases: fermipy.diffuse.model_component.ModelComponentInfo

Information about a model component consisting of sources from a catalog

Parameters:
  • source_names (list) – The names of the nested sources
  • catalog_info (model_component.CatalogInfo or None) – Information about the catalog containing the nested sources
  • roi_model (fermipy.roi_model.ROIModel) – Fermipy object describing the nested sources
class fermipy.diffuse.model_component.CompositeSourceInfo(**kwargs)[source]

Bases: fermipy.diffuse.model_component.ModelComponentInfo

Information about a model component represented by a CompositeSource

Parameters:
  • source_names (list) – The names of the nested sources
  • catalog_info (model_component.CatalogInfo or None) – Information about the catalog containing the nested sources
  • roi_model (fermipy.roi_model.ROIModel) – Fermipy object describing the nested sources
class fermipy.diffuse.model_component.GalpropMergedRingInfo(**kwargs)[source]

Bases: object

Information about a set of Merged Galprop Rings

Parameters:
  • source_name (str) – The name given to the merged component, e.g., merged_CO or merged_HI
  • ring (int) – The index of the merged ring
  • sourcekey (str) – Key that identifies this component, e.g., merged_CO_1, or merged_HI_3
  • galkey (str) – Key that identifies how to merge the galprop rings, e.g., ‘ref’
  • galprop_run (str) – Key that idenfifies the galprop run used to make the input rings
  • files (str) – List of files of the input gasmap files
  • merged_gasmap (str) – Filename for the merged gasmap
update(**kwargs)[source]

Update data members from keyword arguments

class fermipy.diffuse.model_component.IsoComponentInfo(**kwargs)[source]

Bases: fermipy.diffuse.model_component.ModelComponentInfo

Information about a model component represented by a IsoSource

Parameters:Spectral_Filename (str) – Name of the template file for the spatial model
class fermipy.diffuse.model_component.MapCubeComponentInfo(**kwargs)[source]

Bases: fermipy.diffuse.model_component.ModelComponentInfo

Information about a model component represented by a MapCubeSource

Parameters:Spatial_Filename (str) – Name of the template file for the spatial model
class fermipy.diffuse.model_component.ModelComponentInfo(**kwargs)[source]

Bases: object

Information about a model component

Parameters:
  • source_name (str) – The name given to the component, e.g., loop_I or moon
  • source_ver (str) – Key to indentify the model version of the source, e.g., v00
  • sourcekey (str) – Key that identifies this component, e.g., loop_I_v00 or moon_v00
  • model_type (str) – Type of model, ‘MapCubeSource’ | ‘IsoSource’ | ‘CompositeSource’ | ‘Catalog’ | ‘PointSource’
  • srcmdl_name (str) – Name of the xml file with the xml just for this component
  • moving (bool) – Flag for moving sources (i.e., the sun and moon)
  • selection_dependent (bool) – Flag for selection dependent sources (i.e., the residual cosmic ray model)
  • components (dict) – Sub-dictionary of ModelComponentInfo objects for moving and selection_dependent sources
  • comp_key (str) – Component key for this component of moving and selection_dependent sources
add_component_info(compinfo)[source]

Add sub-component specific information to a particular data selection

Parameters:compinfo (ModelComponentInfo object) – Sub-component being added
clone_and_merge_sub(key)[source]

Clones self and merges clone with sub-component specific information

Parameters:
  • key (str) – Key specifying which sub-component
  • ModelComponentInfo object (Returns) –
get_component_info(comp)[source]

Return the information about sub-component specific to a particular data selection

Parameters:
  • comp (binning.Component object) – Specifies the sub-component
  • ModelComponentInfo object (Returns) –
update(**kwargs)[source]

Update data members from keyword arguments

class fermipy.diffuse.model_component.PointSourceInfo(**kwargs)[source]

Bases: fermipy.diffuse.model_component.ModelComponentInfo

Information about a model component represented by a PointSource

fermipy.diffuse.model_manager module

Classes and utilities that manage fitting models for diffuse analyses

class fermipy.diffuse.model_manager.ModelComponent(**kwargs)[source]

Bases: object

Small helper class to tie a ModelComponentInfo to a spectrum

class fermipy.diffuse.model_manager.ModelInfo(**kwargs)[source]

Bases: object

Small helper class to keep track of a single fitting model

component_names

Return the list of name of the components

items()[source]

Return the key, value pairs of model components

make_model_rois(components, name_factory)[source]

Make the fermipy roi_model objects for each of a set of binning components

make_srcmap_manifest(components, name_factory)[source]

Build a yaml file that specfies how to make the srcmap files for a particular model

Parameters:
  • components (list) – The binning components used in this analysis
  • name_factory (NameFactory) – Object that handles naming conventions
  • a dictionary that contains information about where to find the (Returns) –
  • maps for each component of the model (source) –
class fermipy.diffuse.model_manager.ModelManager(**kwargs)[source]

Bases: object

Small helper class to create fitting models and manager XML files for fermipy

This class contains a ‘library’, which is a dictionary of all the source components:

specifically it maps:

sourcekey : model_component.ModelComponentInfo

csm

Return the CatalogSourceManager

dmm

Return the DiffuseModelManager

static get_sub_comp_info(source_info, comp)[source]

Build and return information about a sub-component for a particular selection

gmm

Return the GalpropMapManager

make_fermipy_config_yaml(modelkey, components, data, **kwargs)[source]

Build a fermipy top-level yaml configuration file

Parameters:
  • modelkey (str) – Key used to identify this particular model
  • components (list) – The binning components used in this analysis
  • data (str) – Path to file containing dataset definition
make_library(diffuse_yaml, catalog_yaml, binning_yaml)[source]

Build up the library of all the components

Parameters:
  • diffuse_yaml (str) – Name of the yaml file with the library of diffuse component definitions
  • catalog_yaml (str) – Name of the yaml file with the library of catalog split definitions
  • binning_yaml (str) – Name of the yaml file with the binning definitions
make_model_info(modelkey)[source]

Build a dictionary with the information for a particular model.

Parameters:
  • modelkey (str) – Key used to identify this particular model
  • ModelInfo (Return) –
make_srcmap_manifest(modelkey, components, data)[source]

Build a yaml file that specfies how to make the srcmap files for a particular model

Parameters:
  • modelkey (str) – Key used to identify this particular model
  • components (list) – The binning components used in this analysis
  • data (str) – Path to file containing dataset definition
read_model_yaml(modelkey)[source]

Read the yaml file for the diffuse components

fermipy.diffuse.model_manager.make_library(**kwargs)[source]

Build and return a ModelManager object and fill the associated model library

fermipy.diffuse.job_library module

Module to collect configuration to run specific jobs

class fermipy.diffuse.job_library.ConfigMaker_Gtexpcube2(link, **kwargs)[source]

Bases: fermipy.jobs.scatter_gather.ConfigMaker

Small class to generate configurations for gtexpcube2

This takes the following arguments: –comp : binning component definition yaml file –data : datset definition yaml file –irf_ver : IRF verions string (e.g., ‘V6’) –coordsys : Coordinate system [‘GAL’ | ‘CEL’] –hpx_order: HEALPix order parameter

build_job_configs(args)[source]

Hook to build job configurations

default_options = {'irf_ver': ('V6', 'Version of IRFs to use.', <type 'str'>), 'comp': (None, 'Path to yaml file defining binning.', <type 'str'>), 'data': (None, 'Path to yaml file defining dataset.', <type 'str'>), 'coordsys': ('GAL', 'Coordinate system of the spatial projection (CEL or GAL).', <type 'str'>), 'hpx_order_max': (6, 'Maximum HEALPIX order for exposure cubes.', <type 'int'>)}
class fermipy.diffuse.job_library.ConfigMaker_SrcmapsCatalog(link, **kwargs)[source]

Bases: fermipy.jobs.scatter_gather.ConfigMaker

Small class to generate configurations for gtsrcmaps for catalog sources

This takes the following arguments: –comp : binning component definition yaml file –data : datset definition yaml file –irf_ver : IRF verions string (e.g., ‘V6’) –sources : Yaml file with input source model definitions –make_xml : Write xml files for the individual components

build_job_configs(args)[source]

Hook to build job configurations

default_options = {'irf_ver': ('V6', 'Version of IRFs to use.', <type 'str'>), 'sources': (None, 'Path to yaml file defining catalog components.', <type 'str'>), 'make_xml': (False, 'Write xml files needed to make source maps', <type 'bool'>), 'data': (None, 'Path to yaml file defining dataset.', <type 'str'>), 'comp': (None, 'Path to yaml file defining binning.', <type 'str'>)}
class fermipy.diffuse.job_library.ConfigMaker_SumRings(link, **kwargs)[source]

Bases: fermipy.jobs.scatter_gather.ConfigMaker

Small class to generate configurations for fermipy-coadd to sum galprop ring gasmaps

This takes the following arguments: –diffuse : Diffuse model component definition yaml file –outdir : Output directory

build_job_configs(args)[source]

Hook to build job configurations

default_options = {'diffuse': (None, 'Path to yaml file defining diffuse components.', <type 'str'>), 'outdir': (None, 'Output directory', <type 'str'>)}
class fermipy.diffuse.job_library.ConfigMaker_Vstack(link, **kwargs)[source]

Bases: fermipy.jobs.scatter_gather.ConfigMaker

Small class to generate configurations for fermipy-vstack to merge source maps

This takes the following arguments: –comp : binning component definition yaml file –data : datset definition yaml file –irf_ver : IRF verions string (e.g., ‘V6’) –diffuse : Diffuse model component definition yaml file’

build_job_configs(args)[source]

Hook to build job configurations

default_options = {'irf_ver': ('V6', 'Version of IRFs to use.', <type 'str'>), 'comp': (None, 'Path to yaml file defining binning.', <type 'str'>), 'data': (None, 'Path to yaml file defining dataset.', <type 'str'>), 'diffuse': (None, 'Path to yaml file defining diffuse components.', <type 'str'>)}
class fermipy.diffuse.job_library.ConfigMaker_healview(link, **kwargs)[source]

Bases: fermipy.jobs.scatter_gather.ConfigMaker

Small class to generate configurations for fermipy-healview to display source maps

This takes the following arguments: –comp : binning component definition yaml file –data : datset definition yaml file –irf_ver : IRF verions string (e.g., ‘V6’) –diffuse : Diffuse model component definition yaml file’

build_job_configs(args)[source]

Hook to build job configurations

default_options = {'irf_ver': ('V6', 'Version of IRFs to use.', <type 'str'>), 'comp': (None, 'Path to yaml file defining binning.', <type 'str'>), 'data': (None, 'Path to yaml file defining dataset.', <type 'str'>), 'diffuse': (None, 'Path to yaml file defining diffuse components.', <type 'str'>)}

Make a fermipy.jobs.Link object to run fermipy-coadd

Make a fermipy.jobs.Link object to run fermipy-healview

Make a fermipy.jobs.Link object to run fermipy-vstack

Make a fermipy.jobs.Gtlink object to run gtexpcube2

Make a fermipy.jobs.Gtlink object to run gtsrcmaps

fermipy.diffuse.job_library.create_sg_gtexpcube2(**kwargs)[source]

Build and return a ScatterGather object that can invoke gtexpcube2

fermipy.diffuse.job_library.create_sg_gtsrcmaps_catalog(**kwargs)[source]

Build and return a ScatterGather object that can invoke gtsrcmaps for catalog sources

fermipy.diffuse.job_library.create_sg_healview_diffuse(**kwargs)[source]

Build and return a ScatterGather object that can invoke fermipy-healview

fermipy.diffuse.job_library.create_sg_sum_ring_gasmaps(**kwargs)[source]

Build and return a ScatterGather object that can invoke fermipy-coadd

fermipy.diffuse.job_library.create_sg_vstack_diffuse(**kwargs)[source]

Build and return a ScatterGather object that can invoke fermipy-vstack

fermipy.diffuse.job_library.invoke_sg_gtexpcube2()[source]

Entry point for command line use for dispatching batch jobs

fermipy.diffuse.job_library.invoke_sg_gtsrcmaps_catalog()[source]

Entry point for command line use for dispatching batch jobs

fermipy.diffuse.job_library.invoke_sg_healview_diffuse()[source]

Entry point for command line use for dispatching batch jobs

fermipy.diffuse.job_library.invoke_sg_sum_ring_gasmaps()[source]

Entry point for command line use for dispatching batch jobs

fermipy.diffuse.job_library.invoke_sg_vstack_diffuse()[source]

Entry point for command line use for dispatching batch jobs

fermipy.diffuse.gt_assemble_model module

Merge source maps to build composite sources

class fermipy.diffuse.gt_assemble_model.ConfigMaker_AssembleModel(link, **kwargs)[source]

Bases: fermipy.jobs.scatter_gather.ConfigMaker

Small class to generate configurations for this script

Parameters:
  • --comp (binning component definition yaml file) –
  • --data (datset definition yaml file) –
  • --hpx_order (Maximum HEALPix order to use) –
  • --irf_ver (IRF verions string (e.g., 'V6')) –
  • args (Names of models to assemble source maps for) –
build_job_configs(args)[source]

Hook to build job configurations

default_options = {'sources': (None, 'Path to yaml file defining catalog components.', <type 'str'>), 'irf_ver': ('V6', 'Version of IRFs to use.', <type 'str'>), 'comp': (None, 'Path to yaml file defining binning.', <type 'str'>), 'args': (None, 'Names of input models', <type 'list'>), 'hpx_order': (7, 'Maximum HEALPIX order for model fitting.', <type 'int'>), 'diffuse': (None, 'Path to yaml file defining diffuse components.', <type 'str'>), 'data': (None, 'Path to yaml file defining dataset.', <type 'str'>)}
class fermipy.diffuse.gt_assemble_model.GtAssembleModel(**kwargs)[source]

Bases: fermipy.jobs.chain.Link

Small class to assemple source map files for fermipy analysis.

This is useful for re-merging after parallelizing source map creation.

static append_hdus(hdulist, srcmap_file, source_names, hpx_order)[source]

Append HEALPix maps to a list

Parameters:
  • hdulist (list) – The list being appended to
  • srcmap_file (str) – Path to the file containing the HDUs
  • source_names (list of str) – Names of the sources to extract from srcmap_file
  • hpx_order (int) – Maximum order for maps
static assemble_component(compname, compinfo, hpx_order)[source]

Assemble the source map file for one binning component

Parameters:
  • compname (str) – The key for this component (e.g., E0_PSF3)
  • compinfo (dict) – Information about this component
  • hpx_order (int) – Maximum order for maps
static copy_ccube(ccube, outsrcmap, hpx_order)[source]

Copy a counts cube into outsrcmap file reducing the HEALPix order to hpx_order if needed.

default_options = {'comp': (None, 'Path to yaml file defining binning.', <type 'str'>), 'hpx_order': (7, 'Maximum HEALPIX order for model fitting.', <type 'int'>), 'input': (None, 'Input yaml file', <type 'str'>)}
static open_outsrcmap(outsrcmap)[source]

Open and return the outsrcmap file in append mode

run_analysis(argv)[source]

Assemble the source map file for one binning component FIXME

class fermipy.diffuse.gt_assemble_model.GtInitModel(**kwargs)[source]

Bases: fermipy.jobs.chain.Link

Small class to preprate files fermipy analysis.

Specifically this create the srcmap_manifest and fermipy_config_yaml files

default_options = {'sources': (None, 'Path to yaml file defining catalog components.', <type 'str'>), 'comp': (None, 'Path to yaml file defining binning.', <type 'str'>), 'args': (None, 'Names of input models', <type 'list'>), 'hpx_order': (7, 'Maximum HEALPIX order for model fitting.', <type 'int'>), 'diffuse': (None, 'Path to yaml file defining diffuse components.', <type 'str'>), 'data': (None, 'Path to yaml file defining dataset.', <type 'str'>)}
run_analysis(argv)[source]

Assemble the source map file for one binning component FIXME

Build and return a Link object that can invoke GtAssembleModel

fermipy.diffuse.gt_assemble_model.create_sg_assemble_model(**kwargs)[source]

Build and return a ScatterGather object that can invoke this script

fermipy.diffuse.gt_assemble_model.main_batch()[source]

Entry point for command line use for dispatching batch jobs

fermipy.diffuse.gt_assemble_model.main_init()[source]

Entry point for command line use for init job

fermipy.diffuse.gt_assemble_model.main_single()[source]

Entry point for command line use for single job

fermipy.diffuse.gt_coadd_split module

Prepare data for diffuse all-sky analysis

class fermipy.diffuse.gt_coadd_split.CoaddSplit(linkname, **kwargs)[source]

Bases: fermipy.jobs.chain.Chain

Small class to merge counts cubes for a series of binning components

default_options = {'coordsys': ('GAL', 'Coordinate system of the spatial projection (CEL or GAL).', <type 'str'>), 'dry_run': (False, 'Print commands but do not run them', <type 'bool'>), 'nfiles': (96, 'Number of input files', <type 'int'>), 'comp': (None, 'Path to yaml file defining binning.', <type 'str'>), 'data': (None, 'Path to yaml file defining dataset.', <type 'str'>), 'do_ltsum': (False, 'Sum livetime cube files', <type 'bool'>)}
run_argparser(argv)[source]

Initialize a link with a set of arguments using argparser

Build the links in this chain from the binning specification

fermipy.diffuse.gt_coadd_split.create_chain_coadd_split(**kwargs)[source]

Build and return a CoaddSplit object

fermipy.diffuse.gt_coadd_split.main()[source]

Entry point for command line use

fermipy.diffuse.gt_merge_srcmaps module

Merge source maps to build composite sources

class fermipy.diffuse.gt_merge_srcmaps.ConfigMaker_MergeSrcmaps(link, **kwargs)[source]

Bases: fermipy.jobs.scatter_gather.ConfigMaker

Small class to generate configurations for this script

This adds the following arguments: –comp : binning component definition yaml file –data : datset definition yaml file –irf_ver : IRF verions string (e.g., ‘V6’) –sources : Catalog model component definition yaml file’

build_job_configs(args)[source]

Hook to build job configurations

default_options = {'irf_ver': ('V6', 'Version of IRFs to use.', <type 'str'>), 'sources': (None, 'Path to yaml file defining catalog components.', <type 'str'>), 'data': (None, 'Path to yaml file defining dataset.', <type 'str'>), 'comp': (None, 'Path to yaml file defining binning.', <type 'str'>)}
class fermipy.diffuse.gt_merge_srcmaps.GtMergeSourceMaps(**kwargs)[source]

Bases: object

Small class to merge source maps for composite sources.

This is useful for parallelizing source map creation.

NULL_MODEL = 'srcmdls/null.xml'
default_options = {'irfs': ('CALDB', 'Instrument response functions', <type 'str'>), 'expcube': (None, 'Input Livetime cube file', <type 'str'>), 'srcmaps': (None, 'Input source maps file', <type 'str'>), 'srcmdl': (None, 'Input source model xml file', <type 'str'>), 'outxml': (None, 'Output source model xml file', <type 'str'>), 'bexpmap': (None, 'Input binned exposure map file', <type 'str'>), 'outfile': (None, 'Output file', <type 'str'>), 'gzip': (False, 'Compress output file', <type 'bool'>), 'merged': (None, 'Name of merged source', <type 'str'>)}

Make a fermipy.jobs.Link object to run `GtMergeSourceMaps

static make_parser()[source]

Make an argument parser for this class

run(argv)[source]

Run this analysis

Build and return a Link object that can invoke GtAssembleModel

fermipy.diffuse.gt_merge_srcmaps.create_sg_merge_srcmaps(**kwargs)[source]

Build and return a ScatterGather object that can invoke this script

fermipy.diffuse.gt_merge_srcmaps.main_batch()[source]

Entry point for command line use for dispatching batch jobs

fermipy.diffuse.gt_merge_srcmaps.main_single()[source]

Entry point for command line use for single job

fermipy.diffuse.gt_split_and_bin module

Prepare data for diffuse all-sky analysis

class fermipy.diffuse.gt_split_and_bin.ConfigMaker_SplitAndBin(chain, gather, **kwargs)[source]

Bases: fermipy.jobs.scatter_gather.ConfigMaker

Small class to generate configurations for SplitAndBin

build_job_configs(args)[source]

Hook to build job configurations

default_options = {'ft1file': (None, 'Input FT1 file', <type 'str'>), 'scratch': (None, 'Path to scratch area', <type 'str'>), 'coordsys': ('GAL', 'Coordinate system of the spatial projection (CEL or GAL).', <type 'str'>), 'hpx_order_max': (9, 'Maximum HEALPIX order for binning counts data.', <type 'int'>), 'comp': (None, 'Path to yaml file defining binning.', <type 'str'>), 'data': (None, 'Path to yaml file defining dataset.', <type 'str'>)}
make_base_config(args)[source]

Hook to build a baseline job configuration

Parameters:args (dict) – Command line arguments, see add_arguments
class fermipy.diffuse.gt_split_and_bin.SplitAndBin(linkname, comp_dict=None, **kwargs)[source]

Bases: fermipy.jobs.chain.Chain

Small class to split and bin data according to some user-provided specification

run_argparser(argv)[source]

Initialize a link with a set of arguments using argparser

Build the links in this chain from the binning specification

fermipy.diffuse.gt_split_and_bin.create_chain_split_and_bin(**kwargs)[source]

Make a fermipy.jobs.SplitAndBin

fermipy.diffuse.gt_split_and_bin.create_inputlist(arglist)[source]

Read lines from a file and makes a list of file names.

Removes whitespace and lines that start with ‘#’ Recursively read all files with the extension ‘.lst’

fermipy.diffuse.gt_split_and_bin.create_sg_split_and_bin(**kwargs)[source]

Build and return a fermipy.jobs.ScatterGather object that can invoke this script

fermipy.diffuse.gt_split_and_bin.main_batch()[source]

Entry point for command line use for dispatching batch jobs

fermipy.diffuse.gt_split_and_bin.main_single()[source]

Entry point for command line use for single job

fermipy.diffuse.gt_split_and_bin.make_full_path(basedir, outkey, origname)[source]

Make a full file path

fermipy.diffuse.gt_split_and_bin.readlines(arg)[source]

Read lines from a file into a list.

Removes whitespace and lines that start with ‘#’

fermipy.diffuse.gt_srcmap_partial module

Run gtsrcmaps for a single energy plane for a single source

This is useful to parallize the production of the source maps

class fermipy.diffuse.gt_srcmap_partial.ConfigMaker_SrcmapPartial(link, **kwargs)[source]

Bases: fermipy.jobs.scatter_gather.ConfigMaker

Small class to generate configurations for this script

This adds the following arguments: –comp : binning component definition yaml file –data : datset definition yaml file –irf_ver : IRF verions string (e.g., ‘V6’) –diffuse : Diffuse model component definition yaml file’ –make_xml : Write xml files for the individual components

build_job_configs(args)[source]

Hook to build job configurations

default_options = {'irf_ver': ('V6', 'Version of IRFs to use.', <type 'str'>), 'make_xml': (True, 'Write xml files needed to make source maps', <type 'bool'>), 'data': (None, 'Path to yaml file defining dataset.', <type 'str'>), 'diffuse': (None, 'Path to yaml file defining diffuse components.', <type 'str'>), 'comp': (None, 'Path to yaml file defining binning.', <type 'str'>)}
class fermipy.diffuse.gt_srcmap_partial.GtSrcmapPartial(**kwargs)[source]

Bases: fermipy.jobs.chain.Link

Small class to create srcmaps for only once source in a model, and optionally for only some of the energy layers.

This is useful for parallelizing source map creation.

NULL_MODEL = 'srcmdls/null.xml'
default_options = {'irfs': ('CALDB', 'Instrument response functions', <type 'str'>), 'expcube': (None, 'Input Livetime cube file', <type 'str'>), 'srcmdl': (None, 'Input source model xml file', <type 'str'>), 'source': (None, 'Input source', <type 'str'>), 'kmin': (0, 'Minimum Energy Bin', <type 'int'>), 'bexpmap': (None, 'Input binned exposure map file', <type 'str'>), 'outfile': (None, 'Output file', <type 'str'>), 'kmax': (-1, 'Maximum Energy Bin', <type 'int'>), 'cmap': (None, 'Input counts cube file', <type 'str'>), 'gzip': (False, 'Compress output file', <type 'bool'>)}
run_analysis(argv)[source]

Run this analysis

Build and return a Link object that can invoke GtAssembleModel

fermipy.diffuse.gt_srcmap_partial.create_sg_srcmap_partial(**kwargs)[source]

Build and return a ScatterGather object that can invoke this script

fermipy.diffuse.gt_srcmap_partial.main_batch()[source]

Entry point for command line use for dispatching batch jobs

fermipy.diffuse.gt_srcmap_partial.main_single()[source]

Entry point for command line use for single job

fermipy.diffuse.residual_cr module

Compute the residual cosmic-ray contamination

class fermipy.diffuse.residual_cr.ConfigMaker_ResidualCR(link, **kwargs)[source]

Bases: fermipy.jobs.scatter_gather.ConfigMaker

Small class to generate configurations for this script

build_job_configs(args)[source]

Hook to build job configurations

default_options = {'clean': ('ultracleanveto', 'Clean event class', <type 'str'>), 'full_output': (False, 'Include diagnostic output', <type 'bool'>), 'mask_factor': (2.0, 'Pixel selection factor for output mask', <type 'float'>), 'hpx_order': (4, 'HEALPIX order for analysis', <type 'int'>), 'mktime': ('nosm', 'Key for gtmktime selection', <type 'str'>), 'dirty': ('source', 'Dirty event class', <type 'str'>), 'coordsys': ('GAL', 'Coordinate system of the spatial projection (CEL or GAL).', <type 'str'>), 'comp': ('config/binning_4_residualCR.yaml', 'Path to yaml file defining binning.', <type 'str'>), 'irf_ver': ('V6', 'Version of IRFs to use.', <type 'str'>), 'dataset_yaml': (None, 'Path to yaml file defining dataset.', <type 'str'>), 'sigma': (3.0, 'Width of gaussian to smooth output maps [degrees]', <type 'float'>), 'select_factor': (5.0, 'Pixel selection factor for Aeff Correction', <type 'float'>)}
class fermipy.diffuse.residual_cr.ResidualCRAnalysis(**kwargs)[source]

Bases: fermipy.jobs.chain.Link

Small class to analyze the residual cosmic-ray contaimination.

default_options = {'bexpcube_clean': (None, 'Input exposure cube for clean event class.', <type 'str'>), 'ccube_clean': (None, 'Input counts cube for clean event class.', <type 'str'>), 'full_output': (False, 'Include diagnostic output', <type 'bool'>), 'mask_factor': (2.0, 'Pixel selection factor for output mask', <type 'float'>), 'hpx_order': (4, 'HEALPIX order for analysis', <type 'int'>), 'clobber': (False, 'Overwrite output file', <type 'bool'>), 'outfile': (None, 'Name of output file', <type 'str'>), 'coordsys': ('GAL', 'Coordinate system of the spatial projection (CEL or GAL).', <type 'str'>), 'bexpcube_dirty': (None, 'Input exposure cube for dirty event class.', <type 'str'>), 'sigma': (3.0, 'Width of gaussian to smooth output maps [degrees]', <type 'float'>), 'ccube_dirty': (None, 'Input counts cube for dirty event class.', <type 'str'>), 'select_factor': (5.0, 'Pixel selection factor for Aeff Correction', <type 'float'>)}
run_analysis(argv)[source]

Run this analysis

class fermipy.diffuse.residual_cr.ResidualCRChain(linkname, **kwargs)[source]

Bases: fermipy.jobs.chain.Chain

Small class to preform analysis of residual cosmic-ray contamination

default_options = {'ft1file': ('P8_P302_8years_source_zmax105.lst', 'Path to list of input FT1 files', <type 'str'>), 'dataset_yaml': (None, 'Path to yaml file defining dataset.', <type 'str'>), 'full_output': (False, 'Include diagnostic output', <type 'bool'>), 'dry_run': (False, 'Print commands but do not run them', <type 'bool'>), 'hpx_order_binning': (6, 'Maximum HEALPIX order for binning counts data.', <type 'int'>), 'comp': ('config/binning_4_residualCR.yaml', 'Path to yaml file defining binning.', <type 'str'>), 'hpx_order_fitting': (4, 'HEALPIX order for analysis', <type 'int'>), 'ft2file': ('ft2_files/ft2_8years_moon.lst', 'Path to FT2 file', <type 'str'>), 'coordsys': ('GAL', 'Coordinate system of the spatial projection (CEL or GAL).', <type 'str'>), 'irf_ver': ('V6', 'Version of IRFs to use.', <type 'str'>)}
run_argparser(argv)[source]

Initialize a link with a set of arguments using argparser

fermipy.diffuse.residual_cr.create_chain_residual_cr(**kwargs)[source]

Build and return a ResidualCRChain object

Build and return a Link object that can invoke ResidualCRAnalysis

fermipy.diffuse.residual_cr.create_sg_residual_cr(**kwargs)[source]

Build and return a ScatterGather object that can invoke this script

fermipy.diffuse.residual_cr.main_batch()[source]

Entry point for command line use for dispatching batch jobs

fermipy.diffuse.residual_cr.main_chain()[source]

Energy point for running the entire Cosmic-ray analysis

fermipy.diffuse.residual_cr.main_single()[source]

Entry point for command line use for single job

Module contents