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=0#,results = IUL.calc_int(analysis,Name,cl=0.95,emin=minEnergy, emax=maxEnergy) print "Bayesian upper limit: " + str(limit) + " photons/cm^2/s" #Calls for the prefactor/err, index/err, and scale N0 = analysis.model[Name].funcs['Spectrum'].getParam('Prefactor').value() N0_err = analysis.model[Name].funcs['Spectrum'].getParam('Prefactor').error() gamma = analysis.model[Name].funcs['Spectrum'].getParam('Index').value() gamma_err = analysis.model[Name].funcs['Spectrum'].getParam('Index').error() E0 = analysis.model[Name].funcs['Spectrum'].getParam('Scale').value() #Array that returns the results of the unbinned analysis #log-likelihood,flux,flux_err,test statisitc Return = [lkl,analysis.flux(Name, emin=minEnergy, emax=maxEnergy),analysis.fluxError(Name, emin=minEnergy, emax=maxEnergy),limit,analysis.Ts(Name,reoptimize=False),N0,N0_err,gamma,gamma_err,E0] return Return
def runFit(basename,directory,model,irfs,srcName,Emin,Emax): """ Performs the fit using maximum likelihood estimation. """ evtfile = directory + "/" + basename + "_filtered_gti.fits" SC = basename + "_SC.fits" expmap = directory + "/" + basename + "_expMap.fits" ltcube = directory + "/" + basename + "_ltcube.fits" obs = UnbinnedObs(eventFile=evtfile, scFile=SC, expMap=expmap, expCube=ltcube, irfs=irfs) analysis = UnbinnedAnalysis(obs, srcModel=model, optimizer='NEWMINUIT') likeObj = pyLike.NewMinuit(analysis.logLike) analysis.fit(verbosity=0,covar=True,optObject=likeObj) num = int(directory[directory.find('bin')+3:]) return "{:8d}{:14.4e}{:14.4e}{:10.4f}{:12.4f}{:12.2f}".format(num, \ analysis.flux(srcName,emin=100,emax=300000), \ analysis.fluxError(srcName,emin=100,emax=300000), \ analysis.model[srcName].funcs['Spectrum'].getParam('Index').value(), \ analysis.model[srcName].funcs['Spectrum'].getParam('Index').error(), \ analysis.Ts(srcName))
def PerformLikelihoodAnalysis(self): print "\nPerforming likelihood analysis on position: ra=%s, dec=%s" % ( self.xref, self.yref) # Wait a random amount of time between 1 and 5 minutes before starting in order to not crash the asf/nsf disks at SLAC waitTime = random.random() * 300 time.sleep(waitTime) # Defind the scratch directory JobID = os.environ.get('LSB_JOBID') Username = getpass.getuser() ScratchDirectory = "/scratch/%s/%s/" % (Username, JobID) # Define the pfile directory if JobID == 'None': PFILESDirectory = "%s/pfiles_%s/" % (self.outdir, self.binNumber) else: PFILESDirectory = "%s/pfiles/" % ScratchDirectory # Create the output directory if it doesn't already exist if (os.path.isdir(self.outdir) == False): print "\n >> Creating Directory: " + self.outdir cmd = "mkdir " + self.outdir os.system(cmd) # Define where to save the results likelihoodResults = '%s/likelihoodResults_bin%s.txt' % (self.outdir, self.binNumber) # Remove any pre-existing pfiles if (os.path.isdir(PFILESDirectory) == True): cmd = "rm -r %s" % PFILESDirectory os.system(cmd) # Set the new pfiles directory SetPfilesDirectory(PFILESDirectory) # Make a copy of the source model xmlModelWithPutativeSource = '%s/ModelSource_bin%s.xml' % ( self.outdir, self.binNumber) cmd = "cp " + self.srcmdl + " " + xmlModelWithPutativeSource print cmd os.system(cmd) # Add a putative point source at the requested location # AddCandidateSource(self.xref, self.yref, xmlModelWithPutativeSource) ModifySourceModel(xmlModelWithPutativeSource, self.xref, self.yref) # # Import the necessary gtapps # gtlike = GtApp('gtlike') # # Run the likelihood analysis # print '\nPerforming the likelihood fit:' # gtlike.run(statistic=self.statistic, # scfile=self.scfile, # evfile=self.evfile, # expmap=self.expmap, # expcube=self.expcube, # srcmdl=xmlModelWithPutativeSource, # irfs=self.irfs, # optimizer=self.optimizer, # results=likelihoodResults, # plot='no', # save='yes') # Setup the unbinned likelihood object print '\nPerforming the likelihood fit:' try: obs = UnbinnedObs(self.evfile, self.scfile, expMap=self.expmap, expCube=self.expcube, irfs=self.irfs) # Define the likelihood object #like = UnbinnedAnalysis(obs,xmlModelWithPutativeSource,optimizer=self.optimizer) like = UnbinnedAnalysis(obs, xmlModelWithPutativeSource, optimizer='MINUIT') # Setup the likelihood parameters Source = 'CandidateSource' Integral = like.par_index(Source, 'Integral') Index = like.par_index(Source, 'Index') LowerLimit = like.par_index(Source, 'LowerLimit') UpperLimit = like.par_index(Source, 'UpperLimit') # Setup the likelihood bounds like[Integral].setScale(1e-3) like[Index].setBounds(-5, -0.5) # like[LowerLimit] = emin # like[UpperLimit] = emax # Perform the likelihood fit #optObject = pyLike.NewMinuit(like.logLike) #like.fit(verbosity=0,covar=True,tol=0.02,optObject=optObject) like.fit(verbosity=1, covar=True, tol=1e-10, optimizer='MINUIT', optObject=None) # Extract the best fit index IndexValue = like[Index].value() IndexError = like[Index].error() # Extract the best fit flux FluxValue = like.flux(Source, emin=100, emax=3e5) FluxError = like.fluxError(Source, emin=100, emax=3e5) # Extract likelihood fit results print '\nLikelihood Results:' print like.model[Source] print "TS = %s" % like.Ts(Source) print "Flux = %s +/- %s" % (FluxValue, FluxError) print "Index = %s +/- %s" % (IndexValue, IndexError) # Save the xml file like.writeXml(xmlFile=xmlModelWithPutativeSource) except Exception, message: print traceback.format_exc()
def main(NAME, RA, DEC, TSTART, TSTOP, EMIN, EMAX, SC, ROIu, xml): ROIue = float(ROIu) + 10 os.system('ls -1 *PH*.fits > %s_events.list' % (NAME)) my_apps.filter['evclass'] = 128 my_apps.filter['evtype'] = 3 my_apps.filter['ra'] = RA my_apps.filter['dec'] = DEC my_apps.filter['rad'] = ROIu my_apps.filter['emin'] = EMIN my_apps.filter['emax'] = EMAX my_apps.filter['zmax'] = 90 my_apps.filter['tmin'] = TSTART my_apps.filter['tmax'] = TSTOP my_apps.filter['infile'] = '@%s_events.list' % (NAME) my_apps.filter['outfile'] = '%s_filtered.fits' % (NAME) my_apps.filter.run() # maketime my_apps.maketime['scfile'] = SC my_apps.maketime['filter'] = '(DATA_QUAL>0)&&(LAT_CONFIG==1)' my_apps.maketime['roicut'] = 'no' my_apps.maketime['evfile'] = '%s_filtered.fits' % (NAME) my_apps.maketime['outfile'] = '%s_filtered_gti.fits' % (NAME) my_apps.maketime.run() # my_apps.counts_map['evfile'] = '%s_filtered_gti.fits' % (NAME) my_apps.counts_map['scfile'] = SC my_apps.counts_map['outfile'] = '%s_CountMap.fits' % (NAME) # my_apps.counts_map.run() # my_apps.expCube['evfile'] = '%s_filtered_gti.fits' % (NAME) my_apps.expCube['scfile'] = SC my_apps.expCube['zmax'] = 90 my_apps.expCube['outfile'] = 'expCube.fits' my_apps.expCube['dcostheta'] = 0.025 my_apps.expCube['binsz'] = 1 my_apps.expCube.run() my_apps.expMap['evfile'] = '%s_filtered_gti.fits' % (NAME) my_apps.expMap['scfile'] = SC my_apps.expMap['expcube'] = 'expCube.fits' my_apps.expMap['outfile'] = 'expMap.fits' my_apps.expMap['irfs'] = 'CALDB' my_apps.expMap['srcrad'] = ROIue my_apps.expMap['nlong'] = 120 my_apps.expMap['nlat'] = 120 my_apps.expMap['nenergies'] = 20 my_apps.expMap.run() # sara xml model roiname = '%s_filtered_gti.fits' % NAME if float(xml) == 0: xml_creator_P8_v1.main(NAME, float(RA), float(DEC), float(EMIN), float(EMAX), 15) xmlmodelname = '%s_model.xml' % NAME my_apps.diffResps['evfile'] = '%s_filtered_gti.fits' % (NAME) my_apps.diffResps['scfile'] = SC my_apps.diffResps['srcmdl'] = xmlmodelname my_apps.diffResps['irfs'] = 'CALDB' my_apps.diffResps.run() xmlfitname = '%s_fit1.xml' % NAME obs = UnbinnedObs(roiname, SC, expMap='expMap.fits', expCube='expCube.fits', irfs='CALDB') # like1 = UnbinnedAnalysis(obs,xmlmodelname,optimizer='MINUIT') like1 = UnbinnedAnalysis(obs, xmlmodelname, optimizer='NewMinuit') likeobj = pyLike.NewMinuit(like1.logLike) like1.fit(verbosity=0, optObject=likeobj) print likeobj.getRetCode() sourceDetails = {} for source in like1.sourceNames(): sourceDetails[source] = like1.Ts(source) for source, TS in sourceDetails.iteritems(): if (TS < 2): print "Deleting...", source, " TS = ", TS like1.deleteSource(source) like1.fit(verbosity=0, optObject=likeobj) print "0 is converged", likeobj.getRetCode() like1.logLike.writeXml(xmlfitname) numl = search(NAME, xmlfitname) numlg = str(numl + 3) os.system("sed '" + numlg + "," + numlg + " s/free=\"1\"/free=\"0\"/' " + xmlfitname + " > xml_sed.xml ") inputs = likeInput(like1, NAME, model="xml_sed.xml", nbins=6, phCorr=1.0) inputs.plotBins() inputs.fullFit(CoVar=True) sed = likeSED(inputs) sed.getECent() sed.fitBands() sed.Plot() result = like1.model[NAME] TS = like1.Ts(NAME) flux = like1.flux(NAME, emin=100) gamma = like1.model[NAME].funcs['Spectrum'].getParam('Index').value() cov_gg = like1.model[NAME].funcs['Spectrum'].getParam('Index').error() # cov_II = like1.model[NAME].funcs['Spectrum'].getParam('Integral').error() flux_err = like1.fluxError(NAME, emin=100) like1.plot() fitsedname = '%s_6bins_likeSEDout.fits' % NAME sedtool(fitsedname) print NAME, " TS=", TS print result if float(xml) == 1: xmlmodelname = '%s_model.xml' % NAME xmlfitname = '%s_fit1.xml' % NAME obs = UnbinnedObs(roiname, SC, expMap='expMap.fits', expCube='expCube.fits', irfs='CALDB') # like1 = UnbinnedAnalysis(obs,xmlmodelname,optimizer='MINUIT') like1 = UnbinnedAnalysis(obs, xmlmodelname, optimizer='NewMinuit') likeobj = pyLike.NewMinuit(like1.logLike) like1.fit(verbosity=0, optObject=likeobj) print likeobj.getRetCode() sourceDetails = {} for source in like1.sourceNames(): sourceDetails[source] = like1.Ts(source) for source, TS in sourceDetails.iteritems(): if (TS < 2): print "Deleting...", source, " TS = ", TS like1.deleteSource(source) like1.fit(verbosity=0, optObject=likeobj) print "0 is converged", likeobj.getRetCode() like1.logLike.writeXml(xmlfitname) numl = search(NAME, xmlfitname) numlg = str(numl + 3) os.system("sed '" + numlg + "," + numlg + " s/free=\"1\"/free=\"0\"/' " + xmlfitname + " > xml_sed.xml ") inputs = likeInput(like1, NAME, model="xml_sed.xml", nbins=6, phCorr=1.0) inputs.plotBins() inputs.fullFit(CoVar=True) sed = likeSED(inputs) sed.getECent() sed.fitBands() sed.Plot() result = like1.model[NAME] TS = like1.Ts(NAME) flux = like1.flux(NAME, emin=100) gamma = like1.model[NAME].funcs['Spectrum'].getParam('Index').value() cov_gg = like1.model[NAME].funcs['Spectrum'].getParam('Index').error() # cov_II = like1.model[NAME].funcs['Spectrum'].getParam('Integral').error() flux_err = like1.fluxError(NAME, emin=100) like1.plot() fitsedname = '%s_6bins_likeSEDout.fits' % NAME sedtool(fitsedname) print NAME, " TS=", TS print result
class quickLike: """ This is the base class. A usual likelihood analysis will consists of running the following functions (assuming you have a configuration file): * qL = quickLike('MySource', True) * qL.makeObs() * qL.initDRM() * qL.fitDRM() * qL.initMIN() * qL.fitMIN() This will set up all of the objects needed for the analysis and do an initial fit with one of the DRM optimizers. It'll save these results and use them for the second fit with one of the Minuit optimizers. If you do not have a configuration file, you'll need to input all of the options for this module when you create the quickLike object (see the various options below). You can create a configuration file by executing writeConfig(). * qL.writeConfig() This module will catch any failures from the optimizers and will report them to the user. There are a few functions that are useful to use in this case:""" def __init__(self, base = 'MySource', configFile = False, likelihoodConfig = {"model" : "MySource_model.xml", "sourcename" : "Source Name", "drmtol" : 0.1, "mintol" : 1e-4}, commonConfig = {"base" : 'MySource', "eventclass" : 2, "binned" : False, "irfs" : "P7SOURCE_V6", "verbosity" : 0}): commonConfig['base'] = base self.logger = initLogger(base, 'quickLike') if(configFile): try: commonConfigRead,analysisConfigRead,likelihoodConfigRead,plotConfigRead = readConfig(self.logger,base) except(FileNotFound): self.logger.critical("One or more needed files do not exist") return try: commonConfig = checkConfig(self.logger,commonConfig,commonConfigRead) except(KeyError): return try: likelihoodConfig = checkConfig(self.logger,likelihoodConfig,likelihoodConfigRead) except(KeyError): return self.commonConf = commonConfig self.likelihoodConf = likelihoodConfig self.ret = re.compile('\n') self.fitbit = False self.Print() def writeConfig(self): """Writes all of the initialization variables to the config file called <basename>.cfg""" writeConfig(quickLogger=self.logger, commonDictionary=self.commonConf, likelihoodDictionary=self.likelihoodConf) def Print(self): """Prints out information about the various objects to the terminal and to the log file.""" logString = "Created quickLike object: " for variable, value in self.commonConf.iteritems(): logString += variable+"="+str(value)+"," for variable, value in self.likelihoodConf.iteritems(): logString += variable+"="+str(value)+"," self.logger.info(logString) def makeObs(self): """Creates either a binned or unbinned observation object for use in the likelihood analysis. This function checks for all of the needed files first. If you do not have a needed file, see the quickAnalysis module for creation. This function should be run before any of the init or fit functions.""" if(self.commonConf['binned']): try: checkForFiles(self.logger,[self.commonConf['base']+'_srcMaps.fits', self.commonConf['base']+'_ltcube.fits', self.commonConf['base']+'_BinnedExpMap.fits']) self.obs = BinnedObs(srcMaps=self.commonConf['base']+'_srcMaps.fits', expCube=self.commonConf['base']+'_ltcube.fits', binnedExpMap=self.commonConf['base']+'_BinnedExpMap.fits', irfs=self.commonConf['irfs']) except(FileNotFound): self.logger.critical("One or more needed files do not exist") return else: try: checkForFiles(self.logger,[self.commonConf['base']+'_filtered_gti.fits', self.commonConf['base']+'_SC.fits', self.commonConf['base']+'_expMap.fits', self.commonConf['base']+'_ltcube.fits']) self.obs = UnbinnedObs(self.commonConf['base']+'_filtered_gti.fits', self.commonConf['base']+'_SC.fits', expMap=self.commonConf['base']+'_expMap.fits', expCube=self.commonConf['base']+'_ltcube.fits', irfs=self.commonConf['irfs']) except(FileNotFound): self.logger.critical("One or more needed files do not exist") return self.logger.info(self.ret.subn(', ',str(self.obs))[0]) def initDRM(self): """Initializes the DRM optimizer (either binned or unbinned). This is usually the second function that you run when using this module. You need to run makeObs before you run this function. If it hasn't been run, this function will exit.""" try: self.obs except AttributeError: self.logger.critical("Obs object does not exist. Create it first with the makeObs function") return try: checkForFiles(self.logger,[self.likelihoodConf['model']]) if(self.commonConf['binned']): self.DRM = BinnedAnalysis(self.obs,self.likelihoodConf['model'],optimizer="DRMNGB") else: self.DRM = UnbinnedAnalysis(self.obs,self.likelihoodConf['model'],optimizer="DRMNGB") self.DRM.tol = float(self.likelihoodConf['drmtol']) self.logger.info(self.ret.subn(', ',str(self.DRM))[0]) except(FileNotFound): self.logger.critical("One or more needed files do not exist") return def initAltFit(self,opt="MINUIT"): """Initiallizes a minuit optimizer to use as a backup to the DRM optimizer. This function is used internally in the fitDRM function so you probably will never use it. You need to run makeObs before you run this function. If it hasn't been run, this function will exit.""" try: self.obs except AttributeError: self.logger.critical("Obs object does not exist. Create it first with the makeObs function") return try: checkForFiles(self.logger,[self.likelihoodConf['model']]) if(self.commonConf['binned']): self.ALTFIT = BinnedAnalysis(self.obs,self.likelihoodConf['model'],optimizer=opt) else: self.ALTFIT = UnbinnedAnalysis(self.obs,self.likelihoodConf['model'],optimizer=opt) self.ALTFIT.tol = float(self.likelihoodConf['drmtol']) self.ALTFITobj = pyLike.Minuit(self.ALTFIT.logLike) self.logger.info(self.ret.subn(', ',str(self.ALTFIT))[0]) except(FileNotFound): self.logger.critical("One or more needed files do not exist") return def initMIN(self, useBadFit=False): """Initiallizes a New Minuit optimizer to use as a backup to the DRM optimizer. This is usually run after you have initially run fitDRM and created a <basename>_likeDRM.xml model file which is used a seed for the New Minuit optimizer. You can skip the DRM process if you like but you need to have the proper model file (<basename>_likeDRM.xml) present in the working directory. You need to run makeObs before you run this function. If it hasn't been run, this function will exit. If you want to use the non convergant fit from fitDRM, set useBadFit to True.""" try: self.obs except AttributeError: self.logger.critical("Obs object does not exist. Create it first with the makeObs function.") return if(useBadFit): model = self.commonConf['base']+'_badDRMFit.xml' else: model = self.commonConf['base']+'_likeDRM.xml' try: checkForFiles(self.logger,[model]) if(self.commonConf['binned']): self.MIN = BinnedAnalysis(self.obs,model,optimizer='NewMinuit') else: self.MIN = UnbinnedAnalysis(self.obs,model,optimizer='NewMinuit') self.MIN.tol = float(self.likelihoodConf['mintol']) self.MINobj = pyLike.NewMinuit(self.MIN.logLike) self.logger.info(self.ret.subn(', ',str(self.MIN))[0]) except(FileNotFound): self.logger.critical("One or more needed files do not exist") return def fitDRM(self): """Performs a DRM inital fit on your data using the <basename>_model.xml model file. It tries an intial fit and if that fails, tries a tighter tolerance. If that fails, it tries a looser tolerance. If that fails, it tries to do this initial fit with the MINUIT optimizer. If that fails, this function bails. If the fit converges, it saves the results to <basename>_likeDRM.xml which will be used in the NewMinuit fit. If no fit is found, it will save the results to <basename>_badDRMFit.xml. You can use this in the NewMinuit fit if you use the useBadFit option in initMIN. You need to have run initDRM before you run this function.""" try: self.DRM except AttributeError: self.logger.critical("DRM object does not exist. Create it first with the initDRM function.") return altfit=False try: self.DRM.fit(verbosity=int(self.commonConf['verbosity'])) except: self.logger.error("Initial DRM Fit Failed") try: self.logger.info("Trying tighter tolerance (DRMtol*0.1)") self.DRM.tol = float(self.likelihoodConf['drmtol']) * 0.1 self.DRM.fit(verbosity= int(self.commonConf['verbosity'])) except: self.logger.error("Second DRM Fit Failed") try: self.logger.info("Trying looser tolerance (drmtol*10.)") self.DRM.tol = float(self.likelihoodConf['drmtol']) * 10. self.DRM.fit(verbosity= int(self.commonConf['verbosity'])) except: self.logger.error("Third DRM Fit Failed") try: self.logger.info("Trying alternate fit algorithm (MINUIT)") self.initAltFit() self.ALTFIT.fit(verbosity=int(self.commonConf['verbosity']),covar=True,optObject=self.ALTFITobj) print self.ALTFITobj.getQuality() altfit = True except: self.logger.error("Alternative fit algorithm failed, bailing") self.logger.error(self.decodeRetCode('Minuit',self.ALTFITobj.getRetCode())) self.ALTFIT.logLike.writeXml(self.commonConf['base']+'_badDRMFit.xml') self.logger.info("Saved ALTFIT as "+self.commonConf['base']+"_badDRMFit.xml") return if(altfit): self.logger.info("ALTFIT Fit Finished. Total TS: "+str(self.ALTFIT.logLike.value())) self.ALTFIT.logLike.writeXml(self.commonConf['base']+'_likeDRM.xml') self.logger.info("Saved ALTFIT as "+self.commonConf['base']+"_likeDRM.xml") else: self.DRM.logLike.writeXml(self.commonConf['base']+'_likeDRM.xml') self.logger.info("DRM Fit Finished. Total TS: "+str(self.DRM.logLike.value())) self.logger.info("Saved DRM as "+self.commonConf['base']+"_likeDRM.xml") def fitMIN(self): """Does a New Minuit fit on your data based on the model output by the fitDRM function. You need to have run initMIN before running this function. Saves the results to <basename>_likeMIN.xml if there is convergence. If convergence is not found, saves the results to <basename>_badMINFit.xml.""" try: self.MIN except AttributeError: self.logger.critical("MIN object does not exist. Create it first with the initMIN function.") return self.MIN.fit(covar=True, optObject=self.MINobj,verbosity=int(self.commonConf['verbosity'])) self.MIN.logLike.writeXml(self.commonConf['base']+'_likeMinuit.xml') self.logger.info("NEWMINUIT Fit Finished. Total TS: "+str(self.MIN.logLike.value())) self.logger.info("NEWMINUIT Fit Status: "+str(self.MINobj.getRetCode())) self.logger.info("NEWMINUIT fit Distance: "+str(self.MINobj.getDistance())) self.fitbit = True if(self.MINobj.getRetCode() > 0): self.logger.error("NEWMINUIT DID NOT CONVERGE!!!") self.logger.error("The fit failed the following tests: "+self.decodeRetCode('NewMinuit',self.MINobj.getRetCode())) self.MIN.fit(covar=True, optObject=self.MINobj,verbosity=int(self.commonConf['verbosity'])) self.MIN.logLike.writeXml(self.commonConf['base']+'_badMINFit.xml') def printSource(self,source,Emin=100,Emax=300000): """Prints various details for a source in your model.""" try: self.MIN except AttributeError: self.logger.critical("MIN object does not exist. "+\ "Create it first with the initMIN function and then fit it with the fitMIN function.") return if(not self.fitbit): self.logger.warn("Fit isn't current, these values might not be correct. Fun fitMIN first.") logString = source TS = self.MIN.Ts(source) print "TS: ",TS logString += " TS: " + str(TS) NPred = self.MIN.NpredValue(source) print "Npred: ",NPred logString += " NPred: " + str(NPred) flux = self.MIN.flux(source,emin=Emin,emax=Emax) print "Flux: ",flux logString += "Flux: "+str(flux) if(self.fitbit): fluxErr = self.MIN.fluxError(source,emin=Emin,emax=Emax) print "Flux Error: ",fluxErr logString += "Flux Error: "+str(fluxErr) for paramName in self.MIN.model[source].funcs['Spectrum'].paramNames: paramValue = self.MIN.model[source].funcs['Spectrum'].getParam(paramName).value() print paramName,": ",paramValue logString += paramName + ": " + str(paramValue) + " " self.logger.info(logString) def customERange(self,Emin,Emax): """Sets a smaller energy range for the fitting of both the DRM and MIN optimization steps.""" try: self.DRM except AttributeError: self.logger.warn("DRM object doesn't exist. Energy range not modified.") else: self.DRM.setEnergyRange(Emin,Emax) self.logger.info("Set energy range for DRM to "+str(self.DRM.emin)+","+str(self.DRM.emax)) try: self.MIN except AttributeError: self.logger.warn("MIN object doesn't exist. Energy range not modified.") else: self.MIN.setEnergyRange(Emin,Emax) self.logger.info("Set energy range for MIN to "+str(self.MIN.emin)+","+str(self.MIN.emax)) def calcUpper(self,source,Emin=100,Emax=300000): """Calculates an upper limit for a source in your model.""" self.ul = UpperLimits(self.MIN) self.ul[source].compute(emin=Emin,emax=Emax) print self.ul[source].results self.logger.info(source+" UL: "+str(self.ul[source].results[0])) def removeWeak(self,mySource = '',tslimit=0,distlimit=0,RemoveFree=False,RemoveFixed=False): """This function has two main uses: it will print out details on all of the sources in your model and it will remove sources according to different requirements. If you just want to print out details, execute it this way: <obj>.removeWeak(<my_source>) Where <obj> is the quickLike object you're using here and <my_source> is the name of your source of interest. You can then remove some of these sources from the model if you like. For example, if you want to remove all of the fixed sources with TS values less than 1, execute it this way: <obj>.removeWeak(<my_source>,tslimit=1,RemoveFixed=True) You can mix and match any of the options. You could remove all sources (fixed and free) that are below a TS value of 3 and are 10 degrees from your source of interest by executing: <obj>.removeWeak(<my_source>,tslimit=3,distlimit=10,RemoveFree=True,RemoveFixed=True)""" try: self.MIN except AttributeError: self.logger.critical("MIN object does not exist. "+\ "Create it first with the initMIN function and then fit it with the fitMIN function.") return if(not self.fitbit): self.logger.warn("Fit isn't current, these values might not be correct. Run fitMIN first.") if(mySource == ''): mySource = self.likelihoodConf['sourcename'] for name in self.MIN.sourceNames(): remove = False distance = 0 sourceTS = self.MIN.Ts(name) if(self.MIN.model[name].src.getType() == 'Point'): distance = self.MIN._separation(self.MIN.model[mySource].src,self.MIN.model[name].src) if(self.MIN.freePars(name).size() > 0): indexFree = "Free" if( (sourceTS < tslimit) and (distance > distlimit) and RemoveFree ): remove = True else: indexFree = "Fixed" if( (sourceTS < tslimit) and (distance > distlimit) and RemoveFixed ): remove = True if( remove ): self.logger.info("Removing "+name+", TS: "+str(sourceTS)+", Frozen?: "+str(indexFree)+", Distance: "+str(distance)) self.MIN.deleteSource(name) else: self.logger.info("Retaining "+name+", TS: "+str(sourceTS)+", Frozen?: "+str(indexFree)+", Distance: "+str(distance)) def paramsAtLimit(self, limit = 0.1): """This function will print out any sources whoes parameters are close to their limits. You could use this to find sources that are having issues being fit. This function is useful when you're having trouble getting convergence from the New Minuit fit routine. The limit is in percentage difference of a bound. If one of the bounds is zero it uses the value of the parameter to check for closeness (absolute instead of percent differenct). The default is 0.1 (1%) difference for a measure of closeness.""" try: self.MIN except AttributeError: self.logger.critical("MIN object does not exist. "+\ "Create it first with the initMIN function and then fit it with the fitMIN function.") return if(not self.fitbit): self.logger.warn("Fit isn't current, these values might not be correct. Run fitMIN first.") for src in self.MIN.sourceNames(): for name in self.MIN.model[src].funcs['Spectrum'].paramNames: bounds = self.MIN.model[src].funcs['Spectrum'].getParam(name).getBounds() value = self.MIN.model[src].funcs['Spectrum'].getParam(name).value() try: distToLower = abs((value - bounds[0])/bounds[0]) except ZeroDivisionError: distToLower = abs(value) try: distToUpper = abs((value - bounds[1])/bounds[1]) except ZeroDivisionError: distToUpper = abs(value) if( distToLower < limit ): self.logger.error("The "+name+" ("+str(value)+") of "+src+" is close ("\ +str(distToLower)+") to its lower limit ("+str(bounds[0])+")") if( distToUpper < limit): self.logger.error("The "+name+" ("+str(value)+") of "+src+" is close ("\ +str(distToUpper)+") to its upper limit ("+str(bounds[1])+")") def decodeRetCode(self, optimizer, retCode): """Decodes the return codes from the Minuit and New Minuit fit functions. Used in the fitting functions in this module. You'll probably never use this function.""" if(optimizer == 'NewMinuit'): retCode -= 100 failure = "" if(retCode & 1): failure += " IsAboveMaxEdm" if(retCode & 2): failure += " HasCovariance" if(retCode & 4): failure += " HesseFailed" if(retCode & 8): failure += " HasMadePosDefCovar" if(retCode & 16): failure += " HasPosDefCovar" if(retCode & 32): failure += " HasAccurateCovar" if(retCode & 64): failure += " HasValidCovariance" if(retCode & 128): failure += " HasValidParameters" if(retCode & 256): failure += " IsValid" return failure if(optimizer == 'Minuit'): if(retCode == 0): failure = "Error matrix not calculated at all" if(retCode == 1): failure = "Diagonal approximation only, not accurate" if(retCode == 2): failure = "Full matrix, but forced positive-definite (i.e. not accurate)" if(retCode == 3): failure = "Full accurate covariance matrix (After MIGRAD, this is the indication of normal convergence.)" return failure
like1.fit(verbosity=0) like1.logLike.writeXml(str(name)+'fit'+str(this_bin)+'.xml') like2 = UnbinnedAnalysis(obs,srcModel=str(name)+'fit'+str(this_bin)+'.xml',optimizer='NewMinuit') obj = pyLike.Minuit(like2.logLike) like2.fit(verbosity=0, covar=True, optObject=obj) like2.plot() try: flux = like2.model['_2FGLJ'+str(cat_name)].funcs['Spectrum'].getParam('Integral').value() errFlux = like2.model['_2FGLJ'+str(cat_name)].funcs['Spectrum'].getParam('Integral').error() scale = like2.model['_2FGLJ'+str(cat_name)].funcs['Spectrum'].getParam('Integral').getScale() except: flux = 0 errFlux = 0 scale = 0 ratio1 = like2.fluxError('_2FGLJ'+str(cat_name),emin=energy_min, emax=energy_max) ratio2 = like2.flux('_2FGLJ'+str(cat_name),emin=energy_min, emax=energy_max) ults = like2.Ts('_2FGLJ'+str(cat_name)) scaled_flux = flux*scale scaled_errFlux = errFlux*scale ulfr = ratio1/ratio2 folder.append(str(scaled_flux)) #Flux xml folder.append(" ") folder.append(str(scaled_errFlux)) #Flux xml Error folder.append(" ") folder.append(str(like2.flux('_2FGLJ'+str(cat_name),emin=energy_min, emax=energy_max))) #Flux method folder.append(" ") folder.append(str(like2.fluxError('_2FGLJ'+str(cat_name),emin=energy_min, emax=energy_max))) #Flux method error folder.append(" ")
def PerformLikelihoodAnalysis(self): print "\nPerforming likelihood analysis on position: ra=%s, dec=%s" % (self.xref, self.yref) # Wait a random amount of time between 1 and 5 minutes before starting in order to not crash the asf/nsf disks at SLAC waitTime = random.random()*300 time.sleep(waitTime) # Defind the scratch directory JobID = os.environ.get('LSB_JOBID') Username = getpass.getuser() ScratchDirectory = "/scratch/%s/%s/" % (Username, JobID) # Define the pfile directory if JobID == 'None': PFILESDirectory = "%s/pfiles_%s/" % (self.outdir, self.binNumber) else: PFILESDirectory = "%s/pfiles/" % ScratchDirectory # Create the output directory if it doesn't already exist if(os.path.isdir(self.outdir)==False): print "\n >> Creating Directory: " + self.outdir cmd = "mkdir " + self.outdir os.system(cmd) # Define where to save the results likelihoodResults = '%s/likelihoodResults_bin%s.txt' % (self.outdir, self.binNumber) # Remove any pre-existing pfiles if(os.path.isdir(PFILESDirectory)==True): cmd = "rm -r %s" % PFILESDirectory os.system(cmd) # Set the new pfiles directory SetPfilesDirectory(PFILESDirectory) # Make a copy of the source model xmlModelWithPutativeSource = '%s/ModelSource_bin%s.xml' % (self.outdir, self.binNumber) cmd = "cp " + self.srcmdl + " " + xmlModelWithPutativeSource print cmd os.system(cmd) # Add a putative point source at the requested location # AddCandidateSource(self.xref, self.yref, xmlModelWithPutativeSource) ModifySourceModel(xmlModelWithPutativeSource, self.xref, self.yref) # # Import the necessary gtapps # gtlike = GtApp('gtlike') # # Run the likelihood analysis # print '\nPerforming the likelihood fit:' # gtlike.run(statistic=self.statistic, # scfile=self.scfile, # evfile=self.evfile, # expmap=self.expmap, # expcube=self.expcube, # srcmdl=xmlModelWithPutativeSource, # irfs=self.irfs, # optimizer=self.optimizer, # results=likelihoodResults, # plot='no', # save='yes') # Setup the unbinned likelihood object print '\nPerforming the likelihood fit:' try: obs = UnbinnedObs(self.evfile,self.scfile,expMap=self.expmap,expCube=self.expcube,irfs=self.irfs) # Define the likelihood object #like = UnbinnedAnalysis(obs,xmlModelWithPutativeSource,optimizer=self.optimizer) like = UnbinnedAnalysis(obs,xmlModelWithPutativeSource,optimizer='MINUIT') # Setup the likelihood parameters Source = 'CandidateSource' Integral = like.par_index(Source, 'Integral') Index = like.par_index(Source, 'Index') LowerLimit = like.par_index(Source, 'LowerLimit') UpperLimit = like.par_index(Source, 'UpperLimit') # Setup the likelihood bounds like[Integral].setScale(1e-3) like[Index].setBounds(-5, -0.5) # like[LowerLimit] = emin # like[UpperLimit] = emax # Perform the likelihood fit #optObject = pyLike.NewMinuit(like.logLike) #like.fit(verbosity=0,covar=True,tol=0.02,optObject=optObject) like.fit(verbosity=1,covar=True,tol=1e-10,optimizer='MINUIT', optObject=None) # Extract the best fit index IndexValue = like[Index].value() IndexError = like[Index].error() # Extract the best fit flux FluxValue = like.flux(Source, emin=100, emax=3e5) FluxError = like.fluxError(Source, emin=100, emax=3e5) # Extract likelihood fit results print '\nLikelihood Results:' print like.model[Source] print "TS = %s" % like.Ts(Source) print "Flux = %s +/- %s" % (FluxValue, FluxError) print "Index = %s +/- %s" % (IndexValue, IndexError) # Save the xml file like.writeXml(xmlFile=xmlModelWithPutativeSource) except Exception, message: print traceback.format_exc()
plt.loglog(E,sum_model,label='Total Model') plt.errorbar(E,like._Nobs(),yerr=np.sqrt(like._Nobs()), fmt='o',label='Counts') plt.legend(bbox_to_anchor=(1.05, 1), loc=2) plt.savefig('results/1.eps',format='eps', bbox_inches='tight') # Save figure! # Plot residuals sum_counts=sum_model # Is this right? Probably not :/ resid = (like._Nobs() - sum_counts)/sum_counts resid_err = (np.sqrt(like._Nobs())/sum_counts) plt.figure(figsize=(9,9)) plt.xscale('log') plt.errorbar(E,resid,yerr=resid_err,fmt='o') plt.axhline(0.0,ls=':') plt.savefig('results/2.eps',format='eps', bbox_inches='tight') # Get indexes and stuff fid=open('results/'+name_type+'_results.txt','w') for sourceName in like.sourceNames(): fid.write(str(like.model[sourceName])) fid.write('Flux: '+str(like.flux(sourceName,emin=eMin))+'\n') fid.write('Flux Error: '+str(like.fluxError(sourceName,emin=eMin))+'\n') fid.write('TS: '+str(like.Ts(sourceName))+'\n') fid.write('Sigma: '+str(np.sqrt(like.Ts(sourceName)))+'\n') fid.write('\n=====================================\n') fid.close() # Save .xml like.logLike.writeXml('results/'+name_type+'_results.xml')
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 main(NAME,RA,DEC,TSTART,TSTOP,EMIN,EMAX,Np, path, ROIu): #outdir = os.environ["FERMI_TMPLATAREA"] gtliketxt=open("%s/%s_gtlike.txt"%(path,Np),'w') gtsedtxt=open("%s/%s_sed.txt"%(path,Np),'w') SCC='%s_SC00.fits'%(Np) SC=path+SCC Npp=path+Np print SC ROIue=float(ROIu)+10 os.system("ls -1 '"+Npp+"'_PH*.fits > %s/%s_events.list" %(path,Np)) # os.system('ls -1 'Np'+'PH*.fits > %s/%s_events.list' %(path,Np) my_apps.filter['evclass'] = 128 my_apps.filter['evtype'] = 3 # my_apps.filter['evclsmin'] = 3 # my_apps.filter['evclsmax'] = 4 my_apps.filter['ra'] = RA my_apps.filter['dec'] = DEC my_apps.filter['rad'] = ROIu my_apps.filter['emin'] = EMIN my_apps.filter['emax'] = EMAX my_apps.filter['zmax'] = 90 my_apps.filter['tmin'] = TSTART my_apps.filter['tmax'] = TSTOP my_apps.filter['infile'] = '@%s/%s_events.list' %(path,Np) my_apps.filter['outfile'] = '%s/%s_filtered.fits'%(path,Np) my_apps.filter.run() # maketime my_apps.maketime['scfile'] = SC my_apps.maketime['filter'] = '(DATA_QUAL>0)&&(LAT_CONFIG==1)' my_apps.maketime['roicut'] = 'no' my_apps.maketime['evfile'] = '%s/%s_filtered.fits' %(path,Np) my_apps.maketime['outfile'] = '%s/%s_filtered_gti.fits' %(path,Np) my_apps.maketime.run() # # my_apps.counts_map['evfile'] = '%s/%s_filtered_gti.fits'%(path,Np) # my_apps.counts_map['scfile'] = SC # my_apps.counts_map['outfile'] = '%s/%s_CountMap.fits'%(path,Np) # my_apps.counts_map.run() # my_apps.expCube['evfile'] = '%s/%s_filtered_gti.fits'%(path,Np) my_apps.expCube['scfile'] = SC my_apps.expCube['zmax'] = 90 my_apps.expCube['outfile'] = '%s/%s_expCube.fits' %(path,Np) my_apps.expCube['dcostheta'] = 0.025 my_apps.expCube['binsz'] = 1 my_apps.expCube.run() my_apps.expMap['evfile'] = '%s/%s_filtered_gti.fits'%(path,Np) my_apps.expMap['scfile'] = SC my_apps.expMap['expcube'] ='%s/%s_expCube.fits' %(path,Np) my_apps.expMap['outfile'] ='%s/%s_expMap.fits' %(path,Np) # my_apps.expMap['irfs'] ='P7REP_SOURCE_V15' my_apps.expMap['irfs'] ='CALDB' my_apps.expMap['srcrad'] = ROIue my_apps.expMap['nlong'] =120 my_apps.expMap['nlat'] =120 my_apps.expMap['nenergies'] =20 my_apps.expMap.run() #sara xml model roiname='%s/%s_filtered_gti.fits' %(path,Np) xml_creator_P7_v1.main(path,NAME,float(RA),float(DEC),float(EMIN), float(EMAX), 20,Np) xmlmodelname='%s/%s_model.xml' %(path,Np) my_apps.diffResps['evfile'] = '%s/%s_filtered_gti.fits'%(path,Np) my_apps.diffResps['scfile'] = SC my_apps.diffResps['srcmdl'] = xmlmodelname my_apps.diffResps['irfs'] = 'CALDB' my_apps.diffResps.run() xmlfitname='%s/%s_fit1.xml' %(path,Np) expMapFile='%s/%s_expMap.fits' %(path,Np) expCubeFile='%s/%s_expCube.fits' %(path,Np) obs = UnbinnedObs(roiname,SC ,expMap=expMapFile,expCube=expCubeFile,irfs='CALDB') like1 = UnbinnedAnalysis(obs,xmlmodelname,optimizer='NewMinuit') like1.fit(verbosity=0) like1.logLike.writeXml(xmlfitname) # numl=search(NAME,xmlfitname) # numlg=str(numl+3) # os.system("sed '"+numlg+","+numlg+" s/free=\"1\"/free=\"0\"/' "+xmlfitname+ " > xml_sed.xml ") # inputs=likeInput(like1,NAME,model="xml_sed.xml",nbins=9,phCorr=1.0) #low_edges = [200.,914.61,1955.87,8944.27,19127.05,40902.61] #high_edges = [427.69,1955.87,8944.27,19127.05,40902.61,187049.69] #centers = [0.2767, 1.265, 5.787, 12.37, 26.46, 86.60] #inputs.customBins(low_edges,high_edges) # inputs.plotBins() # inputs.fullFit(CoVar=True) # sed = likeSED(inputs) # sed.getECent() # sed.fitBands() # sed.Plot() result=like1.model[NAME] TS=like1.Ts(NAME) # I = like1.model[NAME].funcs['Spectrum'].getParam('Integral').value() flux = like1.flux(NAME,emin=100) # flux=I*1e-9 gamma = like1.model[NAME].funcs['Spectrum'].getParam('Index').value() cov_gg =like1.model[NAME].funcs['Spectrum'].getParam('Index').error() # cov_II = like1.model[NAME].funcs['Spectrum'].getParam('Integral').error() flux_err = like1.fluxError(NAME,emin=100) # flux_err=cov_II*1e-9 e=1000.0 a=1 b=1.e-18 lenergy_bin=log10(double(EMIN))+(log10(double(EMAX))-log10(double(EMIN)))/2 energy_bin=pow(10,lenergy_bin) freq=2.42e22*energy_bin/100.0 ums = 1.-gamma conv=ums*pow(energy_bin,(-gamma))/(pow(double(EMAX),ums)-pow(double(EMIN),ums))*6.62e-2*(energy_bin/100.0) # conv is in Jy # now convert in nufnu erg/cm2/s convjy=conv*freq*1.e-23 nufnu=flux*convjy b=flux_err*convjy err_log=log10((nufnu+b)/nufnu) #cout<<freq<<" "<<a<<" "<<nufnu<<" "<<b<<endl; #cout<<log10(freq)<<" "<<log10(a)<<" "<<log10(nufnu)<<" "<<err_log<<endl; date_start=computeDate(float(TSTART)) date_stop=computeDate(float(TSTOP)) # like1.plot() # fitsedname='%s_9bins_likeSEDout.fits' %NAME # sedtool(fitsedname) print NAME, " TS=", TS # print result # print like1.model print "spectral index= ", gamma, " +/-", cov_gg print " Flux=", flux, "+/-", flux_err print "freq", freq, " nuFnu=", nufnu, b, # print "'UL': ", results_ul, err gtliketxt.write(NAME) gtliketxt.write(" RA=") gtliketxt.write(RA) gtliketxt.write(" DEC= ") gtliketxt.write(DEC) gtliketxt.write(" TS= ") gtliketxt.write(str(TS)) gtliketxt.write("\n") gtliketxt.write(" Time Interval (MJD) ") gtliketxt.write(str(date_start)) gtliketxt.write(" ") gtliketxt.write(str(date_stop)) gtliketxt.write("\n ") gtliketxt.write("Flux ") if TS <25: obs = UnbinnedObs(roiname,SC ,expMap=expMapFile,expCube=expCubeFile,irfs='CALDB') like1 = UnbinnedAnalysis(obs,xmlmodelname,optimizer='NewMinuit') like1.fit(verbosity=0) ul=UpperLimits(like1) UL=ul[NAME].compute(emin=double(EMIN),emax=double(EMAX)) results_ul=UL[1]*1E-9 err=0 print "'UL': ", results_ul, err gamma_ul=2.0 ums_ul = 1.-gamma_ul conv_ul=ums_ul*pow(energy_bin,(-gamma_ul))/(pow(double(EMAX),ums_ul)-pow(double(EMIN),ums_ul))*6.62e-2*(energy_bin/100.0) convjy_ul=conv_ul*freq*1.e-23 nufnu_ul=results_ul*convjy_ul b=err*convjy_ul print "freq", freq, "0 nuFnu=", nufnu_ul, b, gtliketxt.write(str(results_ul)) gtliketxt.write(" 0 ") #gtliketxt.write(err) gtsedtxt.write(str(freq)) gtsedtxt.write(" | 0 ") gtsedtxt.write(" | ") gtsedtxt.write(str(nufnu_ul)) gtsedtxt.write(" | ") gtsedtxt.write(str(b)) gtsedtxt.write(" | ") gtsedtxt.write(str(date_start)) gtsedtxt.write(" | ") gtsedtxt.write(str(date_stop)) gtsedtxt.write(" | ") gtsedtxt.write(" UL ") gtsedtxt.write(" | ") else: gtliketxt.write(str(flux)) gtliketxt.write(" ") gtliketxt.write(str(flux_err)) gtliketxt.write("\n") gtliketxt.write("Spectral Index = ") gtliketxt.write(str(gamma)) gtliketxt.write(" ") gtliketxt.write(str(cov_gg)) gtsedtxt.write(" ") gtsedtxt.write(str(freq)) gtsedtxt.write(" | 0 ") gtsedtxt.write(" | ") gtsedtxt.write(str(nufnu)) gtsedtxt.write(" | ") gtsedtxt.write(str(b)) gtsedtxt.write(" | ") gtsedtxt.write(str(date_start)) gtsedtxt.write(" | ") gtsedtxt.write(str(date_stop)) gtsedtxt.write(" | ")