def _calculate(self): """ Compute the flux data points for each energy. """ like = self.like name = self.name # Freeze all sources except one to make sed of. all_sources = like.sourceNames() if name not in all_sources: raise Exception("Cannot find source %s in list of sources" % name) saved_state = SuperState(like) self.results = dict( name=name, bands=[], min_ts=self.min_ts, ) for i,(emin,emax,e_middle) in enumerate(zip(self.lower_energy,self.upper_energy,self.middle_energy)): if self.verbosity: print 'Calculating bandfits from %.0dMeV to %.0dMeV' % (emin,emax) like.setEnergyRange(float(emin)+1, float(emax)-1) # Scale the powerlaw to the input spectral model => helps with convergence old_flux = self.init_model.i_flux(emin=emin, emax=emax) model = PowerLaw(index=2, e0=e_middle) model.set_flux(old_flux, emin=emin, emax=emax) norm = model['norm'] model.set_limits('norm',norm/float(self.fit_range),norm*self.fit_range, scale=norm) model.set_limits('index',-5,5) spectrum = build_gtlike_spectrum(model) like.setSpectrum(name,spectrum) like.syncSrcParams(name) if self.verbosity: print 'Before bandfits fitting from %.0dMeV to %.0dMeV' % (emin,emax) print summary(like) paranoid_gtlike_fit(like, verbosity=self.verbosity) if self.verbosity: print 'After bandfits fitting from %.0dMeV to %.0dMeV' % (emin,emax) print summary(like) r = source_dict(like, name, emin=emin, emax=emax, flux_units=self.flux_units, energy_units=self.energy_units, verbosity=self.verbosity) if self.verbosity: print 'Calculating bandfits upper limit from %.0dMeV to %.0dMeV' % (emin,emax) g = GtlikePowerLawUpperLimit(like, name, powerlaw_index=self.upper_limit_index, cl=self.ul_confidence, emin=emin,emax=emax, flux_units=self.flux_units, energy_units=self.energy_units, upper_limit_kwargs=self.upper_limit_kwargs, include_prefactor=True, prefactor_energy=e_middle, verbosity=self.verbosity) r['upper_limit'] = g.todict() r['prefactor'] = powerlaw_prefactor_dict(like, name, errors=True, minos_errors=False, flux_units=self.flux_units) r['significant']=r['TS']['reoptimize']>self.min_ts self.results['bands'].append(r) # revert to old model like.setEnergyRange(*self.init_energes) saved_state.restore()
def build_roi(self, name, fast): if fast: roi_size=5 binsperdec = 2 max_free=2 free_radius=2 else: roi_size = 10 binsperdec = 4 max_free=5 free_radius=5 catalog = Catalog2FGL('$FERMI/catalogs/gll_psc_v05.fit', latextdir='$FERMI/extended_archives/gll_psc_v05_templates', prune_radius=0, max_free=max_free, free_radius=free_radius, limit_parameters=True) ft1 = self.radiopsr_loader.get_ft1(name) ft2 = self.radiopsr_loader.get_ft2(name) ltcube = self.radiopsr_loader.get_ltcube(name) binfile = self.radiopsr_loader.get_binfile(name, binsperdec) roi_dir = self.radiopsr_loader.get_skydir(name) ds = DataSpecification( ft1files = ft1, ft2files = ft2, ltcube = ltcube, binfile = binfile) sa = SpectralAnalysis(ds, binsperdec = binsperdec, emin = 100, emax = 1000000, irf = "P7SOURCE_V6", roi_dir = roi_dir, maxROI = roi_size, minROI = roi_size, event_class= 0) fit_emin = 1e2 fit_emax = 10**5.5 model=PowerLaw(index=2, e0=np.sqrt(fit_emin*fit_emax)) model.set_limits('index',-5,5) ps = PointSource(name=name, model=model, skydir=roi_dir) point_sources = [ps] diffuse_sources = get_default_diffuse(diffdir="/afs/slac/g/glast/groups/diffuse/rings/2year", gfile="ring_2year_P76_v0.fits", ifile="isotrop_2year_P76_source_v0.txt", limit_parameters=True) roi=sa.roi(point_sources=point_sources, diffuse_sources=diffuse_sources, catalogs=catalog, fit_emin=fit_emin, fit_emax=fit_emax) return roi
def _calculate(self,*args,**kwargs): """ Convert all units into sympy arrays after the initial calculation. """ like = self.like name = self.name init_energes = like.energies[[0,-1]] # Freeze all sources except one to make sed of. all_sources = like.sourceNames() if name not in all_sources: raise Exception("Cannot find source %s in list of sources" % name) # make copy of parameter values + free parameters saved_state = SuperState(like) if self.verbosity: print 'Freezing background sources' for other_name in get_background(like): if self.freeze_bg_diffuse: if self.verbosity: print ' * Freezing diffuse source %s' % other_name modify(like, other_name, free=False) else: if self.verbosity: print ' * Freezing spectral shape for diffuse source %s' % other_name modify(like, other_name, freeze_spectral_shape=True) for other_name in get_sources(like): if self.freeze_bg_sources: if self.verbosity: print ' * Freezing bg source %s' % other_name modify(like, other_name, free=False) else: if self.verbosity: print ' * Freezing spectral shape for bg source %s' % other_name modify(like, other_name, freeze_spectral_shape=True) self.raw_results = [] for i,(lower,upper) in enumerate(zip(self.lower,self.upper)): like.setEnergyRange(float(lower)+1, float(upper)-1) e = np.sqrt(lower*upper) if self.verbosity: print 'Calculating SED from %.0dMeV to %.0dMeV' % (lower,upper) """ Note, the most robust method I have found for computing SEDs in gtlike is: (a) Create a generic spectral model with a fixed spectral index. (b) Set the 'Scale' to sqrt(emin*emax) so the prefactor is dNdE in the middle of the sed bin. (b) Set the limits to go from norm/fit_range to norm*fit_range and set the scale to 'norm' """ old_flux = self.init_model.i_flux(emin=lower,emax=upper) model = PowerLaw(index=self.powerlaw_index, e0=e) model.set_flux(old_flux, emin=lower, emax=upper) norm = model['norm'] model.set_limits('norm',norm/float(self.fit_range),norm*self.fit_range, scale=norm) model.set_limits('index',-5,5) model.freeze('index') spectrum = build_gtlike_spectrum(model) like.setSpectrum(name,spectrum) like.syncSrcParams(name) if self.verbosity: print 'Before fitting SED from %.0dMeV to %.0dMeV' % (lower,upper) print summary(like) paranoid_gtlike_fit(like, verbosity=self.verbosity) if self.verbosity: print 'After fitting SED from %.0dMeV to %.0dMeV' % (lower,upper) print summary(like) d = dict() self.raw_results.append(d) d['energy'] = energy_dict(emin=lower, emax=upper, energy_units=self.energy_units) d['flux'] = flux_dict(like, name, emin=lower,emax=upper, flux_units=self.flux_units, errors=True, include_prefactor=True, prefactor_energy=e) d['prefactor'] = powerlaw_prefactor_dict(like, name, errors=self.save_hesse_errors, minos_errors=True, flux_units=self.flux_units) d['TS'] = ts_dict(like, name, verbosity=self.verbosity) if self.verbosity: print 'Calculating SED upper limit from %.0dMeV to %.0dMeV' % (lower,upper) if self.always_upper_limit or d['TS']['reoptimize'] < self.min_ts: ul = GtlikePowerLawUpperLimit(like, name, cl=self.ul_confidence, emin=lower,emax=upper, flux_units=self.flux_units, energy_units=self.energy_units, upper_limit_kwargs=self.upper_limit_kwargs, include_prefactor=True, prefactor_energy=e, verbosity=self.verbosity, ) d['upper_limit'] = ul.todict() # revert to old model like.setEnergyRange(*init_energes) saved_state.restore() self._condense_results()
def _calculate(self, *args, **kwargs): """ Convert all units into sympy arrays after the initial calculation. """ like = self.like name = self.name init_energes = like.energies[[0, -1]] # Freeze all sources except one to make sed of. all_sources = like.sourceNames() if name not in all_sources: raise Exception("Cannot find source %s in list of sources" % name) # make copy of parameter values + free parameters saved_state = SuperState(like) if self.verbosity: print 'Freezing background sources' for other_name in get_background(like): if self.freeze_bg_diffuse: if self.verbosity: print ' * Freezing diffuse source %s' % other_name modify(like, other_name, free=False) else: if self.verbosity: print ' * Freezing spectral shape for diffuse source %s' % other_name modify(like, other_name, freeze_spectral_shape=True) for other_name in get_sources(like): if self.freeze_bg_sources: if self.verbosity: print ' * Freezing bg source %s' % other_name modify(like, other_name, free=False) else: if self.verbosity: print ' * Freezing spectral shape for bg source %s' % other_name modify(like, other_name, freeze_spectral_shape=True) self.raw_results = [] for i, (lower, upper) in enumerate(zip(self.lower, self.upper)): like.setEnergyRange(float(lower) + 1, float(upper) - 1) e = np.sqrt(lower * upper) if self.verbosity: print 'Calculating SED from %.0dMeV to %.0dMeV' % (lower, upper) """ Note, the most robust method I have found for computing SEDs in gtlike is: (a) Create a generic spectral model with a fixed spectral index. (b) Set the 'Scale' to sqrt(emin*emax) so the prefactor is dNdE in the middle of the sed bin. (b) Set the limits to go from norm/fit_range to norm*fit_range and set the scale to 'norm' """ old_flux = self.init_model.i_flux(emin=lower, emax=upper) model = PowerLaw(index=self.powerlaw_index, e0=e) model.set_flux(old_flux, emin=lower, emax=upper) norm = model['norm'] model.set_limits('norm', norm / float(self.fit_range), norm * self.fit_range, scale=norm) model.set_limits('index', -5, 5) model.freeze('index') spectrum = build_gtlike_spectrum(model) like.setSpectrum(name, spectrum) like.syncSrcParams(name) if self.verbosity: print 'Before fitting SED from %.0dMeV to %.0dMeV' % (lower, upper) print summary(like) paranoid_gtlike_fit(like, verbosity=self.verbosity) if self.verbosity: print 'After fitting SED from %.0dMeV to %.0dMeV' % (lower, upper) print summary(like) d = dict() self.raw_results.append(d) d['energy'] = energy_dict(emin=lower, emax=upper, energy_units=self.energy_units) d['flux'] = flux_dict(like, name, emin=lower, emax=upper, flux_units=self.flux_units, errors=True, include_prefactor=True, prefactor_energy=e) d['prefactor'] = powerlaw_prefactor_dict( like, name, errors=self.save_hesse_errors, minos_errors=True, flux_units=self.flux_units) d['TS'] = ts_dict(like, name, verbosity=self.verbosity) if self.verbosity: print 'Calculating SED upper limit from %.0dMeV to %.0dMeV' % ( lower, upper) if self.always_upper_limit or d['TS']['reoptimize'] < self.min_ts: ul = GtlikePowerLawUpperLimit( like, name, cl=self.ul_confidence, emin=lower, emax=upper, flux_units=self.flux_units, energy_units=self.energy_units, upper_limit_kwargs=self.upper_limit_kwargs, include_prefactor=True, prefactor_energy=e, verbosity=self.verbosity, ) d['upper_limit'] = ul.todict() # revert to old model like.setEnergyRange(*init_energes) saved_state.restore() self._condense_results()