def plot_points(self, axes, **kwargs): """ Plot the SED using matpotlib. """ data_kwargs = dict(color='black') data_kwargs.update(kwargs) edict = self.results['Energy'] fdict = self.results['dNdE'] file_energy_units = units.fromstring(edict['Units']) file_flux_units = units.fromstring(fdict['Units']) ce = lambda x: units.convert(np.asarray(x), file_energy_units, axes. energy_units_obj) # get energy part energy = ce(edict['Value']) if 'Lower' in edict and 'Upper' in edict: lower_energy = ce(edict['Lower']) upper_energy = ce(edict['Upper']) has_energy_errors = True else: has_energy_errors = False # get spectral part cf = lambda y: units.convert( energy**2 * np.asarray(y), axes.energy_units_obj**2 * file_flux_units, axes.flux_units_obj / units.cm**2 / units.s) dnde = cf(fdict['Value']) if 'Lower_Error' in fdict and 'Upper_Error' in fdict: # assymetric errors dnde_lower_err = cf(fdict['Lower_Error']) dnde_upper_err = cf(fdict['Upper_Error']) has_assymetric_errors = True else: has_assymetric_errors = False dnde_err = cf(fdict['Average_Error']) # get limits, otherwise assume all significant if 'Upper_Limit' in fdict and 'Significant' in self.results: dnde_ul = cf(fdict['Upper_Limit']) significant = np.asarray(self.results['Significant']) has_upper_limits = True else: has_upper_limits = False plot_points( x=energy, xlo=lower_energy if has_energy_errors else None, xhi=upper_energy if has_energy_errors else None, y=dnde, y_lower_err=dnde_lower_err if has_assymetric_errors else dnde_err, y_upper_err=dnde_upper_err if has_assymetric_errors else dnde_err, y_ul=dnde_ul if has_upper_limits else None, significant=significant if has_upper_limits else np.ones(len(energy), dtype=bool), axes=axes, **data_kwargs)
def pointlike_sed_to_dict(bandflux, flux_units='erg', energy_units='MeV'): results = defaultdict(lambda:defaultdict(list)) ce=lambda e: units.convert(e,'MeV',energy_units) cp = lambda e: units.convert(e,'1/MeV','1/%s' % flux_units) results['Energy']['Units'] = energy_units results['dNdE']['Units'] = 'ph/cm^2/s/%s' % flux_units results['Significant'] = [] for r in bandflux.rec: results['Energy']['Lower'].append(ce(r.elow)) results['Energy']['Upper'].append(ce(r.ehigh)) results['Energy']['Value'].append(ce(np.sqrt(r.elow*r.ehigh))) # Undo scaling in the bandflux recarray fac = r.elow*r.ehigh*bandflux.scale_factor if r.flux > 0: results['Significant'].append(True) results['dNdE']['Value'].append(cp(r.flux/fac)) results['dNdE']['Average_Error'].append(cp((r.uflux/fac - r.lflux/fac)/2)) results['dNdE']['Lower_Error'].append(cp((r.flux-r.lflux)/fac)) results['dNdE']['Upper_Error'].append(cp((r.uflux-r.flux)/fac)) results['dNdE']['Upper_Limit'].append(np.nan) else: results['Significant'].append(False) results['dNdE']['Value'].append(np.nan) results['dNdE']['Average_Error'].append(np.nan) results['dNdE']['Lower_Error'].append(np.nan) results['dNdE']['Upper_Error'].append(np.nan) results['dNdE']['Upper_Limit'].append(cp(r.uflux/fac)) return tolist(results)
def pointlike_model_to_flux(model, emin, emax, flux_units='erg', energy_units='MeV', errors=True, include_prefactor=False, prefactor_energy=None): cef=lambda e: units.convert(e,'MeV',flux_units) ce=lambda e: units.convert(e,'MeV',energy_units) f=dict() if errors: f['flux'],f['flux_err']=model.i_flux(emin=emin,emax=emax,error=True) ef,ef_err=model.i_flux(emin=emin,emax=emax,e_weight=1,error=True) f['eflux'],f['eflux_err']=cef(ef),cef(ef_err) else: f['flux']=model.i_flux(emin=emin,emax=emax,error=False) ef=model.i_flux(emin=emin,emax=emax,e_weight=1,error=False) f['eflux']=cef(ef) f['flux_units']='ph/cm^2/s' f['eflux_units']='%s/cm^2/s' % flux_units f['energy_units']=energy_units f['emin'],f['emax']=ce(emin),ce(emax) if include_prefactor: assert prefactor_energy is not None cp = lambda e: units.convert(e,'1/MeV','1/%s' % flux_units) f['prefactor'] = cp(model(prefactor_energy)) f['prefactor_units'] = 'ph/cm^2/s/%s' % flux_units f['prefactor_energy'] = ce(prefactor_energy) return tolist(f)
def gtlike_flux_dict(like,name, emin=None,emax=None,flux_units='erg', energy_units='MeV', errors=True, include_prefactor=False, prefactor_energy=None): """ Note, emin, emax, and prefactor_energy must be in MeV """ if emin is None and emax is None: emin, emax = get_full_energy_range(like) cef=lambda e: units.convert(e,'MeV',flux_units) ce=lambda e: units.convert(e,'MeV',energy_units) f=dict(flux=like.flux(name,emin=emin,emax=emax), flux_units='ph/cm^2/s', eflux=cef(like.energyFlux(name,emin=emin,emax=emax)), eflux_units='%s/cm^2/s' % flux_units, emin=ce(emin), emax=ce(emax), energy_units=energy_units) if errors: try: # incase the errors were not calculated f['flux_err']=like.fluxError(name,emin=emin,emax=emax) f['eflux_err']=cef(like.energyFluxError(name,emin=emin,emax=emax)) except Exception, ex: print 'ERROR calculating flux error: ', ex traceback.print_exc(file=sys.stdout) f['flux_err']=-1 f['eflux_err']=-1
def plot_points(self, axes, **kwargs): """ Plot the SED using matpotlib. """ data_kwargs=dict(color='black') data_kwargs.update(kwargs) edict = self.results['Energy'] fdict = self.results['dNdE'] file_energy_units = units.fromstring(edict['Units']) file_flux_units = units.fromstring(fdict['Units']) ce = lambda x: units.convert(np.asarray(x),file_energy_units, axes.energy_units_obj) # get energy part energy = ce(edict['Value']) if 'Lower' in edict and 'Upper' in edict: lower_energy = ce(edict['Lower']) upper_energy = ce(edict['Upper']) has_energy_errors = True else: has_energy_errors = False # get spectral part cf = lambda y: units.convert(energy**2*np.asarray(y), axes.energy_units_obj**2*file_flux_units, axes.flux_units_obj/units.cm**2/units.s) dnde = cf(fdict['Value']) if 'Lower_Error' in fdict and 'Upper_Error' in fdict: # assymetric errors dnde_lower_err = cf(fdict['Lower_Error']) dnde_upper_err = cf(fdict['Upper_Error']) has_assymetric_errors = True else: has_assymetric_errors = False dnde_err = cf(fdict['Average_Error']) # get limits, otherwise assume all significant if 'Upper_Limit' in fdict and 'Significant' in self.results: dnde_ul = cf(fdict['Upper_Limit']) significant = np.asarray(self.results['Significant']) has_upper_limits=True else: has_upper_limits=False plot_points( x=energy, xlo=lower_energy if has_energy_errors else None, xhi=upper_energy if has_energy_errors else None, y=dnde, y_lower_err=dnde_lower_err if has_assymetric_errors else dnde_err, y_upper_err=dnde_upper_err if has_assymetric_errors else dnde_err, y_ul=dnde_ul if has_upper_limits else None, significant=significant if has_upper_limits else np.ones(len(energy),dtype=bool), axes=axes, **data_kwargs)
def pointlike_sed_to_dict(bandflux, flux_units='erg', energy_units='MeV'): results = defaultdict(lambda: defaultdict(list)) ce = lambda e: units.convert(e, 'MeV', energy_units) cp = lambda e: units.convert(e, '1/MeV', '1/%s' % flux_units) results['Energy']['Units'] = energy_units results['dNdE']['Units'] = 'ph/cm^2/s/%s' % flux_units results['Significant'] = [] for r in bandflux.rec: results['Energy']['Lower'].append(ce(r.elow)) results['Energy']['Upper'].append(ce(r.ehigh)) results['Energy']['Value'].append(ce(np.sqrt(r.elow * r.ehigh))) # Undo scaling in the bandflux recarray fac = r.elow * r.ehigh * bandflux.scale_factor if r.flux > 0: results['Significant'].append(True) results['dNdE']['Value'].append(cp(r.flux / fac)) results['dNdE']['Average_Error'].append( cp((r.uflux / fac - r.lflux / fac) / 2)) results['dNdE']['Lower_Error'].append( cp((r.flux - r.lflux) / fac)) results['dNdE']['Upper_Error'].append( cp((r.uflux - r.flux) / fac)) results['dNdE']['Upper_Limit'].append(np.nan) else: results['Significant'].append(False) results['dNdE']['Value'].append(np.nan) results['dNdE']['Average_Error'].append(np.nan) results['dNdE']['Lower_Error'].append(np.nan) results['dNdE']['Upper_Error'].append(np.nan) results['dNdE']['Upper_Limit'].append(cp(r.uflux / fac)) return tolist(results)
def pointlike_powerlaw_prefactor_dict(roi, which, flux_units='erg', errors=True): model=roi.get_model(which) assert isinstance(model,PowerLaw) cp = lambda e: units.convert(e,'1/MeV','1/%s' % flux_units) d = dict() d['prefactor'] = cp(model['norm']) if errors: d['prefactor_err'] = cp(model.error('norm')) d['prefactor_units'] = 'ph/cm^2/s/%s' % flux_units d['prefactor_energy'] = model.e0 d['prefactor_energy_units'] = 'MeV' return d
def gtlike_powerlaw_prefactor_dict(like, name, flux_units='erg', errors=True, minos_errors=False): cp = lambda e: units.convert(e,'1/MeV','1/%s' % flux_units) source = like.logLike.getSource(name) spectrum = source.spectrum() assert spectrum.genericName() == 'PowerLaw' pref = spectrum.getParam('Prefactor') scale = spectrum.getParam('Scale') d=dict() d['prefactor'] = cp(pref.getTrueValue()) if errors: d['prefactor_err'] = cp(pref.error()*pref.getScale()) if minos_errors: try: lower,upper=like.minosError(name, 'Prefactor') d['prefactor_lower_err'] = cp(-1*lower*pref.getScale()) d['prefactor_upper_err'] = cp(upper*pref.getScale()) except Exception, ex: print 'ERROR computing Minos errors on parameter Prefactor for source %s:' % (name), ex d['prefactor_lower_err'] = np.nan d['prefactor_upper_err'] = np.nan
def energy_dict(emin, emax, energy_units='MeV'): ce=lambda e: units.convert(e,'MeV',energy_units) return dict(emin=ce(emin), emax=ce(emax), emiddle=ce(np.sqrt(emin*emax)), energy_units=energy_units)
if errors: try: # incase the errors were not calculated f['flux_err']=like.fluxError(name,emin=emin,emax=emax) f['eflux_err']=cef(like.energyFluxError(name,emin=emin,emax=emax)) except Exception, ex: print 'ERROR calculating flux error: ', ex traceback.print_exc(file=sys.stdout) f['flux_err']=-1 f['eflux_err']=-1 if include_prefactor: assert prefactor_energy is not None source = like.logLike.getSource(name) spectrum = source.spectrum() cp = lambda e: units.convert(e,'1/MeV','1/%s' % flux_units) f['prefactor'] = cp(SpectrumPlotter.get_dnde_mev(spectrum,prefactor_energy)) f['prefactor_units'] = 'ph/cm^2/s/%s' % flux_units f['prefactor_energy'] = ce(prefactor_energy) return tolist(f) def gtlike_powerlaw_prefactor_dict(like, name, flux_units='erg', errors=True, minos_errors=False): cp = lambda e: units.convert(e,'1/MeV','1/%s' % flux_units) source = like.logLike.getSource(name) spectrum = source.spectrum() assert spectrum.genericName() == 'PowerLaw' pref = spectrum.getParam('Prefactor') scale = spectrum.getParam('Scale') d=dict()
def get_results(self, pwn): classifier = self.get_classification(pwn) spatial_model=classifier['spatial_model'] spectral_model=classifier['spectral_model'] source_class = classifier['source_class'] if spatial_model is None or spectral_model is None or source_class is None: print '%s has not been classified yet, skipping' % pwn return None assert source_class in PWNClassifier.allowed_source_class assert source_class == 'Upper_Limit' or spatial_model in PWNClassifier.allowed_spatial_models assert source_class == 'Upper_Limit' or spectral_model in PWNClassifier.allowed_spectral_models results = self.loader.get_results(pwn, require_all_exists=True, get_variability=True) if results is None: print 'Results for %s is not done yet, skipping' % pwn return None point_gtlike = results['point']['gtlike'] extended_gtlike = results['extended']['gtlike'] if isnan(spatial_model): # upper limits gtlike = results['at_pulsar']['gtlike'] pointlike = results['at_pulsar']['pointlike'] else: gtlike = results[spatial_model.lower()]['gtlike'] pointlike = results[spatial_model.lower()]['pointlike'] at_pulsar_cutoff=results['at_pulsar']['gtlike']['test_cutoff'] d = copy.copy(classifier) d['raw_phase'] = results['raw_phase'] if results.has_key('shifted_phase'): d['shifted_phase'] = results['shifted_phase'] # likelihood stuff d['ts_point'] = max(point_gtlike['TS']['reoptimize'],0) d['abbreviated_source_class'] = self.abbreviated_source_class_mapper[source_class] if source_class in ['Confused', 'Pulsar', 'Pulsar_Confused', 'PWN']: d['ts_ext'] = max(extended_gtlike['TS']['reoptimize']-point_gtlike['TS']['reoptimize'],0) d['ts_cutoff'] = max(at_pulsar_cutoff['hypothesis_1']['TS']['reoptimize']-at_pulsar_cutoff['hypothesis_0']['TS']['reoptimize'],0) alt_models = [point_gtlike['altdiff'][dist,halo,TS] for dist,halo,TS in itertools.product(['SNR','Lorimer'],[4,10],[150,100000])] if np.any([i is None for i in alt_models]): d['ts_altdiff'] = None print 'BAD = ' else: all_TS = [ i['TS']['reoptimize'] if i is not None else None for i in alt_models] d['ts_altdiff'] = max(min(all_TS),0) print d['ts_point'], all_TS, d['ts_altdiff'] elif source_class == 'Upper_Limit': pass else: raise Exception("...") if spatial_model == 'Extended': # note, does not make sense to use extended spatial model for variability d['ts_var'] = results['point']['variability']['TS_var']['gtlike'] elif isinstance(spatial_model,float) and np.isnan(spatial_model): # upper limit d['ts_var'] = results['at_pulsar']['variability']['TS_var']['gtlike'] else: d['ts_var'] = results[spatial_model.lower()]['variability']['TS_var']['gtlike'] # spectral stuff d['flux'] = None d['flux_err'] = None d['energy_flux'] = None d['energy_flux_err'] = None d['prefactor'] = None d['prefactor_err'] = None d['normalization'] = None d['normalization_err'] = None d['index'] = None d['index_err'] = None d['model_scale'] = None d['cutoff'] = None d['cutoff_err'] = None convert_prefactor = lambda x: units.convert(x, 'ph/cm^2/s/MeV', 'ph/cm^2/s/erg') if source_class != 'Upper_Limit': if spectral_model in ['PowerLaw','FileFunction']: d['flux'] = gtlike['flux']['flux'] d['flux_err'] = gtlike['flux']['flux_err'] assert gtlike['flux']['flux_units'] == 'ph/cm^2/s' d['energy_flux'] = gtlike['flux']['eflux'] d['energy_flux_err'] = gtlike['flux']['eflux_err'] assert gtlike['flux']['eflux_units'] == 'erg/cm^2/s' d['spectrum'] = gtlike['spectrum'] if spectral_model == 'PowerLaw': # Note, prefactor is d['prefactor'] = convert_prefactor(gtlike['spectrum']['Prefactor']) d['prefactor_err'] = convert_prefactor(gtlike['spectrum']['Prefactor_err']) d['index'] = -1*gtlike['spectrum']['Index'] d['index_err'] = np.abs(gtlike['spectrum']['Index_err']) d['model_scale'] = gtlike['spectrum']['Scale'] elif spectral_model == 'FileFunction': d['normalization'] = gtlike['spectrum']['Normalization'] d['normalization_err'] = gtlike['spectrum']['Normalization_err'] elif spectral_model == 'PLSuperExpCutoff': h1 = gtlike['test_cutoff']['hypothesis_1'] d['spectrum'] = h1['spectrum'] d['flux'] = h1['flux']['flux'] d['flux_err'] = h1['flux']['flux_err'] d['energy_flux'] = h1['flux']['eflux'] d['energy_flux_err'] = h1['flux']['eflux_err'] assert h1['flux']['flux_units'] == 'ph/cm^2/s' assert h1['flux']['eflux_units'] == 'erg/cm^2/s' d['prefactor'] = convert_prefactor(h1['spectrum']['Prefactor']) d['prefactor_err'] = convert_prefactor(h1['spectrum']['Prefactor_err']) d['index'] = -1*h1['spectrum']['Index1'] d['index_err'] = np.abs(h1['spectrum']['Index1_err']) d['model_scale'] = h1['spectrum']['Scale'] d['cutoff'] = h1['spectrum']['Cutoff'] d['cutoff_err'] = h1['spectrum']['Cutoff_err'] else: # add in upper limits pass # spatial stuff d['ra'] = pointlike['position']['equ'][0] d['dec'] = pointlike['position']['equ'][1] d['glon'] = pointlike['position']['gal'][0] d['glat'] = pointlike['position']['gal'][1] d['poserr'] = None if spatial_model in [ 'Point', 'Extended' ]: ellipse = pointlike['spatial_model']['ellipse'] if ellipse.has_key('lsigma'): d['poserr'] = ellipse['lsigma'] else: print 'WARNING: localization failed for %s' % pwn d['poserr'] = None d['extension'] = None d['extension_err'] = None if spatial_model == 'Extended': d['extension'] = pointlike['spatial_model']['Sigma'] d['extension_err'] = pointlike['spatial_model']['Sigma_err'] d['powerlaw_flux_upper_limit'] = None d['powerlaw_energy_flux_upper_limit'] = None d['cutoff_flux_upper_limit'] = None d['cutoff_energy_flux_upper_limit'] = None if source_class in ['Confused', 'Pulsar', 'Pulsar_Confused', 'PWN']: pass elif source_class == 'Upper_Limit': d['powerlaw_flux_upper_limit'] = gtlike['powerlaw_upper_limit']['flux'] d['powerlaw_energy_flux_upper_limit'] = gtlike['powerlaw_upper_limit']['eflux'] assert gtlike['powerlaw_upper_limit']['flux_units'] == 'ph/cm^2/s' assert gtlike['powerlaw_upper_limit']['eflux_units'] == 'erg/cm^2/s' d['cutoff_flux_upper_limit'] = gtlike['cutoff_upper_limit']['flux'] d['cutoff_energy_flux_upper_limit'] = gtlike['cutoff_upper_limit']['eflux'] assert gtlike['cutoff_upper_limit']['flux_units'] == 'ph/cm^2/s' assert gtlike['cutoff_upper_limit']['eflux_units'] == 'erg/cm^2/s' else: raise Exception("...") # add in 4BPD SED sed = gtlike['seds']['4bpd'] sed_ts = np.asarray(sed['Test_Statistic']) sed_ts = np.where(sed_ts>0,sed_ts,0) sed_lower_energy = np.asarray(sed['Energy']['Lower']) sed_upper_energy = np.asarray(sed['Energy']['Upper']) sed_middle_energy = np.asarray(sed['Energy']['Value']) sed_prefactor = np.asarray(sed['dNdE']['Value']) sed_prefactor_lower_err = np.asarray(sed['dNdE']['Lower_Error']) sed_prefactor_upper_err = np.asarray(sed['dNdE']['Upper_Error']) sed_prefactor_upper_limit = np.asarray(sed['dNdE']['Upper_Limit']) assert sed['Energy']['Units'] == 'MeV' assert sed['dNdE']['Units'] == 'ph/cm^2/s/erg' d['sed_4bpd'] = sed # Note, when overall source is not significant, do not include upper limits d['sed_ts'] = sed_ts d['sed_lower_energy'] = sed_lower_energy d['sed_upper_energy'] = sed_upper_energy d['sed_middle_energy'] = sed_middle_energy if source_class in ['Confused', 'Pulsar', 'Pulsar_Confused', 'PWN']: significant = (sed_ts >= 4) d['sed_prefactor'] = np.where(significant, sed_prefactor, np.nan) d['sed_prefactor_lower_err'] = np.where(significant, sed_prefactor_lower_err, np.nan) d['sed_prefactor_upper_err'] = np.where(significant, sed_prefactor_upper_err, np.nan) d['sed_prefactor_upper_limit'] = np.where(~significant, sed_prefactor_upper_limit, np.nan) elif source_class == 'Upper_Limit': array_from = lambda x: np.asarray([x]*len(sed_ts)) d['sed_prefactor'] = array_from(np.nan) d['sed_prefactor_lower_err'] = array_from(np.nan) d['sed_prefactor_upper_err'] = array_from(np.nan) d['sed_prefactor_upper_limit'] = sed_prefactor_upper_limit else: raise Exception("...") return d
def get_results(self, pwn): classifier = self.get_classification(pwn) spatial_model = classifier['spatial_model'] spectral_model = classifier['spectral_model'] source_class = classifier['source_class'] if spatial_model is None or spectral_model is None or source_class is None: print '%s has not been classified yet, skipping' % pwn return None assert source_class in PWNClassifier.allowed_source_class assert source_class == 'Upper_Limit' or spatial_model in PWNClassifier.allowed_spatial_models assert source_class == 'Upper_Limit' or spectral_model in PWNClassifier.allowed_spectral_models results = self.loader.get_results(pwn, require_all_exists=True, get_variability=True) if results is None: print 'Results for %s is not done yet, skipping' % pwn return None point_gtlike = results['point']['gtlike'] extended_gtlike = results['extended']['gtlike'] if isnan(spatial_model): # upper limits gtlike = results['at_pulsar']['gtlike'] pointlike = results['at_pulsar']['pointlike'] else: gtlike = results[spatial_model.lower()]['gtlike'] pointlike = results[spatial_model.lower()]['pointlike'] at_pulsar_cutoff = results['at_pulsar']['gtlike']['test_cutoff'] d = copy.copy(classifier) d['raw_phase'] = results['raw_phase'] if results.has_key('shifted_phase'): d['shifted_phase'] = results['shifted_phase'] # likelihood stuff d['ts_point'] = max(point_gtlike['TS']['reoptimize'], 0) d['abbreviated_source_class'] = self.abbreviated_source_class_mapper[ source_class] if source_class in ['Confused', 'Pulsar', 'Pulsar_Confused', 'PWN']: d['ts_ext'] = max( extended_gtlike['TS']['reoptimize'] - point_gtlike['TS']['reoptimize'], 0) d['ts_cutoff'] = max( at_pulsar_cutoff['hypothesis_1']['TS']['reoptimize'] - at_pulsar_cutoff['hypothesis_0']['TS']['reoptimize'], 0) alt_models = [ point_gtlike['altdiff'][dist, halo, TS] for dist, halo, TS in itertools.product(['SNR', 'Lorimer'], [4, 10], [150, 100000]) ] if np.any([i is None for i in alt_models]): d['ts_altdiff'] = None print 'BAD = ' else: all_TS = [ i['TS']['reoptimize'] if i is not None else None for i in alt_models ] d['ts_altdiff'] = max(min(all_TS), 0) print d['ts_point'], all_TS, d['ts_altdiff'] elif source_class == 'Upper_Limit': pass else: raise Exception("...") if spatial_model == 'Extended': # note, does not make sense to use extended spatial model for variability d['ts_var'] = results['point']['variability']['TS_var']['gtlike'] elif isinstance(spatial_model, float) and np.isnan(spatial_model): # upper limit d['ts_var'] = results['at_pulsar']['variability']['TS_var'][ 'gtlike'] else: d['ts_var'] = results[ spatial_model.lower()]['variability']['TS_var']['gtlike'] # spectral stuff d['flux'] = None d['flux_err'] = None d['energy_flux'] = None d['energy_flux_err'] = None d['prefactor'] = None d['prefactor_err'] = None d['normalization'] = None d['normalization_err'] = None d['index'] = None d['index_err'] = None d['model_scale'] = None d['cutoff'] = None d['cutoff_err'] = None convert_prefactor = lambda x: units.convert(x, 'ph/cm^2/s/MeV', 'ph/cm^2/s/erg') if source_class != 'Upper_Limit': if spectral_model in ['PowerLaw', 'FileFunction']: d['flux'] = gtlike['flux']['flux'] d['flux_err'] = gtlike['flux']['flux_err'] assert gtlike['flux']['flux_units'] == 'ph/cm^2/s' d['energy_flux'] = gtlike['flux']['eflux'] d['energy_flux_err'] = gtlike['flux']['eflux_err'] assert gtlike['flux']['eflux_units'] == 'erg/cm^2/s' d['spectrum'] = gtlike['spectrum'] if spectral_model == 'PowerLaw': # Note, prefactor is d['prefactor'] = convert_prefactor( gtlike['spectrum']['Prefactor']) d['prefactor_err'] = convert_prefactor( gtlike['spectrum']['Prefactor_err']) d['index'] = -1 * gtlike['spectrum']['Index'] d['index_err'] = np.abs(gtlike['spectrum']['Index_err']) d['model_scale'] = gtlike['spectrum']['Scale'] elif spectral_model == 'FileFunction': d['normalization'] = gtlike['spectrum']['Normalization'] d['normalization_err'] = gtlike['spectrum'][ 'Normalization_err'] elif spectral_model == 'PLSuperExpCutoff': h1 = gtlike['test_cutoff']['hypothesis_1'] d['spectrum'] = h1['spectrum'] d['flux'] = h1['flux']['flux'] d['flux_err'] = h1['flux']['flux_err'] d['energy_flux'] = h1['flux']['eflux'] d['energy_flux_err'] = h1['flux']['eflux_err'] assert h1['flux']['flux_units'] == 'ph/cm^2/s' assert h1['flux']['eflux_units'] == 'erg/cm^2/s' d['prefactor'] = convert_prefactor(h1['spectrum']['Prefactor']) d['prefactor_err'] = convert_prefactor( h1['spectrum']['Prefactor_err']) d['index'] = -1 * h1['spectrum']['Index1'] d['index_err'] = np.abs(h1['spectrum']['Index1_err']) d['model_scale'] = h1['spectrum']['Scale'] d['cutoff'] = h1['spectrum']['Cutoff'] d['cutoff_err'] = h1['spectrum']['Cutoff_err'] else: # add in upper limits pass # spatial stuff d['ra'] = pointlike['position']['equ'][0] d['dec'] = pointlike['position']['equ'][1] d['glon'] = pointlike['position']['gal'][0] d['glat'] = pointlike['position']['gal'][1] d['poserr'] = None if spatial_model in ['Point', 'Extended']: ellipse = pointlike['spatial_model']['ellipse'] if ellipse.has_key('lsigma'): d['poserr'] = ellipse['lsigma'] else: print 'WARNING: localization failed for %s' % pwn d['poserr'] = None d['extension'] = None d['extension_err'] = None if spatial_model == 'Extended': d['extension'] = pointlike['spatial_model']['Sigma'] d['extension_err'] = pointlike['spatial_model']['Sigma_err'] d['powerlaw_flux_upper_limit'] = None d['powerlaw_energy_flux_upper_limit'] = None d['cutoff_flux_upper_limit'] = None d['cutoff_energy_flux_upper_limit'] = None if source_class in ['Confused', 'Pulsar', 'Pulsar_Confused', 'PWN']: pass elif source_class == 'Upper_Limit': d['powerlaw_flux_upper_limit'] = gtlike['powerlaw_upper_limit'][ 'flux'] d['powerlaw_energy_flux_upper_limit'] = gtlike[ 'powerlaw_upper_limit']['eflux'] assert gtlike['powerlaw_upper_limit']['flux_units'] == 'ph/cm^2/s' assert gtlike['powerlaw_upper_limit'][ 'eflux_units'] == 'erg/cm^2/s' d['cutoff_flux_upper_limit'] = gtlike['cutoff_upper_limit']['flux'] d['cutoff_energy_flux_upper_limit'] = gtlike['cutoff_upper_limit'][ 'eflux'] assert gtlike['cutoff_upper_limit']['flux_units'] == 'ph/cm^2/s' assert gtlike['cutoff_upper_limit']['eflux_units'] == 'erg/cm^2/s' else: raise Exception("...") # add in 4BPD SED sed = gtlike['seds']['4bpd'] sed_ts = np.asarray(sed['Test_Statistic']) sed_ts = np.where(sed_ts > 0, sed_ts, 0) sed_lower_energy = np.asarray(sed['Energy']['Lower']) sed_upper_energy = np.asarray(sed['Energy']['Upper']) sed_middle_energy = np.asarray(sed['Energy']['Value']) sed_prefactor = np.asarray(sed['dNdE']['Value']) sed_prefactor_lower_err = np.asarray(sed['dNdE']['Lower_Error']) sed_prefactor_upper_err = np.asarray(sed['dNdE']['Upper_Error']) sed_prefactor_upper_limit = np.asarray(sed['dNdE']['Upper_Limit']) assert sed['Energy']['Units'] == 'MeV' assert sed['dNdE']['Units'] == 'ph/cm^2/s/erg' d['sed_4bpd'] = sed # Note, when overall source is not significant, do not include upper limits d['sed_ts'] = sed_ts d['sed_lower_energy'] = sed_lower_energy d['sed_upper_energy'] = sed_upper_energy d['sed_middle_energy'] = sed_middle_energy if source_class in ['Confused', 'Pulsar', 'Pulsar_Confused', 'PWN']: significant = (sed_ts >= 4) d['sed_prefactor'] = np.where(significant, sed_prefactor, np.nan) d['sed_prefactor_lower_err'] = np.where(significant, sed_prefactor_lower_err, np.nan) d['sed_prefactor_upper_err'] = np.where(significant, sed_prefactor_upper_err, np.nan) d['sed_prefactor_upper_limit'] = np.where( ~significant, sed_prefactor_upper_limit, np.nan) elif source_class == 'Upper_Limit': array_from = lambda x: np.asarray([x] * len(sed_ts)) d['sed_prefactor'] = array_from(np.nan) d['sed_prefactor_lower_err'] = array_from(np.nan) d['sed_prefactor_upper_err'] = array_from(np.nan) d['sed_prefactor_upper_limit'] = sed_prefactor_upper_limit else: raise Exception("...") return d