def ComputeUL(self, Fit): """Compute an Upper Limit using either the profil or integral method See the ST cicerone for more information on the 2 method""" self._log('UpperLimit', 'Compute upper Limit') #Index given by the user self.info("Assumed index is ", self.config['UpperLimit']['SpectralIndex']) IdGamma = utils.getParamIndx(Fit, self.obs.srcname, 'Index') Fit[IdGamma] = -self.config['UpperLimit']['SpectralIndex']#set the index Fit[IdGamma].setFree(0)#the variable index is frozen to compute the UL import scipy.stats cl = float(self.config['UpperLimit']['cl']) delta = 0.5*scipy.stats.chi2.isf(1-2*(cl-0.5), 1) print cl,' ',delta if self.config['UpperLimit']['Method'] == "Profile": #The method is Profile import UpperLimits ulobject = UpperLimits.UpperLimits(Fit) ul, _ = ulobject[self.obs.srcname].compute(emin=self.obs.Emin, emax=self.obs.Emax,delta=delta) #delta=2.71 / 2) self.info("Upper limit using Profile method: ") print ulobject[self.obs.srcname].results if self.config['UpperLimit']['Method'] == "Integral": #The method is Integral import IntegralUpperLimit ul, _ = IntegralUpperLimit.calc_int(Fit, self.obs.srcname, cl=cl, verbosity=0) print "Upper limit using Integral method: ", ul return ul #Return the result. This is an ul on the integral flux in ph/cm2/s
def runBayesianUL(analysis, Name, minEnergy, maxEnergy): print "\nThe TS is below the threshold, calculating 95% confidence-level Bayesian upper limit." limit, results = IUL.calc_int(analysis, Name, cl=0.95, emin=minEnergy, emax=maxEnergy) print "Bayesian upper limit: " + str(limit) + " photons/cm^2/s" if minEnergy != 100 and maxEnergy != 1e5: print "Calculating greater than 100 MeV upper limit flux" limit, results = IUL.calc_int(analysis, Name, cl=0.95, emin=100, emax=1e5) print "0.1 - 100 GeV Bayesian upper limit: " + str( limit) + " photons/cm^2/s"
def EnvelopeUL(self, Fit): """Compute the envelope UL. An UL is computed for different index and the maximum is taken at each energy. This is usefull when the source index is not know or can not be constrain by theoritical argument The index range form 1.5 to 2.5""" import IntegralUpperLimit import UpperLimits self._log('EnvelopeUL', 'Compute upper limit envelope') PhIndex = Fit.par_index(self.obs.srcname, 'Index') Nbp = 20 #Make Nbp computations Npgraph = 100 #The graph has Npgraph points ener = np.logspace(np.log10(self.obs.Emin), np.log10(self.obs.Emax), Npgraph) #the array containing the energy Ulenv = np.array(Npgraph * [0.]) #the array containing the UL value for i in xrange(Nbp): indx = -1.5 - i / (Nbp - 1.) utils.FreezeParams(Fit, self.srcname, PhIndex, indx) #Use either the profile or the integral method self.info("Methode used: " + self.config['UpperLimit']['Method']) if self.config['UpperLimit']['Method'] == "Profile": ul = UpperLimits.UpperLimits(Fit) source_ul = ul[self.obs.srcname] ul_val, _ = source_ul.compute(emin=self.obs.Emin, emax=self.obs.Emax, delta=2.71 / 2) if self.config['UpperLimit']['Method'] == "Integral": ul_val, _ = IntegralUpperLimit.calc_int(Fit, self.obs.srcname, verbosity=0) self.success("Upper Limits calculated") print "Index = ", indx, " UL = ", ul_val #small print for j in xrange(Npgraph): model_name = Fit.model.srcs[ self.obs.srcname].spectrum().genericName() #compute the DNDE value. The computation change is #the model is PowerLaw or PowerLaw2 #Note : Other model are not taken into account #and no UL will be computed if model_name == 'PowerLaw2': newUl = ul_val * (indx + 1) * pow(ener[j], indx + 2) \ / (pow(self.obs.Emax, indx + 1) - pow(self.obs.Emin, indx + 1)) elif model_name == 'PowerLaw': IdEScale = utils.getParamIndx(Fit, self.obs.srcname, 'Scale') Escale = Fit[IdEScale].value() newUl = ul_val * pow(ener[j] / Escale, indx + 2) * Escale**2 * 1.6022e-6 Ulenv[j] = max(Ulenv[j], newUl) print self.info("Result of the UL envelope") for j in xrange(Npgraph): print ener[j], " ", Ulenv[j]
def ComputeUL(self, Fit): """Compute an Upper Limit using either the profil or integral method See the ST cicerone for more information on the 2 method""" self._log('UpperLimit', 'Compute upper Limit') #Index given by the user self.info("Assumed index is "+str(self.config['UpperLimit']['SpectralIndex'])) parameters = dict() parameters['Index'] = -float(self.config['UpperLimit']['SpectralIndex']) parameters['alpha'] = +float(self.config['UpperLimit']['SpectralIndex']) parameters['Index1'] = -float(self.config['UpperLimit']['SpectralIndex']) parameters['beta'] = 0 parameters['Index2'] = 2. parameters['Cutoff'] = 30000. # set the cutoff to be high for key in parameters.keys(): try: utils.FreezeParams(Fit,self.obs.srcname, key, parameters[key]) except: continue import scipy.stats cl = float(self.config['UpperLimit']['cl']) delta = 0.5*scipy.stats.chi2.isf(1-2*(cl-0.5), 1) if self.config['UpperLimit']['Method'] == "Profile": #The method is Profile if Fit.Ts(self.obs.srcname)<2 : self.warning("TS of the source is very low, better to use Integral method") import UpperLimits ulobject = UpperLimits.UpperLimits(Fit) ul, _ = ulobject[self.obs.srcname].compute(emin=self.obs.Emin, emax=self.obs.Emax,delta=delta) #delta=2.71 / 2) self.info("Upper limit using Profile method: ") print ulobject[self.obs.srcname].results self.warning("Be sure to have enough photons to validate the gaussian assumption") if self.config['UpperLimit']['Method'] == "Integral": #The method is Integral import IntegralUpperLimit ul, _ = IntegralUpperLimit.calc_int(Fit, self.obs.srcname, cl=cl, verbosity=0,emin=self.obs.Emin, emax=self.obs.Emax) print "Upper limit using Integral method: ", ul self.warning("Be sure to have enough photons to validate the gaussian assumption") if self.config['UpperLimit']['Method'] == "Poisson": #The method is Poisson ul = self.PoissonUL(Fit) print "Upper limit using Poisson statistic: ", ul print "This is an ul on the integral flux in ph/cm2/s" return ul #Return the result. This is an ul on the integral flux in ph/cm2/s
def EnvelopeUL(self, Fit): """Compute the envelope UL. An UL is computed for different index and the maximum is taken at each energy. This is usefull when the source index is not know or can not be constrain by theoritical argument The index range form 1.5 to 2.5""" import IntegralUpperLimit import UpperLimits self._log('EnvelopeUL', 'Compute upper limit envelope') PhIndex = Fit.par_index(self.obs.srcname, 'Index') Nbp = 20 #Make Nbp computations Npgraph = 100#The graph has Npgraph points ener = np.logspace(np.log10(self.obs.Emin), np.log10(self.obs.Emax), Npgraph)#the array containing the energy Ulenv = np.array(Npgraph * [0.])#the array containing the UL value for i in xrange(Nbp): indx = -1.5 - i / (Nbp - 1.) Fit[PhIndex] = indx Fit.freeze(PhIndex)#Freeze the index #Use either the profile or the integral method self.info("Methode used: "+self.config['UpperLimit']['Method']) if self.config['UpperLimit']['Method'] == "Profile": ul = UpperLimits.UpperLimits(Fit) source_ul = ul[self.obs.srcname] ul_val, _ = source_ul.compute(emin=self.obs.Emin, emax=self.obs.Emax, delta=2.71 / 2) if self.config['UpperLimit']['Method'] == "Integral": ul_val, _ = IntegralUpperLimit.calc_int(Fit, self.obs.srcname, verbosity=0) self.success("Upper Limits calculated") print "Index = ", indx, " UL = ", ul_val #small print for j in xrange(Npgraph): model_name = Fit.model.srcs[self.obs.srcname].spectrum().genericName() #compute the DNDE value. The computation change is #the model is PowerLaw or PowerLaw2 #Note : Other model are not taken into account #and no UL will be computed if model_name == 'PowerLaw2': newUl = ul_val * (indx + 1) * pow(ener[j], indx + 2) \ / (pow(self.obs.Emax, indx + 1) - pow(self.obs.Emin, indx + 1)) elif model_name == 'PowerLaw': IdEScale = utils.getParamIndx(Fit, self.obs.srcname, 'Scale') Escale = Fit[IdEScale].value() newUl = ul_val * pow(ener[j] / Escale, indx + 2)*Escale**2*1.6022e-6 Ulenv[j] = max(Ulenv[j], newUl) print self.info("Result of the UL envelope") for j in xrange(Npgraph): print ener[j], " ", Ulenv[j]
def ComputeUL(self, Fit): """Compute an Upper Limit using either the profil or integral method See the ST cicerone for more information on the 2 method""" self._log('UpperLimit', 'Compute upper Limit') #Index given by the user self.info("Assumed index is "+str(self.config['UpperLimit']['SpectralIndex'])) IdGamma = utils.getParamIndx(Fit, self.obs.srcname, 'Index') Fit[IdGamma] = -self.config['UpperLimit']['SpectralIndex']#set the index Fit[IdGamma].setFree(0)#the variable index is frozen to compute the UL import scipy.stats cl = float(self.config['UpperLimit']['cl']) delta = 0.5*scipy.stats.chi2.isf(1-2*(cl-0.5), 1) if self.config['UpperLimit']['Method'] == "Profile": #The method is Profile if Fit.Ts(self.obs.srcname)<2 : self.warning("TS of the source is very low, better to use Integral method") import UpperLimits ulobject = UpperLimits.UpperLimits(Fit) ul, _ = ulobject[self.obs.srcname].compute(emin=self.obs.Emin, emax=self.obs.Emax,delta=delta) #delta=2.71 / 2) self.info("Upper limit using Profile method: ") print ulobject[self.obs.srcname].results self.warning("Be sure to have enough photons to validate the gaussian assumption") if self.config['UpperLimit']['Method'] == "Integral": #The method is Integral import IntegralUpperLimit ul, _ = IntegralUpperLimit.calc_int(Fit, self.obs.srcname, cl=cl, verbosity=0,emin=self.obs.Emin, emax=self.obs.Emax) print "Upper limit using Integral method: ", ul self.warning("Be sure to have enough photons to validate the gaussian assumption") if self.config['UpperLimit']['Method'] == "Poisson": #The method is Poisson ul = self.PoissonUL(Fit) print "Upper limit using Poisson statistic: ", ul print "This is an ul on the integral flux in ph/cm2/s" return ul #Return the result. This is an ul on the integral flux in ph/cm2/s
def run(Name, Ra, Dec, minEnergy, maxEnergy, SCFile, ulTS, NMtol,evclass,model): if evclass == 512: irf = "P8R2_ULTRACLEAN_V6" elif evclass == 128: irf = "P8R2_SOURCE_V6" elif evclass == 256: irf = "P8R2_CLEAN_V6" elif evclass == 1024: irf = "P8R2_ULTRACLEANVETO_V6" print "This is multiUBLike.\nPlease make sure that you have added a model for your source with the name: " + str(Name) print "Calcualting the diffuse response for photons in this bin." my_apps.diffResps['evfile'] = '../' + Name + '_gtmktime.fits' my_apps.diffResps['scfile'] = SCFile my_apps.diffResps['srcmdl'] = model my_apps.diffResps['irfs'] = irf my_apps.diffResps.run() print "Finished calculating diffuse response. Now moving to conduct a UNBINNED likelihood analysis." obs = UnbinnedObs('../' + Name + '_gtmktime.fits', SCFile,expMap= '../' + Name + '_expMap.fits',expCube= '../' + Name + '_ltcube.fits', irfs=irf) analysis = UnbinnedAnalysis(obs,model,optimizer='NewMinuit') likeObj = pyLike.NewMinuit(analysis.logLike) analysis.tol = NMtol lkl = analysis.fit(verbosity=0,covar=True,optObject=likeObj) analysis.writeXml( Name + '_output_model.xml') fit = likeObj.getRetCode() print "Likelihood has converged whith Code " + str(likeObj.getRetCode()) multiLike.printResults(analysis,Name, minEnergy,maxEnergy) print "Fit has likelihood: " + str(lkl) print "\nThe TS is below the threshold, calculating 95% confidence-level Bayesian upper limit." limit,results = IUL.calc_int(analysis,Name,cl=0.95,emin=minEnergy, emax=maxEnergy) print "Bayesian upper limit: " + str(limit) + " photons/cm^2/s" #Array that returns the results of the unbinned analysis #log-likelihood,flux,flux_err,test statisitc Return = [lkl,analysis.flux(Name, emin=minEn, emax=maxEn),analysis.fluxError(Name, emin=minEn, emax=maxEn),limit,analysis.Ts(Name,reoptimize=False)] return Return
def ComputeUL(self, Fit): """Compute an Upper Limit using either the profil or integral method See the ST cicerone for more information on the 2 method""" self._log('UpperLimit', 'Compute upper Limit') #Index given by the user print "Assumed index is ", self.config['UpperLimit']['SpectralIndex'] IdGamma = utils.getParamIndx(Fit, self.obs.srcname, 'Index') Fit[IdGamma] = -self.config['UpperLimit'][ 'SpectralIndex'] #set the index Fit[IdGamma].setFree( 0) #the variable index is frozen to compute the UL import scipy.stats cl = float(self.config['UpperLimit']['cl']) delta = 0.5 * scipy.stats.chi2.isf(1 - 2 * (cl - 0.5), 1) print cl, ' ', delta if self.config['UpperLimit'][ 'Method'] == "Profile": #The method is Profile import UpperLimits ulobject = UpperLimits.UpperLimits(Fit) ul, _ = ulobject[self.obs.srcname].compute(emin=self.obs.Emin, emax=self.obs.Emax, delta=delta) #delta=2.71 / 2) print "Upper limit using Profile method: " print ulobject[self.obs.srcname].results if self.config['UpperLimit'][ 'Method'] == "Integral": #The method is Integral import IntegralUpperLimit ul, _ = IntegralUpperLimit.calc_int(Fit, self.obs.srcname, cl=cl, verbosity=0) print "Upper limit using Integral method: ", ul return ul #Return the result. This is an ul on the integral flux in ph/cm2/s
def processAllObs(self, fix_shape=True, delete_below_ts=None, ul_flux_dflux=0, ul_chi2_ts=None, ul_bayes_ts=4.0, ul_cl=0.95, verbosity=0, emin=0, emax=0, interim_save_filename=None): self.logger.info("Processing all observations.") for f in self.obsfiles: lc = dict() lc['config'] = dict() lc['config']['fix_shape'] = fix_shape lc['config']['delete_below_ts'] = delete_below_ts lc['config']['ul_flux_dflux'] = ul_flux_dflux lc['config']['ul_chi2_ts'] = ul_chi2_ts lc['config']['ul_bayes_ts'] = ul_bayes_ts lc['config']['ul_cl'] = ul_cl lc['config']['emin'] = emin lc['config']['emax'] = emax lc['config']['files'] = f #lc['config']['argv'] = sys.argv lc['e_min'] = emin; lc['e_max'] = emax; if type(f) != list: [ obs, like ] = self.loadObs(f,verbosity) lc['t_min'] = obs.roiCuts().minTime() lc['t_max'] = obs.roiCuts().maxTime() if (emin == 0 or emax == 0): lc['e_min'] = obs.roiCuts().getEnergyCuts()[0]; lc['e_max'] = obs.roiCuts().getEnergyCuts()[1]; else: lc['t_min'] = None lc['t_max'] = None like = SL.SummedLikelihood(self.optimizer) for ff in f: [ obs, like1 ] = self.loadObs(ff,verbosity) tmin = obs.roiCuts().minTime() tmax = obs.roiCuts().maxTime() if lc['t_min'] == None or tmin<lc['t_min']: lc['t_min'] = tmin if lc['t_max'] == None or tmax>lc['t_max']: lc['t_max'] = tmax if (lc['e_min'] == 0 or lc['e_max'] == 0): ecuts = obs.roiCuts().getEnergyCuts() lc['e_min'] = ecuts[0] lc['e_max'] = ecuts[1] elif (emin == 0 or emax == 0): ecuts = obs.roiCuts().getEnergyCuts() lc['e_min'] = max(lc['e_min'], ecuts[0]) lc['e_max'] = min(lc['e_max'], ecuts[1]) like.addComponent(like1) emin = lc['e_min'] emax = lc['e_max'] like.tol = like.tol*0.01; if verbosity > 1: print '- Time:',lc['t_min'],'to',lc['t_max'] src = like[self.likelihoodConf['sourcename']] if src == None: raise NameError("No source \""+self.likelihoodConf['sourcename']+"\" in model "+ self.model) srcfreepar=like.freePars(self.likelihoodConf['sourcename']) srcnormpar=like.normPar(self.likelihoodConf['sourcename']) if len(srcfreepar)>0: like.setFreeFlag(self.likelihoodConf['sourcename'], srcfreepar, 0) like.syncSrcParams(self.likelihoodConf['sourcename']) meanvalue = srcnormpar.getValue() meanerror = srcnormpar.error() if meanerror == 0: self.logger.critical("The error on the normalization for your source is 0! You need to do a global fit first (with quickLike) and provide the final XML file (<basename>_likeMinuit.xml) with errors included before you run compute.") return lc['original']=dict() lc['original']['normpar_init_value'] = meanvalue lc['original']['normpar_name'] = srcnormpar.getName() lc['original']['nfree'] = len(like.freePars(self.likelihoodConf['sourcename'])) lc['original']['flux'] = like[self.likelihoodConf['sourcename']].flux(emin, emax) lc['original']['logL'] = like.logLike.value() if verbosity > 1: print '- Original log Like:',lc['original']['logL'] if fix_shape: if verbosity > 1: print '- Fixing spectral shape parameters' sync_name = "" for p in like.params(): if sync_name != "" and sync_name != p.srcName: like.syncSrcParams(sync_name) sync_name = "" if(p.isFree() and p.srcName!=self.likelihoodConf['sourcename'] and p.getName()!=like.normPar(p.srcName).getName()): if verbosity > 2: print '-- '+p.srcName+'.'+p.getName() p.setFree(False) sync_name = p.srcName if sync_name != "" and sync_name != p.srcName: like.syncSrcParams(sync_name) sync_name = "" # ----------------------------- FIT 1 ----------------------------- if verbosity > 1: print '- Fit 1 - All parameters of',self.likelihoodConf['sourcename'],'fixed' like.fit(max(verbosity-3, 0)) lc['allfixed'] = dict() lc['allfixed']['logL'] = like.logLike.value() fitstat = like.optObject.getRetCode() if verbosity > 1 and fitstat != 0: print "- Fit 1 - Minimizer returned with code: ", fitstat lc['allfixed']['fitstat'] = fitstat if verbosity > 1: print '- Fit 1 - log Like:',lc['allfixed']['logL'] if delete_below_ts: frozensrc = [] if verbosity > 1: print '- Deleting point sources with TS<'+str(delete_below_ts) deletesrc = [] for s in like.sourceNames(): freepars = like.freePars(s) if(s!=self.likelihoodConf['sourcename'] and like[s].src.getType() == 'Point' and len(freepars)>0): ts = like.Ts(s) if ts<delete_below_ts: deletesrc.append(s) if verbosity > 2: print '--',s,'(TS='+str(ts)+')' if deletesrc: for s in deletesrc: like.deleteSource(s) if verbosity > 1: print '- Fit 1 - refitting model' like.fit(max(verbosity-3, 0)) lc['allfixed']['fitstat_initial'] = \ lc['allfixed']['fitstat'] fitstat = like.optObject.getRetCode() if verbosity > 1 and fitstat != 0: print "- Fit 1 - Minimizer returned with code: ",\ fitstat lc['allfixed']['fitstat'] = fitstat lc['allfixed']['logL'] = like.logLike.value() if verbosity > 1: print '- Fit 1 - log Like:',lc['allfixed']['logL'] lc['allfixed']['flux']=like[self.likelihoodConf['sourcename']].flux(emin, emax) pars = dict() for pn in like[self.likelihoodConf['sourcename']].funcs['Spectrum'].paramNames: p = like[self.likelihoodConf['sourcename']].funcs['Spectrum'].getParam(pn) pars[p.getName()] = dict(name = p.getName(), value = p.getTrueValue(), error = p.error()*p.getScale(), free = p.isFree()) lc['allfixed']['pars'] = pars # ------------------ N SIGMA PROFILE LIKELIHOOD ------------------- prof_sigma = (-1,-0.5,0,0.5,1.0) lc['profile'] = dict(); lc['profile']['sigma'] = [] lc['profile']['value'] = [] lc['profile']['logL'] = [] lc['profile']['flux'] = [] lc['profile']['fitstat'] = [] if verbosity > 1: print '- Fit 1 - generating %d point likelihood profile'%\ len(prof_sigma) for sigma in prof_sigma: val = sigma*meanerror+meanvalue if val < srcnormpar.getBounds()[0]: val = srcnormpar.getBounds()[0] if (lc['profile']['value'] and lc['profile']['value'][-1]==val): continue lc['profile']['value'].append(val) lc['profile']['sigma'].append((val-meanvalue)/meanerror) if(val == meanvalue): lc['profile']['logL'].append(lc['allfixed']['logL']) lc['profile']['flux'].append(lc['allfixed']['flux']) else: srcnormpar.setValue(val) like.syncSrcParams(self.likelihoodConf['sourcename']) like.fit(max(verbosity-3, 0)) fitstat = like.optObject.getRetCode() if verbosity > 2 and fitstat != 0: print "- Fit 1 - profile: Minimizer returned code: ",\ fitstat lc['profile']['fitstat'].append(fitstat) lc['profile']['logL'].append(like.logLike.value()) lc['profile']['flux'].append(like[self.likelihoodConf['sourcename']].\ flux(emin, emax)) if verbosity > 2: print '- Fit 1 - profile: %+g, %f -> %f'%\ (sigma,lc['profile']['value'][-1], lc['profile']['logL'][-1]-lc['allfixed']['logL']) srcnormpar.setValue(meanvalue) like.syncSrcParams(self.likelihoodConf['sourcename']) # ----------------------------- FIT 2 ----------------------------- if verbosity > 1: print '- Fit 2 - Normalization parameter of',\ self.likelihoodConf['sourcename'],'free' srcnormpar.setFree(1) like.syncSrcParams(self.likelihoodConf['sourcename']) like.fit(max(verbosity-3, 0)) lc['normfree'] = dict() fitstat = like.optObject.getRetCode() if verbosity > 1 and fitstat != 0: print "- Fit 2 - Minimizer returned with code: ", fitstat lc['normfree']['fitstat'] = fitstat lc['normfree']['logL'] = like.logLike.value() lc['normfree']['ts'] = like.Ts(self.likelihoodConf['sourcename']) lc['normfree']['flux_dflux'] = \ srcnormpar.getValue()/srcnormpar.error() if verbosity > 1: print '- Fit 2 - log Like:',lc['normfree']['logL'],\ '(TS='+str(lc['normfree']['ts'])+')' lc['normfree']['nfree']=len(like.freePars(self.likelihoodConf['sourcename'])) lc['normfree']['flux']=like[self.likelihoodConf['sourcename']].flux(emin, emax) pars = dict() for pn in like[self.likelihoodConf['sourcename']].funcs['Spectrum'].paramNames: p = like[self.likelihoodConf['sourcename']].funcs['Spectrum'].getParam(pn) pars[p.getName()] = dict(name = p.getName(), value = p.getTrueValue(), error = p.error()*p.getScale(), free = p.isFree()) lc['normfree']['pars'] = pars ul_type = None if ul_bayes_ts != None and lc['normfree']['ts'] < ul_bayes_ts: ul_type = 'bayesian' [ul_flux, ul_results] = \ IUL.calc_int(like,self.likelihoodConf['sourcename'],cl=ul_cl, skip_global_opt=True, verbosity = max(verbosity-2,0), emin=emin, emax=emax, poi_values = lc['profile']['value']) elif ( ul_flux_dflux != None and \ lc['normfree']['flux_dflux'] < ul_flux_dflux ) or \ ( ul_chi2_ts != None and lc['normfree']['ts'] < ul_chi2_ts): ul_type = 'chi2' [ul_flux, ul_results] = \ IUL.calc_chi2(like,self.likelihoodConf['sourcename'],cl=ul_cl, skip_global_opt=True, verbosity = max(verbosity-2,0), emin=emin, emax=emax) if ul_type != None: lc['normfree']['ul'] = dict(flux = ul_flux, results = ul_results, type = ul_type) # ----------------------------- FIT 3 ----------------------------- if verbosity > 1: print '- Fit 3 - All parameters of',self.likelihoodConf['sourcename'],'free' like.setFreeFlag(self.likelihoodConf['sourcename'], srcfreepar, 1) like.syncSrcParams(self.likelihoodConf['sourcename']) like.fit(max(verbosity-3, 0)) lc['allfree'] = dict() fitstat = like.optObject.getRetCode() if verbosity > 1 and fitstat != 0: print "- Fit 3 - Minimizer returned with code: ", fitstat lc['allfree']['fitstat'] = fitstat lc['allfree']['logL'] = like.logLike.value() lc['allfree']['ts'] = like.Ts(self.likelihoodConf['sourcename']) if verbosity > 1: print '- Fit 3 - log Like:',lc['allfree']['logL'],\ '(TS='+str(lc['allfree']['ts'])+')' lc['allfree']['nfree']=len(like.freePars(self.likelihoodConf['sourcename'])) lc['allfree']['flux']=like[self.likelihoodConf['sourcename']].flux(emin, emax) pars = dict() for pn in like[self.likelihoodConf['sourcename']].funcs['Spectrum'].paramNames: p = like[self.likelihoodConf['sourcename']].funcs['Spectrum'].getParam(pn) pars[p.getName()] = dict(name = p.getName(), value = p.getTrueValue(), error = p.error()*p.getScale(), free = p.isFree()) lc['allfree']['pars'] = pars self.lc.append(lc) if interim_save_filename != None: self.saveProcessedObs(interim_save_filename)
def processAllObs(self, fix_shape=True, delete_below_ts=None, ul_flux_dflux=0,ul_chi2_ts=None, ul_bayes_ts=4.0, ul_cl = 0.95, verbosity=0, ul_optimizer=None): for f in self.obsfiles: spect = dict() spect['config']=dict() spect['config']['fix_shape'] = fix_shape spect['config']['delete_below_ts'] = delete_below_ts spect['config']['ul_flux_dflux'] = ul_flux_dflux spect['config']['ul_chi2_ts'] = ul_chi2_ts spect['config']['ul_bayes_ts'] = ul_bayes_ts spect['config']['ul_cl'] = ul_cl spect['config']['files'] = f [ obs, like ] = self.loadObs(f,verbosity) spect['t_min'] = obs.roiCuts().minTime() spect['t_max'] = obs.roiCuts().maxTime() [emin, emax] = obs.roiCuts().getEnergyCuts() spect['e_min'] = emin spect['e_max'] = emax if verbosity > 1: print '- Time:',spect['t_min'],'to',spect['t_max'] print '- Energy:',emin,'to',emax,'MeV' src = like[self.srcName] if src == None: raise NameError("No source \""+self.srcName+"\" in model "+ self.model) srcnormpar=like.normPar(self.srcName) spect['original']=dict() spect['original']['normpar_init_value'] = srcnormpar.getValue() spect['original']['normpar_name'] = srcnormpar.getName() spect['original']['flux'] = like[self.srcName].flux(emin, emax) spect['original']['logL'] = like.logLike.value() if verbosity > 1: print '- Original log Like:',spect['original']['logL'] if fix_shape: if verbosity > 1: print '- Fixing spectral shape parameters' sync_name = "" for p in like.params(): if sync_name != "" and sync_name != p.srcName: like.syncSrcParams(sync_name) sync_name = "" if(p.isFree() and #p.srcName!=self.srcName and p.getName()!=like.normPar(p.srcName).getName()): if verbosity > 2: print '-- '+p.srcName+'.'+p.getName() p.setFree(False) sync_name = p.srcName if sync_name != "" and sync_name != p.srcName: like.syncSrcParams(sync_name) sync_name = "" # ------------------------------ FIT ------------------------------ if verbosity > 1: print '- Fit - starting' like.fit(max(verbosity-3, 0)) spect['fit'] = dict() spect['fit']['logL'] = like.logLike.value() if verbosity > 1: print '- Fit - log Like:',spect['fit']['logL'] if delete_below_ts: frozensrc = [] if verbosity > 1: print '- Deleting point sources with TS<'+str(delete_below_ts) deletesrc = [] for s in like.sourceNames(): freepars = like.freePars(s) if(s!=self.srcName and like[s].type == 'PointSource' and len(freepars)>0): ts = like.Ts(s) if ts<delete_below_ts: deletesrc.append(s) if verbosity > 2: print '--',s,'(TS='+str(ts)+')' if deletesrc: for s in deletesrc: like.deleteSource(s) if verbosity > 1: print '- Fit - refitting model' like.fit(max(verbosity-3, 0)) spect['fit']['logL'] = like.logLike.value() if verbosity > 1: print '- Fit - log Like:',spect['fit']['logL'] spect['fit']['ts']=like.Ts(self.srcName) if verbosity > 1: print '- TS of %s: %f'%(self.srcName,spect['fit']['ts']) spect['fit']['flux']=like[self.srcName].flux(emin, emax) emid = math.sqrt(emin*emax) spect['fit']['e_mid']=emid # Note: be careful about the meaning here - it is the # differential flux in the middle of the energy bin, not a # flux error. This contradicts the meaning in 'flux_dflux' spect['fit']['dflux'] = \ like[self.srcName].flux(emid*(1-0.001),emid*(1+0.001))/(emid*0.002) spect['fit']['flux_dflux'] = \ srcnormpar.getValue()/srcnormpar.error() pars = dict() for pn in like[self.srcName].funcs['Spectrum'].paramNames: p = like[self.srcName].funcs['Spectrum'].getParam(pn) pars[p.getName()] = dict(name = p.getName(), value = p.getTrueValue(), error = p.error()*p.getScale(), free = p.isFree()) spect['fit']['pars'] = pars ul_type = None if ul_bayes_ts != None and spect['fit']['ts'] < ul_bayes_ts: ul_type = 'bayesian' [ul_flux, ul_results] = \ IntegralUpperLimit.calc_int(like,self.srcName,cl=ul_cl, skip_global_opt=True, verbosity = max(verbosity-2,0), emin=emin, emax=emax, profile_optimizer=ul_optimizer) elif ( ul_flux_dflux != None and \ spect['fit']['flux_dflux'] < ul_flux_dflux ) or \ ( ul_chi2_ts != None and spect['fit']['ts'] < ul_chi2_ts): ul_type = 'chi2' [ul_flux, ul_results] = \ IntegralUpperLimit.calc_chi2(like,self.srcName,cl=ul_cl, skip_global_opt=True, verbosity = max(verbosity-2,0), emin=emin, emax=emax, profile_optimizer=ul_optimizer) if ul_type != None: spect['fit']['ul'] = dict(flux = ul_flux, results = ul_results, type = ul_type) self.spectra.append(spect)
def runFermiTools(Name, RA, DEC, minEnergy, maxEnergy, SCFile, radius, binsz, TSTART, TSTOP, Evfile, bins, zmax, evclass, evtype, TSul, NMtol, lc_bin_num, runMRM): print "Working on bin " + str(lc_bin_num) + " for the light curve." f = FermiObject() """ Following steps execute Fermi Tool gtselect """ print('\nWorking on file.') print('Cutting file to fit desired parameters . . .\n') f._setEvclass(evclass) f._setEvtype(evtype) f._setRa(RA) f._setDec(DEC) f._setRad(radius) f._setEmin(minEnergy) f._setEmax(maxEnergy) f._setZmax(zmax) f._setTmin(TSTART) f._setTmax(TSTOP) f._setInfile(Evfile) f._setOutfile(Name + '_gtselect' + str(lc_bin_num) + '_lc.fits') f.amonSelect() print( 'File cuts have been made. Now making cuts for GTI using spacecraft file.' ) """ Following steps execute Fermi Tool gtmktime """ f._setScfile(SCFile) f._setRoicut('no') f._setEvfile(Name + '_gtselect' + str(lc_bin_num) + '_lc.fits') f._setOutfile(Name + '_gtmktime' + str(lc_bin_num) + '_lc.fits') ############################################### # Filter expression # Filter = '(DATA_QUAL>0)&&(LAT_CONFIG==1)' ############################################### f._setFilter(Filter) print('Working on file ' + str(f.getOutfile()) + '. . .') f.amonTime() print( 'File cuts have been made. Now begining construction of the counts map from event data.' ) """ Following steps execute Fermi Tool gtbin to create the counts map """ f._setAlgorithm('CMAP') f._setEvfile(Name + '_gtmktime' + str(lc_bin_num) + '_lc.fits') f._setOutfile(Name + '_cmap' + str(lc_bin_num) + '_lc.fits') f._setScfile('NONE') num_pix = int((2 * radius) / float(binsz)) print "Counts map is " + str(num_pix) + " by " + str(num_pix) + " pixels." f._setNxpix(num_pix) f._setNypix(num_pix) f._setBinsz(binsz) f._setCoordsys('CEL') f._setAxisrot(0) f._setProj('AIT') f.amonBincmap() print( 'Counts map is complete.Now begining construction of the counts cube.') """ Following steps execute Fermi Tool gtbin to create counts cube (3D counts map). """ f._setAlgorithm('CCUBE') f._setOutfile(Name + '_ccube' + str(lc_bin_num) + '_lc.fits') pix = int((sqrt(2) * radius) / float(binsz)) print "Counts cube is " + str(pix) + " by " + str(pix) + " pixels." f._setNxpix(pix) f._setNypix(pix) ebin = int(10 * log10(maxEnergy / minEnergy)) print "There are " + str(ebin) + " logarithmically uniform energy bins." f._setEnumbins(ebin) f.amonBinccube() print('Counts cube is complete.') print('Using XML model from whole dataset.\n Moving on to gtltcube.') print "Now working on ltcube file using gtltcube\n" my_apps.expCube['evfile'] = Name + '_gtmktime' + str( lc_bin_num) + '_lc.fits' my_apps.expCube['scfile'] = SCFile my_apps.expCube['outfile'] = Name + '_ltcube' + str( lc_bin_num) + '_lc.fits' my_apps.expCube['dcostheta'] = 0.025 my_apps.expCube['binsz'] = 1 my_apps.expCube['phibins'] = 0 my_apps.expCube['zmax'] = zmax my_apps.expCube['chatter'] = 0 my_apps.expCube.run() print "\nltcube complete.\nMoving to compute exposure map for whole sky with gtexpcube2.\n" f._setInfile(Name + '_ltcube' + str(lc_bin_num) + '_lc.fits') cubePix = int((2 * radius + 20) / binsz) f._setNxpix(cubePix) f._setNypix(cubePix) f._setBinsz(binsz) f._setCoordsys('CEL') f._setRa(RA) f._setDec(DEC) f._setAxisrot(0) f._setProj('AIT') f._setEmin(minEnergy) f._setEmax(maxEnergy) f._setEnumbins(ebin) f._setOutfile(Name + '_expcube' + str(lc_bin_num) + '_lc.fits') f._setIrfs('P8R2_SOURCE_V6') f.amonExpcube2() print "Finnished making exposure map.\n" print "Now begining computation of model counts map with gtsrcmaps.\n" f._setScfile(SCFile) f._setExpcube(Name + '_ltcube' + str(lc_bin_num) + '_lc.fits') f._setCmap(Name + '_ccube' + str(lc_bin_num) + '_lc.fits') f._setBexpmap(Name + '_expcube' + str(lc_bin_num) + '_lc.fits') f._setOutfile(Name + '_srcmaps' + str(lc_bin_num) + '_lc.fits') f._setIrfs('CALDB') f._setSrcmdl(Name + '_output_model.xml') f.amonSrcmaps() print "Finished srcmaps. Now moving to conduct a BINNED likelihood analysis." obs = BinnedObs(binnedExpMap=Name + '_expcube' + str(lc_bin_num) + '_lc.fits', expCube=Name + '_ltcube' + str(lc_bin_num) + '_lc.fits', srcMaps=Name + '_srcmaps' + str(lc_bin_num) + '_lc.fits', irfs='P8R2_SOURCE_V6') analysis = BinnedAnalysis(obs, srcModel=Name + '_output_model.xml', optimizer='NEWMINUIT') likeObj = pyLike.NewMinuit(analysis.logLike) analysis.tol = NMtol analysis.fit(verbosity=0, covar=True, optObject=likeObj) fit = likeObj.getRetCode() print "Likelihood has converged whith Code " + str(likeObj.getRetCode()) Flux = analysis.flux(Name, emin=minEnergy, emax=maxEnergy) Ferr = analysis.fluxError(Name, emin=minEnergy, emax=maxEnergy) MeVtoErg = 1.602e-6 ef = analysis.energyFlux(Name, minEnergy, maxEnergy) * MeVtoErg ef_err = analysis.energyFluxError(Name, minEnergy, maxEnergy) * MeVtoErg UL = False TSUM = TSTART + TSTOP TMID = TSUM / 2 limit = Flux if analysis.Ts(Name) < TSul: UL = True limit, results = IUL.calc_int(analysis, Name, cl=0.90, emin=minEnergy, emax=maxEnergy) #Run gtselect to make smaller data fits file to compute the exposure, set to 3 degrees around source of interest f._setRad(3) f._setInfile(Evfile) f._setOutfile(Name + '_gtselect' + str(lc_bin_num) + '_exposure.fits') print "Creating file " + Name + "_gtselect_exposure.fits" f.amonSelect() #Run gtmaketime on this small region f._setEvfile(Name + '_gtselect' + str(lc_bin_num) + '_exposure.fits') f._setOutfile(Name + '_gtmktime' + str(lc_bin_num) + '_exposure.fits') print('Working on file ' + str(f.getOutfile())) f.amonTime() my_apps.evtbin['algorithm'] = 'LC' my_apps.evtbin['evfile'] = f.getOutfile() my_apps.evtbin['outfile'] = Name + '_LC' + str( lc_bin_num) + '_exposure.fits' my_apps.evtbin['scfile'] = f.getScfile() my_apps.evtbin['tbinalg'] = 'LIN' my_apps.evtbin['tstart'] = f.getTmin() my_apps.evtbin['tstop'] = f.getTmax() my_apps.evtbin['dtime'] = TSTOP - TSTART my_apps.evtbin.run() yes = subprocess.call([ 'gtexposure', Name + '_LC' + str(lc_bin_num) + '_exposure.fits', f.getScfile(), 'P8R2_SOURCE_V6', Name + '_output_model.xml', Name ]) if yes == 0: print "Exposure map has been created" else: print "Subprocessing failed. Unable to create exposure map with gtexposure." print "Time bin complete." hdulist = pyfits.open(Name + '_LC' + str(lc_bin_num) + '_exposure.fits') tbdata = hdulist[1].data z = tbdata['EXPOSURE'] exp = z[0] ################################################################ # This portion prints to the text file # ################################################################ f = open("lc_output.txt", "a") f.write( str(Flux) + ',' + str(Ferr) + ',' + str(ef) + ',' + str(ef_err) + ',' + str(limit) + ',' + str(analysis.Ts(Name)) + ',' + str(UL) + ',' + str(TMID) + ',' + str(exp) + '\n') f.close() print "Likelihood analysis on this band is complete." if runMRM == True: runMakeResMap(Name, RA, DEC, radius, binsz, minEnergy, maxEnergy, lc_bin_num) else: pass yes = subprocess.call([ 'rm', Name + '_gtselect' + str(lc_bin_num) + '_lc.fits', Name + '_gtmktime' + str(lc_bin_num) + '_lc.fits', Name + '_cmap' + str(lc_bin_num) + '_lc.fits', Name + '_ccube' + str(lc_bin_num) + '_lc.fits', Name + '_ltcube' + str(lc_bin_num) + '_lc.fits', Name + '_expcube' + str(lc_bin_num) + '_lc.fits', Name + '_LC' + str(lc_bin_num) + '_exposure.fits', Name + '_srcmaps' + str(lc_bin_num) + '_lc.fits', Name + '_gtselect' + str(lc_bin_num) + '_exposure.fits', Name + '_gtmktime' + str(lc_bin_num) + '_exposure.fits' ]) if yes == 0: print 'Files for bin have been deleted' else: print "Subprocessing failed. Unable to delete files for bin."
def runFermiTools(Name, RA, DEC, minEnergy, maxEnergy, SCFile, radius, binsz, TSTART, TSTOP, Evfile, bins, zmax, evclass, evtype, TSul, NMtol, lc_bin_num, runMRM): print "Working on bin " + str(lc_bin_num) + " for the light curve." f = FermiObject() """ Following steps execute Fermi Tool gtselect """ print('\nWorking on file.') print('Cutting file to fit desired parameters . . .\n') f._setEvclass(evclass) f._setEvtype(evtype) f._setRa(RA) f._setDec(DEC) f._setRad(radius) f._setEmin(minEnergy) f._setEmax(maxEnergy) f._setZmax(zmax) f._setTmin(TSTART) f._setTmax(TSTOP) f._setInfile(Evfile) f._setOutfile(Name + '_gtselect' + str(lc_bin_num) + '_lc.fits') f.amonSelect() print( 'File cuts have been made. Now making cuts for GTI using spacecraft file.' ) """ Following steps execute Fermi Tool gtmktime """ f._setScfile(SCFile) f._setRoicut('no') f._setEvfile(Name + '_gtselect' + str(lc_bin_num) + '_lc.fits') f._setOutfile(Name + '_gtmktime' + str(lc_bin_num) + '_lc.fits') ############################################### # Filter expression # Filter = '(DATA_QUAL>0)&&(LAT_CONFIG==1)' ############################################### f._setFilter(Filter) print('Working on file ' + str(f.getOutfile()) + '. . .') f.amonTime() print('File cuts have been made.') print('Using XML model from whole dataset.\n Moving on to gtltcube.') print "Now working on ltcube file using gtltcube\n" my_apps.expCube['evfile'] = Name + '_gtmktime' + str( lc_bin_num) + '_lc.fits' my_apps.expCube['scfile'] = SCFile my_apps.expCube['outfile'] = Name + '_ltcube' + str( lc_bin_num) + '_lc.fits' my_apps.expCube['dcostheta'] = 0.025 my_apps.expCube['binsz'] = 1 my_apps.expCube['phibins'] = 0 my_apps.expCube['zmax'] = zmax my_apps.expCube['chatter'] = 0 my_apps.expCube.run() print "\nltcube complete.\nMoving to compute exposure map with gtexpmap.\n" my_apps.expMap['evfile'] = Name + '_gtmktime' + str( lc_bin_num) + '_lc.fits' my_apps.expMap['scfile'] = SCFile my_apps.expMap['expcube'] = Name + '_ltcube' + str(lc_bin_num) + '_lc.fits' my_apps.expMap['outfile'] = Name + '_expMap' + str(lc_bin_num) + '_lc.fits' my_apps.expMap['irfs'] = 'CALDB' my_apps.expMap['srcrad'] = radius + 10 my_apps.expMap['nlong'] = 4 * (radius + 10) my_apps.expMap['nlat'] = 4 * (radius + 10) ebin = int(10 * log10(maxEnergy / minEnergy)) print "There are " + str(ebin) + " energy bans." my_apps.expMap['nenergies'] = ebin my_apps.expMap.run() print "Finnished making exposure map.\n" print "Calcualting the diffuse response for photons in this bin." my_apps.diffResps['evfile'] = Name + '_gtmktime' + str( lc_bin_num) + '_lc.fits' my_apps.diffResps['scfile'] = SCFile my_apps.diffResps['srcmdl'] = Name + '_output_model.xml' my_apps.diffResps['irfs'] = 'CALDB' my_apps.diffResps.run() print "Finished calculating diffuse response. Now moving to conduct a UNBINNED likelihood analysis." obs = UnbinnedObs(Name + '_gtmktime' + str(lc_bin_num) + '_lc.fits', SCFile, expMap=Name + '_expMap' + str(lc_bin_num) + '_lc.fits', expCube=Name + '_ltcube' + str(lc_bin_num) + '_lc.fits', irfs='P8R2_SOURCE_V6') analysis = UnbinnedAnalysis(obs, Name + '_output_model.xml', optimizer='NewMinuit') likeObj = pyLike.NewMinuit(analysis.logLike) analysis.tol = NMtol LIKE = analysis.fit(verbosity=0, covar=True, optObject=likeObj) fit = likeObj.getRetCode() print "Likelihood has converged whith Code " + str(likeObj.getRetCode()) Flux = analysis.flux(Name, emin=minEnergy, emax=maxEnergy) Ferr = analysis.fluxError(Name, emin=minEnergy, emax=maxEnergy) MeVtoErg = 1.602e-6 ef = analysis.energyFlux(Name, minEnergy, maxEnergy) * MeVtoErg ef_err = analysis.energyFluxError(Name, minEnergy, maxEnergy) * MeVtoErg UL = False TSUM = TSTART + TSTOP TMID = TSUM / 2 limit = Flux if analysis.Ts(Name) < TSul: UL = True limit, results = IUL.calc_int(analysis, Name, cl=0.90, emin=minEnergy, emax=maxEnergy) #Do second likelihood with constant flux to calculate the TS variability obsC = UnbinnedObs(Name + '_gtmktime' + str(lc_bin_num) + '_lc.fits', SCFile, expMap=Name + '_expMap' + str(lc_bin_num) + '_lc.fits', expCube=Name + '_ltcube' + str(lc_bin_num) + '_lc.fits', irfs='P8R2_SOURCE_V6') analysisC = UnbinnedAnalysis(obsC, Name + '_var_model.xml', optimizer='NewMinuit') likeObjC = pyLike.NewMinuit(analysisC.logLike) analysisC.tol = NMtol LIKEC = analysisC.fit(verbosity=0, covar=True, optObject=likeObjC) #Run gtselect to make smaller data fits file to compute the exposure, set to 3 degrees around source of interest f._setRad(3) f._setInfile(Evfile) f._setOutfile(Name + '_gtselect' + str(lc_bin_num) + '_exposure.fits') print "Creating file " + Name + "_gtselect_exposure.fits" f.amonSelect() #Run gtmaketime on this small region f._setEvfile(Name + '_gtselect' + str(lc_bin_num) + '_exposure.fits') f._setOutfile(Name + '_gtmktime' + str(lc_bin_num) + '_exposure.fits') print('Working on file ' + str(f.getOutfile())) f.amonTime() my_apps.evtbin['algorithm'] = 'LC' my_apps.evtbin['evfile'] = f.getOutfile() my_apps.evtbin['outfile'] = Name + '_LC' + str( lc_bin_num) + '_exposure.fits' my_apps.evtbin['scfile'] = f.getScfile() my_apps.evtbin['tbinalg'] = 'LIN' my_apps.evtbin['tstart'] = f.getTmin() my_apps.evtbin['tstop'] = f.getTmax() my_apps.evtbin['dtime'] = TSTOP - TSTART my_apps.evtbin.run() yes = subprocess.call([ 'gtexposure', Name + '_LC' + str(lc_bin_num) + '_exposure.fits', f.getScfile(), 'P8R2_SOURCE_V6', Name + '_output_model.xml', Name ]) if yes == 0: print "Exposure map has been created" else: print "Subprocessing failed. Unable to create exposure map with gtexposure." print "Time bin complete." hdulist = pyfits.open(Name + '_LC' + str(lc_bin_num) + '_exposure.fits') tbdata = hdulist[1].data z = tbdata['EXPOSURE'] exp = z[0] ################################################################ # This portion prints to the text file # ################################################################ f = open("lc_output.txt", "a") f.write( str(Flux) + ',' + str(Ferr) + ',' + str(ef) + ',' + str(ef_err) + ',' + str(limit) + ',' + str(analysis.Ts(Name)) + ',' + str(UL) + ',' + str(TMID) + ',' + str(exp) + ',' + str(LIKE) + ',' + str(LIKEC) + '\n') f.close() print "Likelihood analysis on this band is complete." yes = subprocess.call([ 'rm', Name + '_gtselect' + str(lc_bin_num) + '_lc.fits', Name + '_gtmktime' + str(lc_bin_num) + '_lc.fits', Name + '_cmap' + str(lc_bin_num) + '_lc.fits', Name + '_ccube' + str(lc_bin_num) + '_lc.fits', Name + '_ltcube' + str(lc_bin_num) + '_lc.fits', Name + '_expMap' + str(lc_bin_num) + '_lc.fits', Name + '_LC' + str(lc_bin_num) + '_exposure.fits', Name + '_srcmaps' + str(lc_bin_num) + '_lc.fits', Name + '_gtselect' + str(lc_bin_num) + '_exposure.fits', Name + '_gtmktime' + str(lc_bin_num) + '_exposure.fits' ]) if yes == 0: print 'Files for bin have been deleted' else: print "Subprocessing failed. Unable to delete files for bin."
def _compute(self): if self.verbosity: print 'Calculating gtlike upper limit' like = self.like name = self.name saved_state = SuperState(like) source = like.logLike.getSource(name) try: import IntegralUpperLimit # First, freeze spectrum (except for normalization) # of our soruce gtlike_allow_fit_only_prefactor(like, name) # Spectral fit whole ROI if self.verbosity: print 'Before fitting before Upper Limit:' print summary(like) """ N.B. spectral fit in this function instead of in upper limits code since my paranoid_gtlike_fit function is more robust. """ paranoid_gtlike_fit(like, verbosity=self.verbosity) if self.verbosity: print 'After fitting before Upper Limit:' print summary(like) # Freeze everything but our source of interest for i in range(len(like.model.params)): like.model[i].setFree(False) like.syncSrcParams(like[i].srcName) if self.rescale_parameters_before_limit: source=like.logLike.getSource(name) spectrum=source.spectrum() model = build_pointlike_model(spectrum) if self.verbosity: print 'Rescaling %s model parameters before limits' % model.name print ' * Initial mappers:',model.mappers norm_name = model.param_names[0] default_norm_limits = model.default_limits[norm_name] lower,upper = model.get_limits(norm_name) norm_min = min(lower, default_norm_limits.lower) norm_max = max(upper, default_norm_limits.upper) model.set_limits(norm_name, norm_min, norm_max, scale=1) if self.verbosity: print ' * New mappers:',model.mappers spectrum = build_gtlike_spectrum(model) like.setSpectrum(name,spectrum) like.syncSrcParams(name) # Note, I think freeze_all is redundant, but flag it just # to be paranoid flux_ul, results = IntegralUpperLimit.calc_int(like, name, freeze_all=True, skip_global_opt=True, cl=self.cl, emin=self.emin, emax=self.emax, verbosity=self.verbosity, **self.upper_limit_kwargs) if self.verbosity: print 'After computing Upper limit:' print summary(like) source=like.logLike.getSource(name) spectrum=source.spectrum() prefactor=spectrum.normPar() pref_ul = results['ul_value']*prefactor.getScale() prefactor.setTrueValue(pref_ul) self.results = flux_dict(like, name, emin=self.emin,emax=self.emax, flux_units=self.flux_units, energy_units=self.energy_units, errors=False, include_prefactor=self.include_prefactor, prefactor_energy=self.prefactor_energy) self.results['spectrum'] = spectrum_to_dict(spectrum) self.results['confidence'] = self.cl if self.xml_name is not None: # refree parameters before saving the XML saved_state.restore_free() # build pointlike model from object source=like.logLike.getSource(name) spectrum=source.spectrum() model = build_pointlike_model(spectrum) # set default oomp limits model.set_default_limits(oomp_limits=True) # place back into xml spectrum = build_gtlike_spectrum(model) like.setSpectrum(name,spectrum) like.syncSrcParams(name) like.writeXml(self.xml_name) except Exception, ex: print 'ERROR gtlike upper limit: ', ex traceback.print_exc(file=sys.stdout) self.results = None
def run(clean=False): gtselect['tmin'] = 0. + start_time gtselect['tmax'] = 86400/2 + start_time gtselect['infile'] = 'test_events.fits' gtselect['outfile'] = 'filtered1.fits' gtselect['ra'] = 90 gtselect['dec'] = 20 gtselect['rad'] = 20 gtselect.run() gtvcut.run(infile=gtselect['outfile'], table='EVENTS') gtltcube['evfile'] = 'filtered1.fits' gtltcube['scfile'] = 'orbSim_scData_0000.fits' gtltcube['outfile'] = 'expcube1.fits' gtltcube['dcostheta'] = 0.05 gtltcube['binsz'] = 1 gtltcube['phibins'] = 0 gtltcube['chatter'] = 4 gtltcube.run() gtselect['tmin'] = 86400/2 + start_time gtselect['tmax'] = 86400 + start_time gtselect['outfile'] = 'filtered2.fits' gtselect.run() gtvcut.run(infile=gtselect['outfile'], table='EVENTS') gtltcube['evfile'] = 'filtered2.fits' gtltcube['scfile'] = 'orbSim_scData_0000.fits' gtltcube['outfile'] = 'expcube2.fits' gtltcube['dcostheta'] = 0.05 gtltcube['binsz'] = 1 gtltcube['chatter'] = 4 gtltcube.run() gtltsum['infile1'] = 'expcube1.fits' gtltsum['infile2'] = 'expcube2.fits' gtltsum['outfile'] = 'expcube_1_day.fits' gtltsum['chatter'] = 4 gtltsum.run() gtexpmap.copy(gtltcube) gtexpmap['evfile'] = 'filtered_events_0000.fits' gtexpmap['irfs'] = irfs gtexpmap['srcrad'] = 30 gtexpmap['nlong'] = 120 gtexpmap['nlat'] = 120 gtexpmap['nenergies'] = 20 gtexpmap['expcube'] = 'expcube_1_day.fits' gtexpmap['outfile'] = 'expMap.fits' gtexpmap.run(chatter=4) gtvcut.run(infile=gtexpmap['outfile'], table='PRIMARY') gtdiffrsp.copy(gtexpmap) gtdiffrsp['srcmdl'] = srcmdl gtdiffrsp['evfile'] = 'filtered_events_0000.fits' gtdiffrsp['evtype'] = 'INDEF' gtdiffrsp.run(chatter=4) gtvcut.run(infile=gtdiffrsp['evfile'], table='EVENTS') gtlike.copy(gtltcube) gtlike.copy(gtdiffrsp) gtlike['expmap'] = gtexpmap['outfile'] gtlike['expcube'] = gtltsum['outfile'] gtlike['statistic'] = 'UNBINNED' gtlike['optimizer'] = 'MINUIT' if sys.platform == 'darwin': gtlike['optimizer'] = 'NEWMINUIT' gtlike['ftol'] = 1e-4 gtlike['refit'] = 'no' gtlike.run(chatter=3) like = unbinnedAnalysis(mode='h', optimizer='NEWMINUIT') like.fit(verbosity=0, tol=gtlike['ftol']) print like.model print "Ts values:" for src in like.sourceNames(): print src, like.Ts(src) print "Exercise UpperLimits.py" ul = UpperLimits(like) # for src in like.sourceNames(): for src in like.sourceNames()[:1]: if like[src].src.getType() == 'Point': flux_ul = ul[src].compute(emin=100, emax=3e5)[0] print src, flux_ul print "Exercise IntegralUpperLimit.py" # for src in like.sourceNames(): for src in like.sourceNames()[:1]: if like[src].src.getType() == 'Point': flux_ul = IntegralUpperLimit.calc_int(like, src) print src, flux_ul[0] # bayes_ul = ul[src].bayesianUL(emin=100, emax=3e5)[0] # print src, bayes_ul # TsMap['srcmdl'] = 'Ts_srcModel.xml' # TsMap.run() if clean: cleanUp()