fermipy.diffuse subpackage
The fermipy.diffuse sub-package is a collection of standalone utilities that allow the user to parallelize the data and template preparation for all-sky analysis.
The tools described here perform a number of functions:
Making binned counts maps and expousre maps over the whole sky.
Managing model components for all-sky analysis; including both diffuse emission and point source contributions. This includes make spatial-spectral templates and expected counts maps for various components.
Building intergrated models for a collection of model components.
Fitting those models.
Overview
This package implements an analysis pipeline prepare data and templates for analysis. This involves a lot of bookkeeping and loops over various things.It is probably easiest to first describe this with a bit of pseudo-code that represents the various analysis steps.
The various loop variables are:
Input data files
For practical reasons, the input photon event files (FT1) files are split into monthly files. In the binning step of the analysis we loop over those files.
binning components
We split the data into several “binning components” and make seperate binned counts maps for each components. A binning component is defined by energy range and data sub-selection (such as PSF event type and zenith angle cuts).
Diffuse model components
The set of all the model components that represent diffuse emission, such as contributions for cosmic ray interactions with
Catalog model components
The set of all the catalog sources (both point sources and extended source), merged into a few distinct contributions.
Diffuse emission model definitions
A set of user defined models that merge the various model components with specific spectral models.
# Data Binning, prepare the analysis directories and precompute the DM spectra
# First we loop over all the input input files and split up the
# data by binning component and bin the data using the command
# fermipy-split-and-bin-sg, which is equivalent to:
for file in input_data_files:
fermipy-split-and-bin(file)
# Then we loop over the binning components and coadd the binned
# data from all the input files using the command
# fermipy-coadd-split-sf, which is equivalent to:
for comp in binning_components:
fermipy-coadd-split(comp)
# We also loop over the binning components and compute the
# exposure maps for each binning component using the command
# fermipy-gtexpcube2-sg, which is equivalent to:
for comp in binned_components:
gtexpcube2(comp)
# We loop over the diffuse components that come from GALProp
# templates and refactor them using the command
# fermipy-sum-ring-gasmaps-sg, which is equivalent to
for galprop_comp in diffuse_galprop_components:
fermipy-coadd(galprop_comp)
# We do a triple loop over all of the diffuse components, all the
# binning components and all the energy bins and convolve the
# emission template with the instrument response using the command
# fermipy-srcmaps-diffuse-sg, which is equivalent to
for diffuse_comp in diffuse_components:
for binning_comp in binned_components:
for energy in energy_bins:
fermipy-srcmap-diffuse(diffuse_comp, binning_comp, energy)
# We then do a double loop over all the diffuse components and all
# the binning components and stack the template maps into single
# files using the command
# fermipy-vstack-diffuse-sg, which is equivalent to
for diffuse_comp in diffuse_components:
for binning_comp in binned_components:
fermipy-vstack-diffuse(diffuse_comp, binning_comp)
# We then do a double loop over source catalogs and binning
# components and compute the templates for each source using the
# command
# fermipy-srcmaps-catalog-sg, which is equivalent to
for catalog in catalogs:
for binning_comp in binned_components:
fermipy-srcmaps-catalog(catalog, binning_comp)
# We then loop over the catalog components (essentially
# sub-sets of catalog sources that we want to merge)
# and merge those sources into templates using the command
# fermipy-merge-srcmaps-sg, which is equivalent to
for catalog_comp in catalog_components:
for binning_comp in binned_components:
fermipy-merge-srcmaps(catalog_comp, binning_comp)
# At this point we have a library to template maps for all the
# emision components that we have defined.
# Now we want to define specific models. We do this
# using the commands
# fermipy-init-model and fermipy-assemble-model-sg, which is equivalent to
for model in models:
fermipy-assemble-model(model)
# At this point we, for each model under consideration we have an
# analysis directory that is set up for fermipy
Configuration
This section describes the configuration management scheme used within the fermipy.diffuse package and documents the configuration parameters that can be set in the configuration file.
Analysis classes in the dmpipe package all inherit from the fermipy.jobs.Link
class, which allow user to invoke the class either interactively within python
or from the unix command line.
From the command line
$ fermipy-srcmaps-diffuse-sg --comp config/binning.yaml --data config/dataset_source.yaml --library models/library.yaml
From python there are a number of ways to do it, we recommend this:
from fermipy.diffuse.gt_srcmap_partial import SrcmapsDiffuse_SG
link = SrcmapsDiffuse_SG( )
link.update_args(dict(comp='config/binning.yaml', data='config/dataset_source.yaml',library='models/library.yaml'))
link.run()
Top Level Configuration
We use a yaml file to define the top-level analysis parameters.
# The binning components
comp : config/binning.yaml
# The dataset
data : config/dataset_source.yaml
# Library with the fitting components
library : models/library.yaml
# Yaml file with the list of models to prepare
models : models/modellist.yaml
# Input FT1 file
ft1file : P8_P305_8years_source_zmax105.lst
# HEALPix order for counts cubes
hpx_order_ccube : 9
# HEALPix order for exposure cubes
hpx_order_expcube : 6
# HEALPix order fitting models
hpx_order_fitting : 7
# Build the XML files for the diffuse emission model components
make_diffuse_comp_xml : True
# Build the XML files for the catalog source model components
make_catalog_comp_xml : True
# Name of the directory for the merged GALProp gasmaps
merged_gasmap_dir : merged_gasmap
# Number of catalog sources per batch job
catalog_nsrc : 500
Binning Configuration
We use a yaml file to define the binning components.
coordsys : 'GAL'
E0:
log_emin : 1.5
log_emax : 2.0
enumbins : 2
zmax : 80.
psf_types :
PSF3 :
hpx_order : 5
E1:
log_emin : 2.0
log_emax : 2.5
enumbins : 2
zmax : 90.
psf_types :
PSF23 :
hpx_order : 6
E2:
log_emin : 2.5
log_emax : 3.0
enumbins : 3
zmax : 100.
psf_types :
PSF123 :
hpx_order : 8
E3:
log_emin : 3.0
log_emax : 6.0
enumbins : 9
zmax : 105.
psf_types :
PSF0123 :
hpx_order : 9
- coordsys‘GAL’ or ‘CEL’
Coordinate system to use
- log_emin, log_emax: float
Energy bin boundries in log10(MeV)
- enumbins: int
Number of energy bins for this binning component
- zmaxfloat
Maximum zenith angle (in degrees) for this binning component
- psf_types: dict
Sub-dictionary of binning components by PSF event type, PSF3 means PSF event type 3 events only. PSF0123 means all four PSF event types.
- hpx_order: int
HEALPix order to use for binning. The more familiar nside parameter is nside = 2**order
Dataset Configuration
We use a yaml file to define the data set we are using. The example below specifies using a pre-defined 8 year dataset, selecting the “SOURCE” event class and using the V2 version of the corresponding IRFs (specifically P8R3_SOURCE_V2).
basedir : '/gpfs/slac/kipac/fs1/u/dmcat/data/flight/diffuse_dev'
data_pass : 'P8'
data_ver : 'P305'
evclass : 'source'
data_time : '8years'
irf_ver : 'V2'
The basedir parameter should point at the analysis directory. For the most part the other parameter are using to make the names of the various files produced by the pipeline. The evclass parameter defines the event selection, and the IRF version is defined by a combination of the data_ver, evclass and irf_ver parameters.
GALProp Rings Configuration
We use a yaml file to define the how we combine GALProp emission templates. The example below specifies how to construct as series of ‘merged_CO’ rings by combining GALProp intensity template predictions.
galprop_run : 56_LRYusifovXCO5z6R30_QRPD_150_rc_Rs8
ring_limits : [1, 2, 3, 4, 6, 8, 9, 10, 11, 12, 13, 15]
diffuse_comp_dict :
merged_CO : ['pi0_decay_H2R', 'bremss_H2R']
remove_rings : ['merged_CO_7']
- galprop_runstring
Define the GALProp run to use for this component. This is used to make the filenames for input template maps.
- ring_limitslist of int
This specfies how to combine the GALProp rings into a smaller set of rings.
- diffuse_comp_dictdict
This specifies how to make GALProp components into merged components for the diffuse analysis
- remove_rings: list of str
This allow use to remove certain rings from the model
Catalog Component Configuration
We use a yaml file to define the how we split up the catalog source components. The example below specifies using the FL8Y source list, and to split out the faint sources (i.e., those with the Signif_Avg value less that 100.), and the extended source, and to keep all the remaining sources (i.e., the bright, pointlike, sources) as individual sources.
catalog_name : FL8Y
catalog_file : /nfs/slac/kipac/fs1/u/dmcat/ancil/catalogs/official/4FGLp/gll_psc_8year_v4.fit
catalog_extdir : /nfs/slac/kipac/fs1/u/dmcat/ancil/catalogs/official/extended/Extended_archive_v18
catalog_type : FL8Y
rules_dict :
faint :
cuts :
- { cut_var: Signif_Avg, max_val : 100. }
- mask_extended
extended :
cuts :
- select_extended
remainder :
merge : False
Model Component Library
We use a yaml file to define a “library” of model components. The comprises a set of named emission components, and a set one or more versions for each named component. Here is an example library defintion file.
# Catalog Components
FL8Y :
model_type : catalog
versions : [v00]
# Diffuse Components
galprop_rings :
model_type : galprop_rings
versions : [p8-ref_IC_thin, p8-ref_HI_150, p8-ref_CO_300_mom, p8-ref_dnm_300hp]
dnm_merged:
model_type : MapCubeSource
versions : ['like_4y_300K']
gll-iem :
model_type : MapCubeSource
versions : [v06]
loopI :
model_type : MapCubeSource
versions : [haslam]
bubbles :
model_type : MapCubeSource
versions : [v00, v01]
iso_map :
model_type : MapCubeSource
versions : [P8R3_SOURCE_V2]
patches :
model_type : MapCubeSource
versions : [v09]
selection_dependent : True
no_psf : True
edisp_disable : True
unresolved :
model_type : MapCubeSource
versions : [strong]
sun-ic :
model_type : MapCubeSource
versions : [v2r0, P8R3-v2r0]
moving : True
edisp_disable : True
sun-disk :
model_type : MapCubeSource
versions : [v3r1, P8R3-v3r1]
moving : True
edisp_disable : True
moon :
model_type : MapCubeSource
versions : [v3r2, P8R3-v3r2]
moving : True
edisp_disable : True
- model_type: ‘MapCubeSource’ or ‘catalog’ or ‘galprop_rings’ or ‘SpatialMap’
Specifies how this model should be constructed. See more below in the versions parameters.
- versions: list of str
Specifies different versions of this model component. How this string is used depend on the model type. for ‘MapCubeSource’ and ‘SpatialMap’ sources it is used to construct the expected filename for the intensity template. For ‘catalog’ and ‘galprop_rings’ it is used to construct the filename for the yaml file that defines the sub-components for that component.
moving: bool If true, then will use source-specific livetime cubes to constuct source templates for each zenith angle cut.
selection_dependent : bool If true, then will used different source templates for each binning component.
no_psf : bool Turns of PSF convolution for this source. Useful for data-driven components.
edisp_disable : bool Turns off energy dispersion for the source. Useful for data-driven components.
Spectral Model Configuration
We use a yaml file to define the spectral models and default parameters. This file is simply a dictionary mapping names to sub-dictionaries defining spectral models and default model parameters.
Model Defintion
We use a yaml file to define each overall model, which combine library components and spectral models.
library : models/library.yaml
spectral_models : models/spectral_models.yaml
sources :
galprop_rings_p8-ref_IC_thin :
model_type : galprop_rings
version : p8-ref_IC_150
SpectrumType :
default : Constant_Correction
galprop_rings-p8-ref_HI_300:
model_type : galprop_rings
version : p8-ref_HI_300
SpectrumType :
default : Powerlaw_Correction
merged_HI_2_p8-ref_HI_300 : BinByBin_5
merged_HI_3_p8-ref_HI_300 : BinByBin_5
merged_HI_4_p8-ref_HI_300 : BinByBin_9
merged_HI_5_p8-ref_HI_300 : BinByBin_9
merged_HI_6_p8-ref_HI_300 : BinByBin_9
merged_HI_8_p8-ref_HI_300 : BinByBin_5
merged_HI_9_p8-ref_HI_300 : BinByBin_5
galprop_rings-p8-ref_CO_300:
model_type : galprop_rings
version : p8-ref_CO_300_mom
SpectrumType :
default : Powerlaw_Correction
merged_CO_2_p8-ref_CO_300_mom : BinByBin_5
merged_CO_3_p8-ref_CO_300_mom : BinByBin_5
merged_CO_4_p8-ref_CO_300_mom : BinByBin_9
merged_CO_5_p8-ref_CO_300_mom : BinByBin_9
merged_CO_6_p8-ref_CO_300_mom : BinByBin_9
merged_CO_8_p8-ref_CO_300_mom : BinByBin_5
merged_CO_9_p8-ref_CO_300_mom : BinByBin_5
dnm_merged :
version : like_4y_300K
SpectrumType : BinByBin_5
iso_map :
version : P8R3_SOURCE_V2
SpectrumType : Iso
sun-disk :
version : v3r1
SpectrumType : Constant_Correction
edisp_disable : True
sun-ic :
version : v2r0
SpectrumType : Constant_Correction
edisp_disable : True
moon :
version : v3r2
SpectrumType : Constant_Correction
edisp_disable : True
patches :
version : v09
SpectrumType : Patches
edisp_disable : True
unresolved :
version : strong
SpectrumType : Constant_Correction
FL8Y :
model_type : Catalog
version : v00
SpectrumType :
default : Constant_Correction
FL8Y_v00_remain : Catalog
FL8Y_v00_faint : BinByBin_9
- model_type: ‘MapCubeSource’ or ‘catalog’ or ‘galprop_rings’ or ‘SpatialMap’
Specifies how this model should be constructed. See more below.
- version: str
Specifies version of this model component.
edisp_disable : bool Turns off energy dispersion for the source. Useful for data-driven components. Needed for model XML file construction.
SpectrumType: str or dictionary This specifies the Spectrum type to use for this model component. For ‘catalog’ and ‘galprop_rings’ model types it can be a dictionary mapping model sub-components to spectrum types. Note that the spectrum types should be defined in the spectral model configuration described above.
Examples
Module contents
Configuration, binning, default options, etc…
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
coordsys (str) – Coodinate system, ‘CEL’ or ‘GAL’
- classmethod build_from_energy_dict(ebin_name, input_dict)[source]
Build a list of components from a dictionary for a single energy range
- property emax
Maximum energy for this component
- property emin
Minimum energy for this component
- property evtype
Event type bit mask for this component
Analysis framework for all-sky diffuse emission fitting
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_format = 'templates/profile_{sourcekey}.fits'
- bexpcube_format = 'bexp_cubes/bexcube_{dataset}_{mktime}_{component}_{coordsys}_{irf_ver}.fits'
- 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_format = 'models/catalog_{sourcekey}.yaml'
- ccube_format = 'counts_cubes/ccube_{dataset}_{mktime}_{component}_{coordsys}.fits'
- comp_srcmdl_xml_format = 'analysis/model_{modelkey}/srcmdl_{modelkey}_{component}.xml'
- component_format = '{zcut}_{ebin}_{psftype}'
- dataset_format = '{data_pass}_{data_ver}_{data_time}_{evclass}'
- diffuse_template_format = 'templates/template_{sourcekey}.fits'
- ft1file_format = '{dataset}_{zcut}.lst'
- ft2file_format = 'ft2_files/ft2_{data_time}.lst'
- fullpath_format = '{basedir}/{localpath}'
- galprop_gasmap_format = 'gasmap/{sourcekey}_{projtype}_{galprop_run}.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_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
- ltcube_format = 'lt_cubes/ltcube_{data_time}_{mktime}_{zcut}.fits'
- ltcubemoon_format = 'sunmoon/ltcube_{data_time}_{mktime}_{zcut}_moon.fits'
- ltcubesun_format = 'sunmoon/ltcube_{data_time}_{mktime}_{zcut}_sun.fits'
- master_srcmdl_xml_format = 'analysis/model_{modelkey}/srcmdl_{modelkey}_master.xml'
- mcube_format = 'model_cubes/mcube_{sourcekey}_{dataset}_{mktime}_{component}_{coordsys}_{irf_ver}.fits'
- merged_gasmap_format = 'merged_gasmaps/{sourcekey}_{projtype}.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_format = 'analysis/model_{modelkey}/srcmaps_{dataset}_{mktime}_{component}_{coordsys}_{irf_ver}.fits'
- mktime_format = 'counts_cubes/mktime_{dataset}_{mktime}_{component}.fits'
- 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_format = 'residual_cr/residual_cr_{dataset}_{mktime}_{component}_{coordsys}_{irf_ver}.fits'
- 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_format = 'templates/spectral_{sourcekey}.txt'
- srcmaps_format = 'srcmaps/srcmaps_{sourcekey}_{dataset}_{mktime}_{component}_{coordsys}_{irf_ver}.fits'
- srcmdl_xml_format = 'srcmdls/{sourcekey}.xml'
- stamp_format = 'stamps/{linkname}.stamp'
- templatesunmoon_format = 'templates/template_{sourcekey}_{zcut}.fits'
Utilities and tools
Small helper class to represent the selection of mktime filters used in the analysis
- class fermipy.diffuse.timefilter.MktimeFilterDict(aliases, selections)[source]
Bases:
object
Small helper class toselection of mktime filters used in the analysis
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
- 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=None)[source]
Build and return a
fermipy.roi_model.ROIModel
object from a dict with information about the sources
- property source_info_dict
Return the dictionary of source_info objects used to build sources
- property 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 sourcessource_names (list) – Names of sourcs to extract
object (Returns dict mapping source_name to fermipy.roi_model.Source)
- fermipy.diffuse.source_factory.make_composite_source(name, spectrum)[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
- fermipy.diffuse.source_factory.make_spatialmap_source(name, Spatial_Filename, spectrum)[source]
Construct and return a
fermipy.roi_model.Source
object
Prepare data for diffuse all-sky analysis
Helper classes to manage model building
- 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)
no_psf (bool) – Flag to indicate that we do not smear this component with the PSF
components (dict) – Sub-dictionary of
ModelComponentInfo
objects for moving and selection_dependent sourcescomp_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
object (Returns ModelComponentInfo)
- 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 objectroi_model (
fermipy.roi_model.ROIModel
) – Fermipy object describing all the catalog sourcessrcmdl_name (str) – Name of xml file with the catalog source model
- 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
- 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)
no_psf (bool) – Flag to indicate that we do not smear this component with the PSF
components (dict) – Sub-dictionary of
ModelComponentInfo
objects for moving and selection_dependent sourcescomp_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
object (Returns ModelComponentInfo)
- class fermipy.diffuse.model_component.IsoComponentInfo(**kwargs)[source]
Bases:
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.PointSourceInfo(**kwargs)[source]
Bases:
ModelComponentInfo
Information about a model component represented by a PointSource
- class fermipy.diffuse.model_component.CompositeSourceInfo(**kwargs)[source]
Bases:
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 sourcesroi_model (
fermipy.roi_model.ROIModel
) – Fermipy object describing the nested sources
- class fermipy.diffuse.model_component.CatalogSourcesInfo(**kwargs)[source]
Bases:
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 sourcesroi_model (
fermipy.roi_model.ROIModel
) – Fermipy object describing the nested sources
- 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
- make_diffuse_comp_info(merged_name, galkey)[source]
Make the information about a single merged component
- 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
- 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
- make_ring_filename(source_name, ring, galprop_run)[source]
Make the name of a gasmap file for a single ring
- 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
- 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.
or (Returns model_component.ModelComponentInfo)
model_component.IsoComponentInfo
- make_diffuse_comp_info_dict(diffuse_sources, components)[source]
Make a dictionary maping from diffuse component to information about that component
- make_template_name(model_type, sourcekey)[source]
Make the name of a template file for particular component
- 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
- catalog_components(catalog_name, split_ver)[source]
Return the set of merged components for a particular split key
- 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 catalogsplit_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
CatalogSourcesInfo (Returns CompositeSourceInfo or)
- 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
- split_comp_info(catalog_name, split_ver, split_key)[source]
Return the info for a particular split key
- 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
- property component_names
Return the list of name of the components
- edisp_disable_list()[source]
Return the list of source for which energy dispersion should be turned off
- 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 conventionsthe (Returns a dictionary that contains information about where to find)
model (source maps for each component of the)
- 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
- property csm
Return the CatalogSourceManager
- property 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
- property gmm
Return the GalpropMapManager
- make_fermipy_config_yaml(modelkey, components, data, **kwargs)[source]
Build a fermipy top-level yaml configuration file
- make_library(diffuse_yaml, catalog_yaml, binning_yaml)[source]
Build up the library of all the components
- 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)
Trivial Link Sub-classes
- class fermipy.diffuse.job_library.Gtlink_select(**kwargs)[source]
Bases:
Gtlink
Small wrapper to run gtselect :param emin: Minimum energy [MeV] [100.0] :type emin: <class ‘float’> :param emax: Maximum energy [MeV] [100000.0] :type emax: <class ‘float’> :param infile: Input file [None] :type infile: <class ‘str’> :param outfile: Output file [None] :type outfile: <class ‘str’> :param zmax: Maximum zenith angle [degrees] [100.0] :type zmax: <class ‘float’> :param tmin: Start time [MET] [None] :type tmin: <class ‘float’> :param tmax: Stop time [MET] [None] :type tmax: <class ‘float’> :param evclass: Event Class [None] :type evclass: <class ‘int’> :param evtype: Event type selections [None] :type evtype: <class ‘int’> :param pfiles: PFILES directory [None] :type pfiles: <class ‘str’>
- appname = 'gtselect'
- default_file_args = {'infile': 1, 'outfile': 2}
- default_options = {'emax': (100000.0, 'Maximum energy [MeV]', <class 'float'>), 'emin': (100.0, 'Minimum energy [MeV]', <class 'float'>), 'evclass': (None, 'Event Class', <class 'int'>), 'evtype': (None, 'Event type selections', <class 'int'>), 'infile': (None, 'Input file', <class 'str'>), 'outfile': (None, 'Output file', <class 'str'>), 'pfiles': (None, 'PFILES directory', <class 'str'>), 'tmax': (None, 'Stop time [MET] ', <class 'float'>), 'tmin': (None, 'Start time [MET]', <class 'float'>), 'zmax': (100.0, 'Maximum zenith angle [degrees]', <class 'float'>)}
- description = 'Link to run gtselect'
- linkname_default = 'gtselect'
- usage = 'gtselect [options]'
- class fermipy.diffuse.job_library.Gtlink_bin(**kwargs)[source]
Bases:
Gtlink
Small wrapper to run gtbin :param algorithm: Binning alogrithm [HEALPIX] :type algorithm: <class ‘str’> :param coordsys: Coordinate system [GAL] :type coordsys: <class ‘str’> :param hpx_order: HEALPIX order parameter [6] :type hpx_order: <class ‘int’> :param evfile: Input FT1 eventfile [None] :type evfile: <class ‘str’> :param outfile: Output file [None] :type outfile: <class ‘str’> :param emin: Minimum energy [MeV] [100.0] :type emin: <class ‘float’> :param emax: Maximum energy [MeV] [100000.0] :type emax: <class ‘float’> :param enumbins: Number of energy bins [16] :type enumbins: <class ‘int’> :param ebinalg: Algorithm for defining energy bins [LOG] :type ebinalg: <class ‘str’> :param ebinfile: Name of the file containing the energy bin definition [None] :type ebinfile: <class ‘str’> :param pfiles: PFILES directory [None] :type pfiles: <class ‘str’>
- appname = 'gtbin'
- default_file_args = {'evfile': 33, 'outfile': 34}
- default_options = {'algorithm': ('HEALPIX', 'Binning alogrithm', <class 'str'>), 'coordsys': ('GAL', 'Coordinate system', <class 'str'>), 'ebinalg': ('LOG', 'Algorithm for defining energy bins', <class 'str'>), 'ebinfile': (None, 'Name of the file containing the energy bin definition', <class 'str'>), 'emax': (100000.0, 'Maximum energy [MeV]', <class 'float'>), 'emin': (100.0, 'Minimum energy [MeV]', <class 'float'>), 'enumbins': (16, 'Number of energy bins', <class 'int'>), 'evfile': (None, 'Input FT1 eventfile', <class 'str'>), 'hpx_order': (6, 'HEALPIX order parameter', <class 'int'>), 'outfile': (None, 'Output file', <class 'str'>), 'pfiles': (None, 'PFILES directory', <class 'str'>)}
- description = 'Link to run gtbin'
- linkname_default = 'gtbin'
- usage = 'gtbin [options]'
- class fermipy.diffuse.job_library.Gtlink_expcube2(**kwargs)[source]
Bases:
Gtlink
Small wrapper to run gtexpcube2 :param irfs: Instrument response functions [CALDB] :type irfs: <class ‘str’> :param evtype: Event type selections [None] :type evtype: <class ‘int’> :param hpx_order: HEALPIX order parameter [6] :type hpx_order: <class ‘int’> :param infile: Input livetime cube file [None] :type infile: <class ‘str’> :param cmap: Input counts cube file [None] :type cmap: <class ‘str’> :param outfile: Output file [None] :type outfile: <class ‘str’> :param coordsys: Coordinate system [GAL] :type coordsys: <class ‘str’>
- appname = 'gtexpcube2'
- default_file_args = {'cmap': 1, 'infile': 1, 'outfile': 2}
- default_options = {'cmap': (None, 'Input counts cube file', <class 'str'>), 'coordsys': ('GAL', 'Coordinate system', <class 'str'>), 'evtype': (None, 'Event type selections', <class 'int'>), 'hpx_order': (6, 'HEALPIX order parameter', <class 'int'>), 'infile': (None, 'Input livetime cube file', <class 'str'>), 'irfs': ('CALDB', 'Instrument response functions', <class 'str'>), 'outfile': (None, 'Output file', <class 'str'>)}
- description = 'Link to run gtexpcube2'
- linkname_default = 'gtexpcube2'
- usage = 'gtexpcube2 [options]'
- class fermipy.diffuse.job_library.Gtlink_scrmaps(**kwargs)[source]
Bases:
Gtlink
Small wrapper to run gtscrmaps :param irfs: Instrument response functions [CALDB] :type irfs: <class ‘str’> :param expcube: Input Livetime cube file [None] :type expcube: <class ‘str’> :param bexpmap: Input binned exposure map file [None] :type bexpmap: <class ‘str’> :param cmap: Input counts cube file [None] :type cmap: <class ‘str’> :param srcmdl: Input source model xml file [None] :type srcmdl: <class ‘str’> :param outfile: Output file [None] :type outfile: <class ‘str’>
- appname = 'gtscrmaps'
- default_file_args = {'bexpmap': 1, 'cmap': 1, 'expcube': 1, 'outfile': 2, 'srcmdl': 1}
- default_options = {'bexpmap': (None, 'Input binned exposure map file', <class 'str'>), 'cmap': (None, 'Input counts cube file', <class 'str'>), 'expcube': (None, 'Input Livetime cube file', <class 'str'>), 'irfs': ('CALDB', 'Instrument response functions', <class 'str'>), 'outfile': (None, 'Output file', <class 'str'>), 'srcmdl': (None, 'Input source model xml file', <class 'str'>)}
- description = 'Link to run gtscrmaps'
- linkname_default = 'gtscrmaps'
- usage = 'gtscrmaps [options]'
- class fermipy.diffuse.job_library.Gtlink_ltsum(**kwargs)[source]
Bases:
Gtlink
Small wrapper to run gtltsum :param infile1: Livetime cube 1 or list of files [None] :type infile1: <class ‘str’> :param infile2: Livetime cube 2 [none] :type infile2: <class ‘str’> :param outfile: Output file [None] :type outfile: <class ‘str’>
- appname = 'gtltsum'
- default_file_args = {'infile1': 1, 'outfile': 2}
- default_options = {'infile1': (None, 'Livetime cube 1 or list of files', <class 'str'>), 'infile2': ('none', 'Livetime cube 2', <class 'str'>), 'outfile': (None, 'Output file', <class 'str'>)}
- description = 'Link to run gtltsum'
- linkname_default = 'gtltsum'
- usage = 'gtltsum [options]'
- class fermipy.diffuse.job_library.Gtlink_mktime(**kwargs)[source]
Bases:
Gtlink
Small wrapper to run gtmktime :param evfile: Input FT1 File [None] :type evfile: <class ‘str’> :param outfile: Output FT1 File [None] :type outfile: <class ‘str’> :param scfile: Input FT2 file [None] :type scfile: <class ‘str’> :param roicut: Apply ROI-based zenith angle cut [False] :type roicut: <class ‘bool’> :param filter: Filter expression [None] :type filter: <class ‘str’> :param pfiles: PFILES directory [None] :type pfiles: <class ‘str’>
- appname = 'gtmktime'
- default_file_args = {'evfile': 33, 'outfile': 34, 'scfile': 33}
- default_options = {'evfile': (None, 'Input FT1 File', <class 'str'>), 'filter': (None, 'Filter expression', <class 'str'>), 'outfile': (None, 'Output FT1 File', <class 'str'>), 'pfiles': (None, 'PFILES directory', <class 'str'>), 'roicut': (False, 'Apply ROI-based zenith angle cut', <class 'bool'>), 'scfile': (None, 'Input FT2 file', <class 'str'>)}
- description = 'Link to run gtmktime'
- linkname_default = 'gtmktime'
- usage = 'gtmktime [options]'
- class fermipy.diffuse.job_library.Gtlink_ltcube(**kwargs)[source]
Bases:
Gtlink
Small wrapper to run gtltcube :param evfile: Input FT1 File [None] :type evfile: <class ‘str’> :param scfile: Input FT2 file [None] :type scfile: <class ‘str’> :param outfile: Output Livetime cube File [None] :type outfile: <class ‘str’> :param dcostheta: Step size in cos(theta) [0.025] :type dcostheta: <class ‘float’> :param binsz: Pixel size (degrees) [1.0] :type binsz: <class ‘float’> :param phibins: Number of phi bins [0] :type phibins: <class ‘int’> :param zmin: Minimum zenith angle [0] :type zmin: <class ‘float’> :param zmax: Maximum zenith angle [105] :type zmax: <class ‘float’> :param pfiles: PFILES directory [None] :type pfiles: <class ‘str’>
- appname = 'gtltcube'
- default_file_args = {'evfile': 33, 'outfile': 34, 'scfile': 33}
- default_options = {'binsz': (1.0, 'Pixel size (degrees)', <class 'float'>), 'dcostheta': (0.025, 'Step size in cos(theta)', <class 'float'>), 'evfile': (None, 'Input FT1 File', <class 'str'>), 'outfile': (None, 'Output Livetime cube File', <class 'str'>), 'pfiles': (None, 'PFILES directory', <class 'str'>), 'phibins': (0, 'Number of phi bins', <class 'int'>), 'scfile': (None, 'Input FT2 file', <class 'str'>), 'zmax': (105, 'Maximum zenith angle', <class 'float'>), 'zmin': (0, 'Minimum zenith angle', <class 'float'>)}
- description = 'Link to run gtltcube'
- linkname_default = 'gtltcube'
- usage = 'gtltcube [options]'
- class fermipy.diffuse.solar.Gtlink_expcube2_wcs(**kwargs)[source]
Bases:
Gtlink
Small wrapper to run gtexpcube2 :param irfs: Instrument response functions [CALDB] :type irfs: <class ‘str’> :param evtype: Event type selections [None] :type evtype: <class ‘int’> :param cmap: Input counts cube template [none] :type cmap: <class ‘str’> :param emin: Start energy (MeV) of first bin [100.0] :type emin: <class ‘float’> :param emax: Stop energy (MeV) of last bin [1000000.0] :type emax: <class ‘float’> :param enumbins: Number of logarithmically-spaced energy bins [12] :type enumbins: <class ‘int’> :param binsz: Image scale (in degrees/pixel) [0.25] :type binsz: <class ‘float’> :param xref: First coordinate of image center in degrees (RA or GLON) [0.0] :type xref: <class ‘float’> :param yref: Second coordinate of image center in degrees (DEC or GLAT) [0.0] :type yref: <class ‘float’> :param axisrot: Rotation angle of image axis, in degrees [0.0] :type axisrot: <class ‘float’> :param proj: Projection method e.g. AIT|ARC|CAR|GLS|MER|NCP|SIN|STG|TAN [CAR] :type proj: <class ‘str’> :param nxpix: Size of the X axis in pixels [1440] :type nxpix: <class ‘int’> :param nypix: Size of the Y axis in pixels [720] :type nypix: <class ‘int’> :param infile: Input livetime cube file [None] :type infile: <class ‘str’> :param outfile: Output file [None] :type outfile: <class ‘str’> :param coordsys: Coordinate system [GAL] :type coordsys: <class ‘str’>
- appname = 'gtexpcube2'
- default_file_args = {'cmap': 1, 'infile': 1, 'outfile': 2}
- default_options = {'axisrot': (0.0, 'Rotation angle of image axis, in degrees', <class 'float'>), 'binsz': (0.25, 'Image scale (in degrees/pixel)', <class 'float'>), 'cmap': ('none', 'Input counts cube template', <class 'str'>), 'coordsys': ('GAL', 'Coordinate system', <class 'str'>), 'emax': (1000000.0, 'Stop energy (MeV) of last bin', <class 'float'>), 'emin': (100.0, 'Start energy (MeV) of first bin', <class 'float'>), 'enumbins': (12, 'Number of logarithmically-spaced energy bins', <class 'int'>), 'evtype': (None, 'Event type selections', <class 'int'>), 'infile': (None, 'Input livetime cube file', <class 'str'>), 'irfs': ('CALDB', 'Instrument response functions', <class 'str'>), 'nxpix': (1440, 'Size of the X axis in pixels', <class 'int'>), 'nypix': (720, 'Size of the Y axis in pixels', <class 'int'>), 'outfile': (None, 'Output file', <class 'str'>), 'proj': ('CAR', 'Projection method e.g. AIT|ARC|CAR|GLS|MER|NCP|SIN|STG|TAN', <class 'str'>), 'xref': (0.0, 'First coordinate of image center in degrees (RA or GLON)', <class 'float'>), 'yref': (0.0, 'Second coordinate of image center in degrees (DEC or GLAT)', <class 'float'>)}
- description = 'Link to run gtexpcube2'
- linkname_default = 'gtexpcube2'
- usage = 'gtexpcube2 [options]'
- class fermipy.diffuse.solar.Gtlink_exphpsun(**kwargs)[source]
Bases:
Gtlink
Small wrapper to run gtexphpsun :param irfs: Instrument response functions [CALDB] :type irfs: <class ‘str’> :param evtype: Event type selection [3] :type evtype: <class ‘int’> :param emin: Start energy (MeV) of first bin [100.0] :type emin: <class ‘float’> :param emax: Stop energy (MeV) of last bin [1000000.0] :type emax: <class ‘float’> :param enumbins: Number of logarithmically-spaced energy bins [12] :type enumbins: <class ‘int’> :param binsz: Image scale (in degrees/pixel) [1.0] :type binsz: <class ‘float’> :param infile: Input livetime cube file [None] :type infile: <class ‘str’> :param outfile: Output file [None] :type outfile: <class ‘str’>
- appname = 'gtexphpsun'
- default_file_args = {'infile': 1, 'outfile': 2}
- default_options = {'binsz': (1.0, 'Image scale (in degrees/pixel)', <class 'float'>), 'emax': (1000000.0, 'Stop energy (MeV) of last bin', <class 'float'>), 'emin': (100.0, 'Start energy (MeV) of first bin', <class 'float'>), 'enumbins': (12, 'Number of logarithmically-spaced energy bins', <class 'int'>), 'evtype': (3, 'Event type selection', <class 'int'>), 'infile': (None, 'Input livetime cube file', <class 'str'>), 'irfs': ('CALDB', 'Instrument response functions', <class 'str'>), 'outfile': (None, 'Output file', <class 'str'>)}
- description = 'Link to run gtexphpsun'
- linkname_default = 'gtexphpsun'
- usage = 'gtexphpsun [options]'
- class fermipy.diffuse.solar.Gtlink_suntemp(**kwargs)[source]
Bases:
Gtlink
Small wrapper to run gtsuntemp :param expsun: Exposure binned in healpix and solar angles [None] :type expsun: <class ‘str’> :param avgexp: Binned exposure [None] :type avgexp: <class ‘str’> :param sunprof: Fits file containing solar intensity profile [None] :type sunprof: <class ‘str’> :param cmap: Counts map file [none] :type cmap: <class ‘str’> :param irfs: Instrument response functions [CALDB] :type irfs: <class ‘str’> :param evtype: Event type selection [3] :type evtype: <class ‘int’> :param coordsys: Coordinate system (CEL - celestial, GAL -galactic) [GAL] :type coordsys: <class ‘str’> :param emin: Start energy (MeV) of first bin [100.0] :type emin: <class ‘float’> :param emax: Stop energy (MeV) of last bin [1000000.0] :type emax: <class ‘float’> :param enumbins: Number of logarithmically-spaced energy bins [12] :type enumbins: <class ‘int’> :param nxpix: Size of the X axis in pixels [1440] :type nxpix: <class ‘int’> :param nypix: Size of the Y axis in pixels [720] :type nypix: <class ‘int’> :param binsz: Image scale (in degrees/pixel) [0.25] :type binsz: <class ‘float’> :param xref: First coordinate of image center in degrees (RA or GLON) [0.0] :type xref: <class ‘float’> :param yref: Second coordinate of image center in degrees (DEC or GLAT) [0.0] :type yref: <class ‘float’> :param axisrot: Rotation angle of image axis, in degrees [0.0] :type axisrot: <class ‘float’> :param proj: Projection method e.g. AIT|ARC|CAR|GLS|MER|NCP|SIN|STG|TAN [CAR] :type proj: <class ‘str’> :param outfile: Output file [None] :type outfile: <class ‘str’>
- appname = 'gtsuntemp'
- default_file_args = {'avgexp': 1, 'expsun': 1, 'outfile': 2, 'sunprof': 1}
- default_options = {'avgexp': (None, 'Binned exposure', <class 'str'>), 'axisrot': (0.0, 'Rotation angle of image axis, in degrees', <class 'float'>), 'binsz': (0.25, 'Image scale (in degrees/pixel)', <class 'float'>), 'cmap': ('none', 'Counts map file', <class 'str'>), 'coordsys': ('GAL', 'Coordinate system (CEL - celestial, GAL -galactic)', <class 'str'>), 'emax': (1000000.0, 'Stop energy (MeV) of last bin', <class 'float'>), 'emin': (100.0, 'Start energy (MeV) of first bin', <class 'float'>), 'enumbins': (12, 'Number of logarithmically-spaced energy bins', <class 'int'>), 'evtype': (3, 'Event type selection', <class 'int'>), 'expsun': (None, 'Exposure binned in healpix and solar angles', <class 'str'>), 'irfs': ('CALDB', 'Instrument response functions', <class 'str'>), 'nxpix': (1440, 'Size of the X axis in pixels', <class 'int'>), 'nypix': (720, 'Size of the Y axis in pixels', <class 'int'>), 'outfile': (None, 'Output file', <class 'str'>), 'proj': ('CAR', 'Projection method e.g. AIT|ARC|CAR|GLS|MER|NCP|SIN|STG|TAN', <class 'str'>), 'sunprof': (None, 'Fits file containing solar intensity profile', <class 'str'>), 'xref': (0.0, 'First coordinate of image center in degrees (RA or GLON)', <class 'float'>), 'yref': (0.0, 'Second coordinate of image center in degrees (DEC or GLAT)', <class 'float'>)}
- description = 'Link to run gtsuntemp'
- linkname_default = 'gtsuntemp'
- usage = 'gtsuntemp [options]'
- class fermipy.diffuse.job_library.Link_FermipyCoadd(**kwargs)[source]
Bases:
AppLink
Small wrapper to run fermipy-coadd :param args: List of input files [[]] :type args: <class ‘list’> :param output: Output file [None] :type output: <class ‘str’>
- appname = 'fermipy-coadd'
- default_file_args = {'args': 1, 'output': 2}
- default_options = {'args': ([], 'List of input files', <class 'list'>), 'output': (None, 'Output file', <class 'str'>)}
- description = 'Link to run fermipy-coadd'
- linkname_default = 'coadd'
- usage = 'fermipy-coadd [options]'
- class fermipy.diffuse.job_library.Link_FermipyGatherSrcmaps(**kwargs)[source]
Bases:
AppLink
Small wrapper to run fermipy-gather-srcmaps :param output: Output file name [None] :type output: <class ‘str’> :param args: List of input files [[]] :type args: <class ‘list’> :param gzip: Compress output [False] :type gzip: <class ‘bool’> :param rm: Remove input files [False] :type rm: <class ‘bool’> :param clobber: Overwrite output [False] :type clobber: <class ‘bool’>
- appname = 'fermipy-gather-srcmaps'
- default_file_args = {'args': 1, 'output': 2}
- default_options = {'args': ([], 'List of input files', <class 'list'>), 'clobber': (False, 'Overwrite output', <class 'bool'>), 'gzip': (False, 'Compress output', <class 'bool'>), 'output': (None, 'Output file name', <class 'str'>), 'rm': (False, 'Remove input files', <class 'bool'>)}
- description = 'Link to run fermipy-gather-srcmaps'
- linkname_default = 'gather-srcmaps'
- usage = 'fermipy-gather-srcmaps [options]'
- class fermipy.diffuse.job_library.Link_FermipyVstack(**kwargs)[source]
Bases:
AppLink
Small wrapper to run fermipy-vstack :param output: Output file name [None] :type output: <class ‘str’> :param hdu: Name of HDU to stack [None] :type hdu: <class ‘str’> :param args: List of input files [[]] :type args: <class ‘list’> :param gzip: Compress output [False] :type gzip: <class ‘bool’> :param rm: Remove input files [False] :type rm: <class ‘bool’> :param clobber: Overwrite output [False] :type clobber: <class ‘bool’>
- appname = 'fermipy-vstack'
- default_file_args = {'args': 1, 'output': 2}
- default_options = {'args': ([], 'List of input files', <class 'list'>), 'clobber': (False, 'Overwrite output', <class 'bool'>), 'gzip': (False, 'Compress output', <class 'bool'>), 'hdu': (None, 'Name of HDU to stack', <class 'str'>), 'output': (None, 'Output file name', <class 'str'>), 'rm': (False, 'Remove input files', <class 'bool'>)}
- description = 'Link to run fermipy-vstack'
- linkname_default = 'vstack'
- usage = 'fermipy-vstack [options]'
- class fermipy.diffuse.job_library.Link_FermipyHealview(**kwargs)[source]
Bases:
AppLink
Small wrapper to run fermipy-healview :param input: Input file [None] :type input: <class ‘str’> :param output: Output file name [None] :type output: <class ‘str’> :param extension: FITS HDU with HEALPix map [None] :type extension: <class ‘str’> :param zscale: Scaling for color scale [log] :type zscale: <class ‘str’>
- appname = 'fermipy-healview'
- default_file_args = {'args': 1, 'output': 2}
- default_options = {'extension': (None, 'FITS HDU with HEALPix map', <class 'str'>), 'input': (None, 'Input file', <class 'str'>), 'output': (None, 'Output file name', <class 'str'>), 'zscale': ('log', 'Scaling for color scale', <class 'str'>)}
- description = 'Link to run fermipy-healview'
- linkname_default = 'fermipy-healview'
- usage = 'fermipy-healview [options]'
Standalone Analysis Links
- class fermipy.diffuse.gt_merge_srcmaps.GtMergeSrcmaps(**kwargs)[source]
Bases:
Link
Small class to merge source maps for composite sources.
This is useful for parallelizing source map creation.
- Parameters:
irfs (<class 'str'>) – Instrument response functions [CALDB]
expcube (<class 'str'>) – Input Livetime cube file [None]
bexpmap (<class 'str'>) – Input binned exposure map file [None]
srcmaps (<class 'str'>) – Input source maps file [None]
srcmdl (<class 'str'>) – Input source model xml file [None]
outfile (<class 'str'>) – Output file [None]
merged (<class 'str'>) – Name of merged source [None]
outxml (<class 'str'>) – Output source model xml file [None]
gzip (<class 'bool'>) – Compress output file [False]
- NULL_MODEL = 'srcmdls/null.xml'
- appname = 'fermipy-merge-srcmaps'
- default_file_args = {'bexpmap': 1, 'cmap': 1, 'expcube': 1, 'outfile': 2, 'outxml': 2, 'srcmdl': 1}
- default_options = {'bexpmap': (None, 'Input binned exposure map file', <class 'str'>), 'expcube': (None, 'Input Livetime cube file', <class 'str'>), 'gzip': (False, 'Compress output file', <class 'bool'>), 'irfs': ('CALDB', 'Instrument response functions', <class 'str'>), 'merged': (None, 'Name of merged source', <class 'str'>), 'outfile': (None, 'Output file', <class 'str'>), 'outxml': (None, 'Output source model xml file', <class 'str'>), 'srcmaps': (None, 'Input source maps file', <class 'str'>), 'srcmdl': (None, 'Input source model xml file', <class 'str'>)}
- description = 'Mrege source maps from a set of sources'
- linkname_default = 'merge-srcmaps'
- usage = 'fermipy-merge-srcmaps [options]'
- class fermipy.diffuse.gt_srcmap_partial.GtSrcmapsDiffuse(**kwargs)[source]
Bases:
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.
- Parameters:
irfs (<class 'str'>) – Instrument response functions [CALDB]
expcube (<class 'str'>) – Input Livetime cube file [None]
bexpmap (<class 'str'>) – Input binned exposure map file [None]
cmap (<class 'str'>) – Input counts cube file [None]
srcmdl (<class 'str'>) – Input source model xml file [None]
outfile (<class 'str'>) – Output file [None]
source (<class 'str'>) – Input source [None]
kmin (<class 'int'>) – Minimum Energy Bin [0]
kmax (<class 'int'>) – Maximum Energy Bin [-1]
no_psf (<class 'bool'>) – Do not apply PSF smearing [False]
gzip (<class 'bool'>) – Compress output file [False]
- NULL_MODEL = 'srcmdls/null.xml'
- appname = 'fermipy-srcmaps-diffuse'
- default_file_args = {'bexpmap': 1, 'cmap': 1, 'expcube': 1, 'outfile': 2, 'srcmdl': 1}
- default_options = {'bexpmap': (None, 'Input binned exposure map file', <class 'str'>), 'cmap': (None, 'Input counts cube file', <class 'str'>), 'expcube': (None, 'Input Livetime cube file', <class 'str'>), 'gzip': (False, 'Compress output file', <class 'bool'>), 'irfs': ('CALDB', 'Instrument response functions', <class 'str'>), 'kmax': (-1, 'Maximum Energy Bin', <class 'int'>), 'kmin': (0, 'Minimum Energy Bin', <class 'int'>), 'no_psf': (False, 'Do not apply PSF smearing', <class 'bool'>), 'outfile': (None, 'Output file', <class 'str'>), 'source': (None, 'Input source', <class 'str'>), 'srcmdl': (None, 'Input source model xml file', <class 'str'>)}
- description = 'Run gtsrcmaps for one or more energy planes for a single source'
- linkname_default = 'srcmaps-diffuse'
- usage = 'fermipy-srcmaps-diffuse [options]'
- class fermipy.diffuse.gt_srcmaps_catalog.GtSrcmapsCatalog(**kwargs)[source]
Bases:
Link
- Small class to create and write srcmaps for all the catalog sources,
once source at a time.
This is useful for creating source maps for all the sources in a catalog
- Parameters:
irfs (<class 'str'>) – Instrument response functions [CALDB]
expcube (<class 'str'>) – Input Livetime cube file [None]
bexpmap (<class 'str'>) – Input binned exposure map file [None]
cmap (<class 'str'>) – Input counts cube file [None]
srcmdl (<class 'str'>) – Input source model xml file [None]
outfile (<class 'str'>) – Output file [None]
srcmin (<class 'int'>) – Index of first source [0]
srcmax (<class 'int'>) – Index of last source [-1]
gzip (<class 'bool'>) – Compress output file [False]
- NULL_MODEL = 'srcmdls/null.xml'
- appname = 'fermipy-srcmaps-catalog'
- default_file_args = {'bexpmap': 1, 'cmap': 1, 'expcube': 1, 'outfile': 2, 'srcmdl': 1}
- default_options = {'bexpmap': (None, 'Input binned exposure map file', <class 'str'>), 'cmap': (None, 'Input counts cube file', <class 'str'>), 'expcube': (None, 'Input Livetime cube file', <class 'str'>), 'gzip': (False, 'Compress output file', <class 'bool'>), 'irfs': ('CALDB', 'Instrument response functions', <class 'str'>), 'outfile': (None, 'Output file', <class 'str'>), 'srcmax': (-1, 'Index of last source', <class 'int'>), 'srcmdl': (None, 'Input source model xml file', <class 'str'>), 'srcmin': (0, 'Index of first source', <class 'int'>)}
- description = 'Run gtsrcmaps for for all the sources in a catalog'
- linkname_default = 'srcmaps-catalog'
- usage = 'fermipy-srcmaps-catalog [options]'
- class fermipy.diffuse.gt_assemble_model.InitModel(**kwargs)[source]
Bases:
Link
Small class to preprate files fermipy analysis.
Specifically this create the srcmap_manifest and fermipy_config_yaml files
- appname = 'fermipy-init-model'
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'hpx_order': (7, 'Maximum HEALPIX order for model fitting.', <class 'int'>), 'library': ('models/library.yaml', 'Path to yaml file defining model components.', <class 'str'>), 'models': ('models/modellist.yaml', 'Path to yaml file defining models.', <class 'str'>)}
- description = 'Initialize model fitting directory'
- linkname_default = 'init-model'
- usage = 'fermipy-init-model [options]'
- class fermipy.diffuse.gt_assemble_model.AssembleModel(**kwargs)[source]
Bases:
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
- appname = 'fermipy-assemble-model'
- static assemble_component(compname, compinfo, hpx_order)[source]
Assemble the source map file for one binning component
- 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 = {'compname': (None, 'Component name.', <class 'str'>), 'hpx_order': (7, 'Maximum HEALPIX order for model fitting.', <class 'int'>), 'input': (None, 'Input yaml file', <class 'str'>)}
- description = 'Assemble sourcemaps for model fitting'
- linkname_default = 'assemble-model'
- usage = 'fermipy-assemble-model [options]'
- class fermipy.diffuse.residual_cr.ResidualCR(**kwargs)[source]
Bases:
Link
Small class to analyze the residual cosmic-ray contaimination.
- Parameters:
ccube_dirty (<class 'str'>) – Input counts cube for dirty event class. [None]
ccube_clean (<class 'str'>) – Input counts cube for clean event class. [None]
bexpcube_dirty (<class 'str'>) – Input exposure cube for dirty event class. [None]
bexpcube_clean (<class 'str'>) – Input exposure cube for clean event class. [None]
hpx_order (<class 'int'>) – HEALPIX order parameter [6]
outfile (<class 'str'>) – Output file [None]
select_factor (<class 'float'>) – Pixel selection factor for Aeff Correction [5.0]
mask_factor (<class 'float'>) – Pixel selection factor for output mask [2.0]
sigma (<class 'float'>) – Width of gaussian to smooth output maps [degrees] [3.0]
full_output (<class 'bool'>) – Include diagnostic output [False]
clobber (<class 'bool'>) – Overwrite files [False]
- appname = 'fermipy-residual-cr'
- default_file_args = {'bexpcube_clean': 1, 'bexpcube_dirty': 1, 'ccube_clean': 1, 'ccube_dirty': 1, 'outfile': 2}
- default_options = {'bexpcube_clean': (None, 'Input exposure cube for clean event class.', <class 'str'>), 'bexpcube_dirty': (None, 'Input exposure cube for dirty event class.', <class 'str'>), 'ccube_clean': (None, 'Input counts cube for clean event class.', <class 'str'>), 'ccube_dirty': (None, 'Input counts cube for dirty event class.', <class 'str'>), 'clobber': (False, 'Overwrite files', <class 'bool'>), 'full_output': (False, 'Include diagnostic output', <class 'bool'>), 'hpx_order': (6, 'HEALPIX order parameter', <class 'int'>), 'mask_factor': (2.0, 'Pixel selection factor for output mask', <class 'float'>), 'outfile': (None, 'Output file', <class 'str'>), 'select_factor': (5.0, 'Pixel selection factor for Aeff Correction', <class 'float'>), 'sigma': (3.0, 'Width of gaussian to smooth output maps [degrees]', <class 'float'>)}
- description = 'Compute the residual cosmic-ray contamination'
- linkname_default = 'residual-cr'
- usage = 'fermipy-residual-cr [options]'
Batch job dispatch classes
- class fermipy.diffuse.job_library.Gtexpcube2_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for
Gtlink_expcube2
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
hpx_order_max (<class 'int'>) – Maximum HEALPIX order for exposure cubes. [6]
- appname = 'fermipy-gtexcube2-sg'
- clientclass
alias of
Gtlink_expcube2
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'hpx_order_max': (6, 'Maximum HEALPIX order for exposure cubes.', <class 'int'>)}
- description = 'Submit gtexpube2 jobs in parallel'
- job_time = 300
- usage = 'fermipy-gtexcube2-sg [options]'
- class fermipy.diffuse.job_library.Gtltsum_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for
Gtlink_ltsum
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
ft1file (<class 'str'>) – Input FT1 file [None]
- appname = 'fermipy-gtltsum-sg'
- clientclass
alias of
Gtlink_ltsum
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'ft1file': (None, 'Input FT1 file', <class 'str'>)}
- description = 'Submit gtltsum jobs in parallel'
- job_time = 300
- usage = 'fermipy-gtltsum-sg [options]'
- class fermipy.diffuse.solar.Gtexpcube2wcs_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for gtexphpsun
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
mktimefilter (<class 'str'>) – Key for gtmktime selection [None]
binsz (<class 'float'>) – Image scale (in degrees/pixel) [1.0]
nxpix (<class 'int'>) – Size of the X axis in pixels [360]
nypix (<class 'int'>) – Size of the Y axis in pixels [180]
- appname = 'fermipy-gtexpcube2wcs-sg'
- clientclass
alias of
Gtlink_expcube2_wcs
- default_options = {'binsz': (1.0, 'Image scale (in degrees/pixel)', <class 'float'>), 'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'mktimefilter': (None, 'Key for gtmktime selection', <class 'str'>), 'nxpix': (360, 'Size of the X axis in pixels', <class 'int'>), 'nypix': (180, 'Size of the Y axis in pixels', <class 'int'>)}
- description = 'Submit gtexpcube2 jobs in parallel'
- job_time = 300
- usage = 'fermipy-gtexpcube2wcs-sg [options]'
- class fermipy.diffuse.solar.Gtexphpsun_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for gtexphpsun
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
mktimefilter (<class 'str'>) – Key for gtmktime selection [None]
- appname = 'fermipy-gtexphpsun-sg'
- clientclass
alias of
Gtlink_exphpsun
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'mktimefilter': (None, 'Key for gtmktime selection', <class 'str'>)}
- description = 'Submit gtexphpsun jobs in parallel'
- job_time = 300
- usage = 'fermipy-gtexphpsun-sg [options]'
- class fermipy.diffuse.solar.Gtsuntemp_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for gtsuntemp
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
mktimefilter (<class 'str'>) – Key for gtmktime selection [None]
sourcekeys (<class 'list'>) – Keys for sources to make template for [None]
- appname = 'fermipy-gtsuntemp-sg'
- clientclass
alias of
Gtlink_suntemp
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'mktimefilter': (None, 'Key for gtmktime selection', <class 'str'>), 'sourcekeys': (None, 'Keys for sources to make template for', <class 'list'>)}
- description = 'Submit gtsuntemp jobs in parallel'
- job_time = 300
- usage = 'fermipy-gtsuntemp-sg [options]'
- class fermipy.diffuse.gt_coadd_split.CoaddSplit_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for fermipy-coadd
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
ft1file (<class 'str'>) – Input FT1 file [None]
- appname = 'fermipy-coadd-split-sg'
- clientclass
alias of
Link_FermipyCoadd
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'ft1file': (None, 'Input FT1 file', <class 'str'>)}
- description = 'Submit fermipy-coadd-split- jobs in parallel'
- job_time = 300
- usage = 'fermipy-coadd-split-sg [options]'
- class fermipy.diffuse.job_library.GatherSrcmaps_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for
Link_FermipyGatherSrcmaps
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
library (<class 'str'>) – Path to yaml file defining model components. [models/library.yaml]
- appname = 'fermipy-gather-srcmaps-sg'
- clientclass
alias of
Link_FermipyGatherSrcmaps
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'library': ('models/library.yaml', 'Path to yaml file defining model components.', <class 'str'>)}
- description = 'Submit fermipy-gather-srcmaps jobs in parallel'
- job_time = 300
- usage = 'fermipy-gather-srcmaps-sg [options]'
- class fermipy.diffuse.job_library.Vstack_SG(link, **kwargs)[source]
Bases:
ScatterGather
- Small class to generate configurations for
Link_FermipyVstack
to merge source maps
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
library (<class 'str'>) – Path to yaml file defining model components. [models/library.yaml]
- appname = 'fermipy-vstack-sg'
- clientclass
alias of
Link_FermipyVstack
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'library': ('models/library.yaml', 'Path to yaml file defining model components.', <class 'str'>)}
- description = 'Submit fermipy-vstack jobs in parallel'
- job_time = 300
- usage = 'fermipy-vstack-sg [options]'
- Small class to generate configurations for
- class fermipy.diffuse.job_library.Healview_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for
Link_FermipyHealview
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
library (<class 'str'>) – Path to yaml file defining model components. [models/library.yaml]
- appname = 'fermipy-healviw-sg'
- clientclass
alias of
Link_FermipyHealview
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'library': ('models/library.yaml', 'Path to yaml file defining model components.', <class 'str'>)}
- description = 'Submit fermipy-healviw jobs in parallel'
- job_time = 60
- usage = 'fermipy-healviw-sg [options]'
- class fermipy.diffuse.job_library.SumRings_SG(link, **kwargs)[source]
Bases:
ScatterGather
- Small class to generate configurations for
Link_FermipyCoadd
to sum galprop ring gasmaps
- Parameters:
library (<class 'str'>) – Path to yaml file defining model components. [models/library.yaml]
outdir (<class 'str'>) – Output directory [None]
- appname = 'fermipy-sum-rings-sg'
- clientclass
alias of
Link_FermipyCoadd
- default_options = {'library': ('models/library.yaml', 'Path to yaml file defining model components.', <class 'str'>), 'outdir': (None, 'Output directory', <class 'str'>)}
- description = 'Submit fermipy-coadd jobs in parallel to sum GALProp rings'
- job_time = 300
- usage = 'fermipy-sum-rings-sg [options]'
- Small class to generate configurations for
- class fermipy.diffuse.job_library.SumRings_SG(link, **kwargs)[source]
Bases:
ScatterGather
- Small class to generate configurations for
Link_FermipyCoadd
to sum galprop ring gasmaps
- Parameters:
library (<class 'str'>) – Path to yaml file defining model components. [models/library.yaml]
outdir (<class 'str'>) – Output directory [None]
- appname = 'fermipy-sum-rings-sg'
- clientclass
alias of
Link_FermipyCoadd
- default_options = {'library': ('models/library.yaml', 'Path to yaml file defining model components.', <class 'str'>), 'outdir': (None, 'Output directory', <class 'str'>)}
- description = 'Submit fermipy-coadd jobs in parallel to sum GALProp rings'
- job_time = 300
- usage = 'fermipy-sum-rings-sg [options]'
- Small class to generate configurations for
- class fermipy.diffuse.residual_cr.ResidualCR_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for this script
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
mktimefilter (<class 'str'>) – Key for gtmktime selection [None]
hpx_order (<class 'int'>) – HEALPIX order parameter [6]
clean (<class 'str'>) – Clean event class [ultracleanveto]
dirty (<class 'str'>) – Dirty event class [source]
select_factor (<class 'float'>) – Pixel selection factor for Aeff Correction [5.0]
mask_factor (<class 'float'>) – Pixel selection factor for output mask [2.0]
sigma (<class 'float'>) – Width of gaussian to smooth output maps [degrees] [3.0]
full_output (<class 'bool'>) – Include diagnostic output [False]
- appname = 'fermipy-residual-cr-sg'
- clientclass
alias of
ResidualCR
- default_options = {'clean': ('ultracleanveto', 'Clean event class', <class 'str'>), 'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'dirty': ('source', 'Dirty event class', <class 'str'>), 'full_output': (False, 'Include diagnostic output', <class 'bool'>), 'hpx_order': (6, 'HEALPIX order parameter', <class 'int'>), 'mask_factor': (2.0, 'Pixel selection factor for output mask', <class 'float'>), 'mktimefilter': (None, 'Key for gtmktime selection', <class 'str'>), 'select_factor': (5.0, 'Pixel selection factor for Aeff Correction', <class 'float'>), 'sigma': (3.0, 'Width of gaussian to smooth output maps [degrees]', <class 'float'>)}
- description = 'Compute the residual cosmic-ray contamination'
- job_time = 300
- usage = 'fermipy-residual-cr-sg [options]'
- class fermipy.diffuse.gt_merge_srcmaps.MergeSrcmaps_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for
GtMergeSrcmaps
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
library (<class 'str'>) – Path to yaml file defining model components. [models/library.yaml]
- appname = 'fermipy-merge-srcmaps-sg'
- clientclass
alias of
GtMergeSrcmaps
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'library': ('models/library.yaml', 'Path to yaml file defining model components.', <class 'str'>)}
- description = 'Merge diffuse maps for all-sky analysis'
- job_time = 300
- usage = 'fermipy-merge-srcmaps-sg [options]'
- class fermipy.diffuse.gt_srcmap_partial.SrcmapsDiffuse_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for
GtSrcmapsDiffuse
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
library (<class 'str'>) – Path to yaml file defining model components. [models/library.yaml]
make_xml (<class 'bool'>) – Write xml files needed to make source maps [True]
- appname = 'fermipy-srcmaps-diffuse-sg'
- clientclass
alias of
GtSrcmapsDiffuse
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'library': ('models/library.yaml', 'Path to yaml file defining model components.', <class 'str'>), 'make_xml': (True, 'Write xml files needed to make source maps', <class 'bool'>)}
- description = 'Run gtsrcmaps for diffuse sources'
- job_time = 1500
- usage = 'fermipy-srcmaps-diffuse-sg [options]'
- class fermipy.diffuse.gt_srcmaps_catalog.SrcmapsCatalog_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for gtsrcmaps for catalog sources
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
library (<class 'str'>) – Path to yaml file defining model components. [models/library.yaml]
nsrc (<class 'int'>) – Number of sources per job [500]
make_xml (<class 'bool'>) – Make XML files. [True]
- appname = 'fermipy-srcmaps-catalog-sg'
- clientclass
alias of
GtSrcmapsCatalog
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'library': ('models/library.yaml', 'Path to yaml file defining model components.', <class 'str'>), 'make_xml': (True, 'Make XML files.', <class 'bool'>), 'nsrc': (500, 'Number of sources per job', <class 'int'>)}
- description = 'Run gtsrcmaps for catalog sources'
- job_time = 1500
- usage = 'fermipy-srcmaps-catalog-sg [options]'
- class fermipy.diffuse.gt_assemble_model.AssembleModel_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for this script
- Parameters:
--compname (binning component definition yaml file)
--data (datset definition yaml file)
--models (model definitino yaml file)
args (Names of models to assemble source maps for)
- appname = 'fermipy-assemble-model-sg'
- clientclass
alias of
AssembleModel
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'hpx_order': (7, 'Maximum HEALPIX order for model fitting.', <class 'int'>), 'models': ('models/modellist.yaml', 'Path to yaml file defining models.', <class 'str'>)}
- description = 'Copy source maps from the library to a analysis directory'
- job_time = 300
- usage = 'fermipy-assemble-model-sg [options]'
- class fermipy.diffuse.residual_cr.ResidualCR_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for this script
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
mktimefilter (<class 'str'>) – Key for gtmktime selection [None]
hpx_order (<class 'int'>) – HEALPIX order parameter [6]
clean (<class 'str'>) – Clean event class [ultracleanveto]
dirty (<class 'str'>) – Dirty event class [source]
select_factor (<class 'float'>) – Pixel selection factor for Aeff Correction [5.0]
mask_factor (<class 'float'>) – Pixel selection factor for output mask [2.0]
sigma (<class 'float'>) – Width of gaussian to smooth output maps [degrees] [3.0]
full_output (<class 'bool'>) – Include diagnostic output [False]
- appname = 'fermipy-residual-cr-sg'
- clientclass
alias of
ResidualCR
- default_options = {'clean': ('ultracleanveto', 'Clean event class', <class 'str'>), 'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'dirty': ('source', 'Dirty event class', <class 'str'>), 'full_output': (False, 'Include diagnostic output', <class 'bool'>), 'hpx_order': (6, 'HEALPIX order parameter', <class 'int'>), 'mask_factor': (2.0, 'Pixel selection factor for output mask', <class 'float'>), 'mktimefilter': (None, 'Key for gtmktime selection', <class 'str'>), 'select_factor': (5.0, 'Pixel selection factor for Aeff Correction', <class 'float'>), 'sigma': (3.0, 'Width of gaussian to smooth output maps [degrees]', <class 'float'>)}
- description = 'Compute the residual cosmic-ray contamination'
- job_time = 300
- usage = 'fermipy-residual-cr-sg [options]'
- class fermipy.diffuse.gt_split_and_bin.SplitAndBin_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for SplitAndBin
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
hpx_order_max (<class 'int'>) – Maximum HEALPIX order for binning counts data. [9]
ft1file (<class 'str'>) – Input FT1 file [None]
scratch (<class 'str'>) – Path to scratch area [None]
- appname = 'fermipy-split-and-bin-sg'
- clientclass
alias of
SplitAndBin
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'ft1file': (None, 'Input FT1 file', <class 'str'>), 'hpx_order_max': (9, 'Maximum HEALPIX order for binning counts data.', <class 'int'>), 'scratch': (None, 'Path to scratch area', <class 'str'>)}
- description = 'Prepare data for diffuse all-sky analysis'
- job_time = 1500
- usage = 'fermipy-split-and-bin-sg [options]'
- class fermipy.diffuse.gt_split_and_mktime.SplitAndMktime_SG(link, **kwargs)[source]
Bases:
ScatterGather
Small class to generate configurations for SplitAndMktime
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
hpx_order_max (<class 'int'>) – Maximum HEALPIX order for binning counts data. [9]
ft1file (<class 'str'>) – Path to list of input FT1 files [P8_P305_8years_source_zmax105.lst]
ft2file (<class 'str'>) – Path to list of input FT2 files [ft2_8years.lst]
do_ltsum (<class 'bool'>) – Run gtltsum on inputs [False]
scratch (<class 'str'>) – Path to scratch area. [None]
dry_run (<class 'bool'>) – Print commands but do not run them [False]
- appname = 'fermipy-split-and-mktime-sg'
- clientclass
alias of
SplitAndMktime
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'do_ltsum': (False, 'Run gtltsum on inputs', <class 'bool'>), 'dry_run': (False, 'Print commands but do not run them', <class 'bool'>), 'ft1file': ('P8_P305_8years_source_zmax105.lst', 'Path to list of input FT1 files', <class 'str'>), 'ft2file': ('ft2_8years.lst', 'Path to list of input FT2 files', <class 'str'>), 'hpx_order_max': (9, 'Maximum HEALPIX order for binning counts data.', <class 'int'>), 'scratch': (None, 'Path to scratch area.', <class 'str'>)}
- description = 'Prepare data for diffuse all-sky analysis'
- job_time = 1500
- usage = 'fermipy-split-and-mktime-sg [options]'
Analysis chain classes
- class fermipy.diffuse.gt_coadd_split.CoaddSplit(**kwargs)[source]
Bases:
Chain
Small class to merge counts cubes for a series of binning components
This chain consists multiple
Link
objects:- coadd-EBIN-ZCUT-FILTER-EVTYPE
_Link_FermipyCoadd
Link to coadd data of a particular type.
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
do_ltsum (<class 'bool'>) – Sum livetime cube files [False]
nfiles (<class 'int'>) – Number of input files [96]
dry_run (<class 'bool'>) – Print commands but do not run them [False]
- appname = 'fermipy-coadd-split'
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'do_ltsum': (False, 'Sum livetime cube files', <class 'bool'>), 'dry_run': (False, 'Print commands but do not run them', <class 'bool'>), 'nfiles': (96, 'Number of input files', <class 'int'>)}
- description = 'Merge a set of counts cube files'
- linkname_default = 'coadd-split'
- usage = 'fermipy-coadd-split [options]'
- coadd-EBIN-ZCUT-FILTER-EVTYPE
- class fermipy.diffuse.gt_split_and_bin.SplitAndBin(**kwargs)[source]
Bases:
Chain
Small class to split and bin data according to some user-provided specification
This chain consists multiple
Link
objects:- select-energy-EBIN-ZCUT
Gtlink_select
Initial splitting by energy bin and zenith angle cut
- select-type-EBIN-ZCUT-FILTER-TYPE
Gtlink_select
Refinement of selection from event types
- bin-EBIN-ZCUT-FILTER-TYPE
Gtlink_bin
Final binning of the data for each event type
- Parameters:
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
hpx_order_max (<class 'int'>) – Maximum HEALPIX order for binning counts data. [9]
ft1file (<class 'str'>) – Input FT1 file [None]
evclass (<class 'int'>) – Event class bit mask [128]
outdir (<class 'str'>) – Base name for output files [counts_cubes_cr]
outkey (<class 'str'>) – Key for this particular output file [None]
pfiles (<class 'str'>) – Directory for .par files [None]
scratch (<class 'str'>) – Scratch area [None]
dry_run (<class 'bool'>) – Print commands but do not run them [False]
- appname = 'fermipy-split-and-bin'
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'dry_run': (False, 'Print commands but do not run them', <class 'bool'>), 'evclass': (128, 'Event class bit mask', <class 'int'>), 'ft1file': (None, 'Input FT1 file', <class 'str'>), 'hpx_order_max': (9, 'Maximum HEALPIX order for binning counts data.', <class 'int'>), 'outdir': ('counts_cubes_cr', 'Base name for output files', <class 'str'>), 'outkey': (None, 'Key for this particular output file', <class 'str'>), 'pfiles': (None, 'Directory for .par files', <class 'str'>), 'scratch': (None, 'Scratch area', <class 'str'>)}
- description = 'Run gtselect and gtbin together'
- linkname_default = 'split-and-bin'
- usage = 'fermipy-split-and-bin [options]'
- select-energy-EBIN-ZCUT
- class fermipy.diffuse.gt_split_and_bin.SplitAndBinChain(**kwargs)[source]
Bases:
Chain
Chain to run split and bin and then make exposure cubes
This chain consists of:
- split-and-bin
SplitAndBin_SG
Chain to make the binned counts maps for each input file
- coadd-split
CoaddSplit_SG
Link to co-add the binnec counts maps files
- expcube2
Gtexpcube2_SG
Link to make the corresponding binned exposure maps
- Parameters:
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
ft1file (<class 'str'>) – Path to list of input FT1 files [P8_P305_8years_source_zmax105.lst]
hpx_order_ccube (<class 'int'>) – Maximum HEALPIX order for binning counts data. [9]
hpx_order_expcube (<class 'int'>) – Maximum HEALPIX order for exposure cubes. [6]
scratch (<class 'str'>) – Path to scratch area. [None]
dry_run (<class 'bool'>) – Print commands but do not run them [False]
- appname = 'fermipy-split-and-bin-chain'
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'dry_run': (False, 'Print commands but do not run them', <class 'bool'>), 'ft1file': ('P8_P305_8years_source_zmax105.lst', 'Path to list of input FT1 files', <class 'str'>), 'hpx_order_ccube': (9, 'Maximum HEALPIX order for binning counts data.', <class 'int'>), 'hpx_order_expcube': (6, 'Maximum HEALPIX order for exposure cubes.', <class 'int'>), 'scratch': (None, 'Path to scratch area.', <class 'str'>)}
- description = 'Run split-and-bin, coadd-split and exposure'
- linkname_default = 'split-and-bin-chain'
- usage = 'fermipy-split-and-bin-chain [options]'
- split-and-bin
- class fermipy.diffuse.gt_split_and_mktime.SplitAndMktime(**kwargs)[source]
Bases:
Chain
Small class to split, apply mktime and bin data according to some user-provided specification
This chain consists multiple
Link
objects:- select-energy-EBIN-ZCUT
Gtlink_select
Initial splitting by energy bin and zenith angle cut
- mktime-EBIN-ZCUT-FILTER
Gtlink_mktime
Application of gtmktime filter for zenith angle cut
- ltcube-EBIN-ZCUT-FILTER
Gtlink_ltcube
Computation of livetime cube for zenith angle cut
- select-type-EBIN-ZCUT-FILTER-TYPE
Gtlink_select
Refinement of selection from event types
- bin-EBIN-ZCUT-FILTER-TYPE
Gtlink_bin
Final binning of the data for each event type
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
hpx_order_max (<class 'int'>) – Maximum HEALPIX order for binning counts data. [9]
ft1file (<class 'str'>) – Path to list of input FT1 files [P8_P305_8years_source_zmax105.lst]
ft2file (<class 'str'>) – Path to list of input FT2 files [ft2_8years.lst]
evclass (<class 'int'>) – Event class bit mask [128]
outdir (<class 'str'>) – Output directory [counts_cubes]
outkey (<class 'str'>) – Key for this particular output file [None]
pfiles (<class 'str'>) – Directory for .par files [None]
do_ltsum (<class 'bool'>) – Sum livetime cube files [False]
scratch (<class 'str'>) – Scratch area [None]
dry_run (<class 'bool'>) – Print commands but do not run them [False]
- appname = 'fermipy-split-and-mktime'
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'do_ltsum': (False, 'Sum livetime cube files', <class 'bool'>), 'dry_run': (False, 'Print commands but do not run them', <class 'bool'>), 'evclass': (128, 'Event class bit mask', <class 'int'>), 'ft1file': ('P8_P305_8years_source_zmax105.lst', 'Path to list of input FT1 files', <class 'str'>), 'ft2file': ('ft2_8years.lst', 'Path to list of input FT2 files', <class 'str'>), 'hpx_order_max': (9, 'Maximum HEALPIX order for binning counts data.', <class 'int'>), 'outdir': ('counts_cubes', 'Output directory', <class 'str'>), 'outkey': (None, 'Key for this particular output file', <class 'str'>), 'pfiles': (None, 'Directory for .par files', <class 'str'>), 'scratch': (None, 'Scratch area', <class 'str'>)}
- description = 'Run gtselect and gtbin together'
- linkname_default = 'split-and-mktime'
- usage = 'fermipy-split-and-mktime [options]'
- select-energy-EBIN-ZCUT
- class fermipy.diffuse.gt_split_and_mktime.SplitAndMktimeChain(**kwargs)[source]
Bases:
Chain
Chain to run split and mktime and then make livetime and exposure cubes
This chain consists of:
- split-and-mktime
SplitAndMkTime_SG
Chain to make the binned counts maps for each input file
- coadd-split
CoaddSplit_SG
Link to co-add the binnec counts maps files
- ltsum
Gtltsum_SG
Link to co-add the livetime cube files
- expcube2
Gtexpcube2_SG
Link to make the corresponding binned exposure maps
- Parameters:
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
ft1file (<class 'str'>) – Path to list of input FT1 files [P8_P305_8years_source_zmax105.lst]
ft2file (<class 'str'>) – Path to list of input FT2 files [ft2_8years.lst]
hpx_order_ccube (<class 'int'>) – Maximum HEALPIX order for binning counts data. [9]
hpx_order_expcube (<class 'int'>) – Maximum HEALPIX order for exposure cubes. [6]
do_ltsum (<class 'bool'>) – Run gtltsum on inputs [False]
scratch (<class 'str'>) – Path to scratch area. [None]
dry_run (<class 'bool'>) – Print commands but do not run them [False]
- appname = 'fermipy-split-and-mktime-chain'
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'do_ltsum': (False, 'Run gtltsum on inputs', <class 'bool'>), 'dry_run': (False, 'Print commands but do not run them', <class 'bool'>), 'ft1file': ('P8_P305_8years_source_zmax105.lst', 'Path to list of input FT1 files', <class 'str'>), 'ft2file': ('ft2_8years.lst', 'Path to list of input FT2 files', <class 'str'>), 'hpx_order_ccube': (9, 'Maximum HEALPIX order for binning counts data.', <class 'int'>), 'hpx_order_expcube': (6, 'Maximum HEALPIX order for exposure cubes.', <class 'int'>), 'scratch': (None, 'Path to scratch area.', <class 'str'>)}
- description = 'Run split-and-mktime, coadd-split and exposure'
- linkname_default = 'split-and-mktime-chain'
- usage = 'fermipy-split-and-mktime-chain [options]'
- split-and-mktime
- class fermipy.diffuse.diffuse_analysis.DiffuseCompChain(**kwargs)[source]
Bases:
Chain
Chain to build srcmaps for diffuse components
This chain consists of:
- sum-ringsSumRings_SG
Merge GALProp gas maps by type and ring
- srcmaps-diffuseSrcmapsDiffuse_SG
Compute diffuse component source maps in parallel
- vstack-diffuseVstack_SG
Combine diffuse component source maps
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
library (<class 'str'>) – Path to yaml file defining model components. [models/library.yaml]
make_xml (<class 'bool'>) – Make XML files. [True]
outdir (<class 'str'>) – Output directory [None]
dry_run (<class 'bool'>) – Print commands but do not run them [False]
- appname = 'fermipy-diffuse-comp-chain'
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'dry_run': (False, 'Print commands but do not run them', <class 'bool'>), 'library': ('models/library.yaml', 'Path to yaml file defining model components.', <class 'str'>), 'make_xml': (True, 'Make XML files.', <class 'bool'>), 'outdir': (None, 'Output directory', <class 'str'>)}
- description = 'Run diffuse component analysis'
- linkname_default = 'diffuse-comp'
- usage = 'fermipy-diffuse-comp-chain [options]'
- class fermipy.diffuse.diffuse_analysis.CatalogCompChain(**kwargs)[source]
Bases:
Chain
Small class to build srcmaps for catalog components
This chain consists of:
- srcmaps-catalogSrcmapsCatalog_SG
Build source maps for all catalog sources in parallel
- gather-srcmapsGatherSrcmaps_SG
Gather source maps into
- merge-srcmapsMergeSrcmaps_SG
Compute source maps for merged sources
- Parameters:
comp (<class 'str'>) – Path to yaml file defining binning. [config/binning.yaml]
data (<class 'str'>) – Path to yaml file defining dataset. [config/dataset_sourceveto.yaml]
library (<class 'str'>) – Path to yaml file defining model components. [models/library.yaml]
nsrc (<class 'int'>) – Number of sources per job [500]
make_xml (<class 'bool'>) – Make XML files for diffuse components [False]
dry_run (<class 'bool'>) – Print commands but do not run them [False]
- appname = 'fermipy-catalog-comp-chain'
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'dry_run': (False, 'Print commands but do not run them', <class 'bool'>), 'library': ('models/library.yaml', 'Path to yaml file defining model components.', <class 'str'>), 'make_xml': (False, 'Make XML files for diffuse components', <class 'bool'>), 'nsrc': (500, 'Number of sources per job', <class 'int'>)}
- description = 'Run catalog component analysis'
- linkname_default = 'catalog-comp'
- usage = 'fermipy-catalog-comp-chain [options]'
- class fermipy.diffuse.gt_assemble_model.AssembleModelChain(**kwargs)[source]
Bases:
Chain
Small class to split, apply mktime and bin data according to some user-provided specification
- appname = 'fermipy-assemble-model-chain'
- default_options = {'comp': ('config/binning.yaml', 'Path to yaml file defining binning.', <class 'str'>), 'data': ('config/dataset_sourceveto.yaml', 'Path to yaml file defining dataset.', <class 'str'>), 'dry_run': (False, 'Print commands but do not run them', <class 'bool'>), 'hpx_order': (7, 'Maximum HEALPIX order for model fitting.', <class 'int'>), 'library': ('models/library.yaml', 'Path to yaml file defining model components.', <class 'str'>), 'models': ('models/modellist.yaml', 'Path to yaml file defining models.', <class 'str'>)}
- description = 'Run init-model and assemble-model'
- linkname_default = 'assemble-model-chain'
- usage = 'fermipy-assemble-model-chain [options]'
- class fermipy.diffuse.diffuse_analysis.DiffuseAnalysisChain(**kwargs)[source]
Bases:
Chain
Chain to define diffuse all-sky analysis
This chain consists of:
- prepare
SplitAndBinChain
Bin the data and make the exposure maps
- diffuse-comp
DiffuseCompChain
Make source maps for diffuse components
- catalog-comp
CatalogCompChain
Make source maps for catalog components
- assemble-model
AssembleModelChain
Assemble the models for fitting
- Parameters:
config (<class 'str'>) – Config yaml file [None]
dry_run (<class 'bool'>) – Print commands but do not run them [False]
- appname = 'fermipy-diffuse-analysis'
- default_options = {'config': (None, 'Config yaml file', <class 'str'>), 'dry_run': (False, 'Print commands but do not run them', <class 'bool'>)}
- description = 'Run diffuse analysis chain'
- linkname_default = 'diffuse'
- usage = 'fermipy-diffuse-analysis [options]'
- prepare
- class fermipy.diffuse.residual_cr.ResidualCRChain(**kwargs)[source]
Bases:
Chain
Chain to preform analysis of residual cosmic-ray contamination
This chain consists of:
- split-and-mktime
SplitAndMktimeChain
Chain to bin up the data and make exposure cubes
- residual-cr
ResidualCR
Residual CR analysis
- Parameters:
config (<class 'str'>) – Config yaml file [None]
- appname = 'fermipy-residual-cr-chain'
- default_options = {'config': (None, 'Config yaml file', <class 'str'>)}
- description = 'Run residual cosmic ray analysis'
- linkname_default = 'residual-cr-chain'
- usage = 'fermipy-residual-cr-chain [options]'
- split-and-mktime
- class fermipy.diffuse.solar.SunMoonChain(**kwargs)[source]
Bases:
Chain
Chain to construct sun and moon templates
This chain consists of:
- exphpsun
Gtexphpsun_SG
Build the sun-centered exposure cubes
- suntemp
Gtsuntemp_SG
Build the templates
- appname = 'fermipy-sunmoon-chain'
- default_options = {'config': (None, 'Config yaml file', <class 'str'>)}
- description = 'Run sun and moon template construction'
- linkname_default = 'summoon'
- usage = 'fermipy-sunmoon-chain [options]'
- exphpsun