Пример #1
0
    def CreateFit(self):
        """Create an UnbinnedAnalysis or a BinnedAnalysis and retrun it.
        By default, the optimizer is DRMNGB """

        #create binnedAnalysis object
        if self.config['analysis']['likelihood'] == 'binned':
            Obs = BinnedObs(srcMaps=self.obs.scrMap,
                            expCube=self.obs.Cubename,
                            binnedExpMap=self.obs.BinnedMapfile,
                            irfs=self.obs.irfs)
            Fit = BinnedAnalysis(Obs, self.obs.xmlfile,
                                 optimizer='DRMNGB')

        #create a unbinnedAnalysis object
        if self.config['analysis']['likelihood'] == 'unbinned':
            Obs = UnbinnedObs(self.obs.eventfile,
                              self.obs.ft2,
                              expMap=self.obs.Mapname,
                              expCube=self.obs.Cubename,
                              irfs=self.obs.irfs)
            Fit = UnbinnedAnalysis(Obs, self.obs.xmlfile,
                                   optimizer='DRMNGB')

        if float(self.config['Spectrum']['FrozenSpectralIndex']) > 0:
            PhIndex = Fit.par_index(self.obs.srcname, 'Index')
            Fit[PhIndex] = -float(self.config['Spectrum']['FrozenSpectralIndex'])
            Fit.freeze(PhIndex)

        return Fit #return the BinnedAnalysis or UnbinnedAnalysis object.
Пример #2
0
    def CreateLikeObject(self):
        """Create an UnbinnedAnalysis or a BinnedAnalysis and retrun it.
        By default, the optimizer is DRMNGB """

        #create binnedAnalysis object
        if self.config['analysis']['likelihood'] == 'binned':
            Obs = BinnedObs(srcMaps=self.obs.scrMap,
                            expCube=self.obs.Cubename,
                            binnedExpMap=self.obs.BinnedMapfile,
                            irfs=self.obs.irfs)
            Fit = BinnedAnalysis(Obs, self.obs.xmlfile,
                                 optimizer='DRMNGB')

        #create a unbinnedAnalysis object
        if self.config['analysis']['likelihood'] == 'unbinned':
            Obs = UnbinnedObs(self.obs.eventfile,
                              self.obs.ft2,
                              expMap=self.obs.Mapname,
                              expCube=self.obs.Cubename,
                              irfs=self.obs.irfs)
            Fit = UnbinnedAnalysis(Obs, self.obs.xmlfile,
                                   optimizer='DRMNGB')

        if float(self.config['Spectrum']['FrozenSpectralIndex']) > 0:
            if Fit.model.srcs[self.obs.srcname].spectrum().genericName()=="PowerLaw" or Fit.model.srcs[self.obs.srcname].spectrum().genericName()=="PowerLaw2":
                PhIndex = Fit.par_index(self.obs.srcname, 'Index')
                Fit[PhIndex] = -float(self.config['Spectrum']['FrozenSpectralIndex'])
                Fit.freeze(PhIndex)
                print "Freezing spectral index at ",-float(self.config['Spectrum']['FrozenSpectralIndex'])
            else:
              log.warning("The model is not a PowerLaw. Cannot freeze the index.")
        return Fit #return the BinnedAnalysis or UnbinnedAnalysis object.
Пример #3
0
    def CreateLikeObject(self):
        """Create an UnbinnedAnalysis or a BinnedAnalysis and retrun it."""
        #create binnedAnalysis object
        if self.config['analysis']['likelihood'] == 'binned':
            use_edisp  = self.config['analysis']['EnergyDispersion'] == 'yes'
            edisp_bins = -2 if use_edisp==True else 0
            Obs = BinnedObs(srcMaps=self.obs.srcMap,
                            expCube=self.obs.Cubename,
                            binnedExpMap=self.obs.BinnedMapfile,
                            irfs=self.obs.irfs)
            Cfg = BinnedConfig(use_edisp=use_edisp, 
                               edisp_bins=edisp_bins)
            Fit = BinnedAnalysis(Obs, self.obs.xmlfile, config=Cfg,
                                 optimizer=self.config['fitting']['optimizer'])
            
            Fit.setEnergyRange(self.obs.Emin,self.obs.Emax)
            print("Is edisp enabled? {0}".format(str(Fit.logLike.use_edisp())))
            
        #create a unbinnedAnalysis object
        if self.config['analysis']['likelihood'] == 'unbinned':
            Obs = UnbinnedObs(self.obs.mktimefile,
                              self.obs.ft2,
                              expMap=self.obs.Mapname,
                              expCube=self.obs.Cubename,
                              irfs=self.obs.irfs)
            Fit = UnbinnedAnalysis(Obs, self.obs.xmlfile,
                                   optimizer=self.config['fitting']['optimizer'])
	
	# Fix this, EBL absorbed models use LogParabola with b=0 instead of PowerLaw, 
        # we may want to allow fixed shape for that case
        if float(self.config['Spectrum']['FrozenSpectralIndex']!=0): 
            parameters = dict()
            parameters['Index']  = -float(self.config['Spectrum']['FrozenSpectralIndex'])
            parameters['alpha']  = +float(self.config['Spectrum']['FrozenSpectralIndex'])
            parameters['Index1'] = -float(self.config['Spectrum']['FrozenSpectralIndex'])
            parameters['beta']   = 0
            parameters['Index2'] = 2.
            parameters['Cutoff'] = 30000. # set the cutoff to be high

            for key in parameters.keys():
                IdGamma = utils.getParamIndx(Fit, self.obs.srcname, key)
                if (IdGamma == -1):
                    continue
                else:
                    self.info("Freezing %s = %s" %(str(key),str(parameters[key])))
                    Fit[IdGamma] = parameters[key] # set the parameter
                    Fit[IdGamma].setFree(False)#the variable index is frozen to compute the UL
                     
        return Fit #return the BinnedAnalysis or UnbinnedAnalysis object.
Пример #4
0
def GetLikeObj(obs, modelin, optimizer, tol=1e-3):

    if isinstance(obs, list) or isinstance(obs, tuple):
        like1 = SummedLikelihood(optimizer=optimizer)
        for il, obs1 in enumerate(obs):
            print 'Creating a Likelihood object for obs%d...' % il
            like2 = BinnedAnalysis(obs1, modelin, optimizer=optimizer)
            like1.addComponent(like2)
    elif isinstance(obs, BinnedObs):
        like1 = BinnedAnalysis(obs, modelin, optimizer=optimizer)
    else:
        print 'error: invalid ObsObject'
        exit(1)

    return like1
Пример #5
0
    def setup_gtlike(self):

        self._obs = BinnedObs(srcMaps=self.srcmapfile,
                              expCube=self.config['ltcube'],
                              binnedExpMap=self.bexpfile,
                              irfs=self.config['irfs'])

        self._like = BinnedAnalysis(binnedData=self._obs,
                                    srcModel=self.srcmdl,
                                    optimizer=self.config['optimizer'])
Пример #6
0
    def CreateLikeObject(self):
        """Create an UnbinnedAnalysis or a BinnedAnalysis and retrun it.
        By default, the optimizer is DRMNGB """

        #create binnedAnalysis object
        if self.config['analysis']['likelihood'] == 'binned':
            Obs = BinnedObs(srcMaps=self.obs.scrMap,
                            expCube=self.obs.Cubename,
                            binnedExpMap=self.obs.BinnedMapfile,
                            irfs=self.obs.irfs)
            Fit = BinnedAnalysis(Obs, self.obs.xmlfile, optimizer='DRMNGB')

        #create a unbinnedAnalysis object
        if self.config['analysis']['likelihood'] == 'unbinned':
            Obs = UnbinnedObs(self.obs.eventfile,
                              self.obs.ft2,
                              expMap=self.obs.Mapname,
                              expCube=self.obs.Cubename,
                              irfs=self.obs.irfs)
            Fit = UnbinnedAnalysis(Obs, self.obs.xmlfile, optimizer='DRMNGB')

        if float(self.config['Spectrum']['FrozenSpectralIndex']) > 0:
            if Fit.model.srcs[self.obs.srcname].spectrum().genericName(
            ) == "PowerLaw" or Fit.model.srcs[
                    self.obs.srcname].spectrum().genericName() == "PowerLaw2":
                PhIndex = Fit.par_index(self.obs.srcname, 'Index')
                Fit[PhIndex] = -float(
                    self.config['Spectrum']['FrozenSpectralIndex'])
                Fit.freeze(PhIndex)
                print "Freezing spectral index at ", -float(
                    self.config['Spectrum']['FrozenSpectralIndex'])
            else:
                log.warning(
                    "The model is not a PowerLaw. Cannot freeze the index.")
        return Fit  #return the BinnedAnalysis or UnbinnedAnalysis object.
Пример #7
0
    def CreateLikeObject(self):
        """Create an UnbinnedAnalysis or a BinnedAnalysis and retrun it."""

        #create binnedAnalysis object
        if self.config['analysis']['likelihood'] == 'binned':
            Obs = BinnedObs(srcMaps=self.obs.srcMap,
                            expCube=self.obs.Cubename,
                            binnedExpMap=self.obs.BinnedMapfile,
                            irfs=self.obs.irfs)
            Fit = BinnedAnalysis(Obs,
                                 self.obs.xmlfile,
                                 optimizer=self.config['fitting']['optimizer'])

        #create a unbinnedAnalysis object
        if self.config['analysis']['likelihood'] == 'unbinned':
            Obs = UnbinnedObs(self.obs.mktimefile,
                              self.obs.ft2,
                              expMap=self.obs.Mapname,
                              expCube=self.obs.Cubename,
                              irfs=self.obs.irfs)
            Fit = UnbinnedAnalysis(
                Obs,
                self.obs.xmlfile,
                optimizer=self.config['fitting']['optimizer'])

# Fix this, EBL absorbed models use LogParabola with b=0 instead of PowerLaw, we may want to allow fixed shape for that case
        if float(self.config['Spectrum']['FrozenSpectralIndex'] > 0
                 ) and self.config['target']['spectrum'] == "PowerLaw":
            parameters = dict()
            parameters['Index'] = -float(
                self.config['Spectrum']['FrozenSpectralIndex'])
            # parameters['alpha']  = +float(self.config['Spectrum']['FrozenSpectralIndex'])
            # parameters['Index1'] = -float(self.config['Spectrum']['FrozenSpectralIndex'])
            # parameters['beta']   = 0
            # parameters['Index2'] = 2.
            # parameters['Cutoff'] = 30000. # set the cutoff to be high

            for key in parameters.keys():
                try:
                    IdGamma = utils.getParamIndx(Fit, self.obs.srcname, key)
                    Fit[IdGamma] = parameters[key]  # set the parameter
                    Fit[IdGamma].setFree(
                        0)  #the variable index is frozen to compute the UL
                except:
                    continue
                else:
                    self.info("Freezing %s at %s"\
                            %(key,str(self.config['Spectrum']['FrozenSpectralIndex'])))
        return Fit  #return the BinnedAnalysis or UnbinnedAnalysis object.
def main(srcMaps=None,
         expCube=None,
         binnedExpMap=None,
         outname=None,
         IRFs='CALDB',
         index=2):
    if srcMaps is None:
        srcMaps = env['ccube']
        expCube = env['lvtime']
        binnedExpMap = env['bexpcube']
        outname = env.get('mdlmap',
                          'modelcube.fits').replace('.fits', '_ps.fits')
        IRFs = env.get('irfs', 'CALDB')

    obs = BinnedObs(srcMaps=srcMaps,
                    expCube=expCube,
                    binnedExpMap=binnedExpMap,
                    irfs=IRFs)

    with pyfits.open(srcMaps) as f:
        w = WCS(f[0].header)
        cpix = int(f[0].header['NAXIS1']) / 2
    RA, DEC, e = w.wcs_pix2sky([[cpix, cpix, 0]], 0)[0]

    xmlfile = outname.replace('.fits', '') + '.xml'

    with open(xmlfile, 'w') as f:
        f.write(content_xml % (index, RA, DEC))

    like1 = BinnedAnalysis(obs, xmlfile, optimizer='')
    os.remove(xmlfile)

    print 'creating Model Map...'
    like1.writeModelMap(outname)

    print 'Done!'
Пример #9
0
    def CreateLikeObject(self):
        """Create an UnbinnedAnalysis or a BinnedAnalysis and retrun it."""

        #create binnedAnalysis object
        if self.config['analysis']['likelihood'] == 'binned':
            Obs = BinnedObs(srcMaps=self.obs.srcMap,
                            expCube=self.obs.Cubename,
                            binnedExpMap=self.obs.BinnedMapfile,
                            irfs=self.obs.irfs)
            Fit = BinnedAnalysis(Obs, self.obs.xmlfile,
                                 optimizer=self.config['fitting']['optimizer'])

        #create a unbinnedAnalysis object
        if self.config['analysis']['likelihood'] == 'unbinned':
            Obs = UnbinnedObs(self.obs.eventfile,
                              self.obs.ft2,
                              expMap=self.obs.Mapname,
                              expCube=self.obs.Cubename,
                              irfs=self.obs.irfs)
            Fit = UnbinnedAnalysis(Obs, self.obs.xmlfile,
                                   optimizer=self.config['fitting']['optimizer'])

        if float(self.config['Spectrum']['FrozenSpectralIndex']) != 0:
            parameters = dict()
            parameters['Index']  = -float(self.config['Spectrum']['FrozenSpectralIndex'])
            parameters['alpha']  = +float(self.config['Spectrum']['FrozenSpectralIndex'])
            parameters['Index1'] = -float(self.config['Spectrum']['FrozenSpectralIndex'])
            parameters['beta']   = 0
            parameters['Index2'] = 2.
            parameters['Cutoff'] = 30000. # set the cutoff to be high
            
            for key in parameters.keys():
                try:
                    IdGamma = utils.getParamIndx(Fit, self.obs.srcname, key)
                    Fit[IdGamma] = parameters[key] # set the parameter
                    Fit[IdGamma].setFree(0)#the variable index is frozen to compute the UL
                except:
                    continue
                else:
                    self.info("Freezing %s at %s"\
                            %(key,str(self.config['Spectrum']['FrozenSpectralIndex'])))
        return Fit #return the BinnedAnalysis or UnbinnedAnalysis object.
Пример #10
0
    def CreateLikeObject(self):
        """Create an UnbinnedAnalysis or a BinnedAnalysis and retrun it."""

        #create binnedAnalysis object
        if self.config['analysis']['likelihood'] == 'binned':
            Obs = BinnedObs(srcMaps=self.obs.srcMap,
                            expCube=self.obs.Cubename,
                            binnedExpMap=self.obs.BinnedMapfile,
                            irfs=self.obs.irfs)
            Fit = BinnedAnalysis(Obs, self.obs.xmlfile,
                                 optimizer=self.config['fitting']['optimizer'])

        #create a unbinnedAnalysis object
        if self.config['analysis']['likelihood'] == 'unbinned':
            Obs = UnbinnedObs(self.obs.eventfile,
                              self.obs.ft2,
                              expMap=self.obs.Mapname,
                              expCube=self.obs.Cubename,
                              irfs=self.obs.irfs)
            Fit = UnbinnedAnalysis(Obs, self.obs.xmlfile,
                                   optimizer=self.config['fitting']['optimizer'])

        if float(self.config['Spectrum']['FrozenSpectralIndex']) > 0:
            if Fit.model.srcs[self.obs.srcname].spectrum().genericName()=="PowerLaw" or\
                    Fit.model.srcs[self.obs.srcname].spectrum().genericName()=="PowerLaw2":
                PhIndex = Fit.par_index(self.obs.srcname, 'Index')
                Fit[PhIndex] = -float(self.config['Spectrum']['FrozenSpectralIndex'])
                Fit.freeze(PhIndex)
            elif Fit.model.srcs[self.obs.srcname].spectrum().genericName()=="PLSuperExpCutoff":
                PhIndex = Fit.par_index(self.obs.srcname, 'Index1')
                Fit[PhIndex] = -float(self.config['Spectrum']['FrozenSpectralIndex'])
                Fit.freeze(PhIndex)
                self.info("Freezing spectral index at -"+str(self.config['Spectrum']['FrozenSpectralIndex']))
            elif Fit.model.srcs[self.obs.srcname].spectrum().genericName()=="PLSuperExpCutoff":
                PhIndex = Fit.par_index(self.obs.srcname, 'Index1')
                Fit[PhIndex] = -float(self.config['Spectrum']['FrozenSpectralIndex'])
                Fit.freeze(PhIndex)
                self.info("Freezing spectral index at -"+str(self.config['Spectrum']['FrozenSpectralIndex']))
            else:
              self.warning("The model is not a PowerLaw. Cannot freeze the index.")
        return Fit #return the BinnedAnalysis or UnbinnedAnalysis object.
Пример #11
0
    def __init__(self, roi, **kwargs):
        """ Build a gtlike pyLikelihood object
            which is consistent with a pointlike roi. """
        keyword_options.process(self, kwargs)
        self.roi = roi

        if not roi.quiet: print 'Running a gtlike followup'

        self.old_dir = os.getcwd()
        if self.savedir is not None:
            self.savedata = True
            if not os.path.exists(self.savedir):
                os.makedirs(self.savedir)
        else:
            self.savedata = False
            self.savedir = mkdtemp(prefix=self.savedir_prefix)

        # put pfiles into savedir
        os.environ['PFILES'] = self.savedir + ';' + os.environ['PFILES'].split(
            ';')[-1]

        if not roi.quiet: print 'Saving files to ', self.savedir

        if self.emin == None and self.emax == None and self.enumbins == None:
            self.emin, self.emax = roi.bin_edges[0], roi.bin_edges[-1]
            self.enumbins = len(roi.bin_edges) - 1
        elif self.emin is not None and \
                self.emax is not None and \
                self.enumbins is not None:
            # all set
            pass
        else:
            raise Exception("emin, emax, and enumbins must all be set.")

        # Note that this formulation makes the gtlike slightly smaller than
        # the pointlike ROI (so the gtlike ROI is inside the pointlike ROI)
        roi_radius = np.degrees(max(_.radius_in_rad for _ in roi.bands))
        if self.bigger_roi:
            npix = int(math.ceil(2.0 * roi_radius / self.binsz))
        else:
            npix = int(math.ceil(np.sqrt(2.0) * roi_radius / self.binsz))

        ct = roi.sa.pixeldata.conv_type

        cmap_file = join(self.savedir, 'ccube.fits')
        srcmap_file = join(self.savedir, 'srcmap.fits')
        bexpmap_file = join(self.savedir, 'bexpmap.fits')
        input_srcmdl_file = join(self.savedir, 'srcmdl.xml')
        cut_ft1 = join(self.savedir, "ft1_cut.fits")

        ft2 = Gtlike.get_ft2(roi)
        ltcube = roi.sa.pixeldata.ltcube

        if self.fix_pointlike_ltcube:
            print 'Fixing pointlike ltcube %s' % ltcube
            livetime.fix_pointlike_ltcube(ltcube)

        irfs = Gtlike.get_gtlike_irfs(roi)

        if self.galactic:
            x, y, coordsys_str = roi.roi_dir.l(), roi.roi_dir.b(), 'GAL'
        else:
            x, y, coordsys_str = roi.roi_dir.ra(), roi.roi_dir.dec(), 'CEL'

        Gtlike.save_xml(roi,
                        input_srcmdl_file,
                        extended_dir_name=self.extended_dir_name)

        evfile = Gtlike.make_evfile(roi, self.savedir)

        if not os.path.exists(cut_ft1):
            if not roi.quiet: print 'Running gtselect'
            gtselect = GtApp('gtselect', 'dataSubselector')
            gtselect.run(infile=evfile,
                         outfile=cut_ft1,
                         ra=0,
                         dec=0,
                         rad=180,
                         tmin=0,
                         tmax=0,
                         emin=self.emin,
                         emax=self.emax,
                         zmax=180,
                         convtype=ct,
                         chatter=self.chatter)
        else:
            if not roi.quiet: print '... Skiping gtselect'

        if not os.path.exists(cmap_file):
            if not roi.quiet: print 'Running gtbin (ccube)'
            gtbin = GtApp('gtbin', 'evtbin')
            gtbin.run(algorithm='ccube',
                      nxpix=npix,
                      nypix=npix,
                      binsz=self.binsz,
                      evfile=cut_ft1,
                      outfile=cmap_file,
                      scfile=ft2,
                      xref=x,
                      yref=y,
                      axisrot=0,
                      proj=self.proj,
                      ebinalg='LOG',
                      emin=self.emin,
                      emax=self.emax,
                      enumbins=self.enumbins,
                      coordsys=coordsys_str,
                      chatter=self.chatter)
        else:
            if not roi.quiet: print '... Skiping gtbin (ccube)'

        if not os.path.exists(bexpmap_file):
            # Use the default binning all sky, 1deg/pixel
            if not roi.quiet: print 'Running gtexpcube'
            gtexpcube = GtApp('gtexpcube2', 'Likelihood')
            gtexpcube.run(infile=ltcube,
                          cmap='none',
                          ebinalg='LOG',
                          emin=self.emin,
                          emax=self.emax,
                          enumbins=self.enumbins,
                          outfile=bexpmap_file,
                          proj='CAR',
                          nxpix=360,
                          nypix=180,
                          binsz=1,
                          irfs=irfs,
                          coordsys=coordsys_str,
                          chatter=self.chatter)
        else:
            if not roi.quiet: print '... Skiping gtexpcube'

        if not os.path.exists(srcmap_file):
            if not roi.quiet: print 'Running gtsrcmaps'
            gtsrcmaps = GtApp('gtsrcmaps', 'Likelihood')
            gtsrcmaps.run(scfile=ft2,
                          expcube=ltcube,
                          cmap=cmap_file,
                          srcmdl=input_srcmdl_file,
                          bexpmap=bexpmap_file,
                          outfile=srcmap_file,
                          irfs=irfs,
                          rfactor=self.rfactor,
                          resample=self.resample,
                          minbinsz=self.minbinsz,
                          chatter=self.chatter)
        else:
            if not roi.quiet: print '... Skiping gtsrcmaps'

        if not roi.quiet: print 'Creating Binned LIKE'
        obs = BinnedObs(srcMaps=srcmap_file,
                        expCube=ltcube,
                        binnedExpMap=bexpmap_file,
                        irfs=irfs)

        self.like = BinnedAnalysis(binnedData=obs,
                                   srcModel=input_srcmdl_file,
                                   optimizer=self.optimizer)

        if self.enable_edisp:
            if not roi.quiet: print 'Enabeling energy dispersion'
            self.like.logLike.set_edisp_flag(True)

        if not roi.quiet: print 'Binned LIKE Created!'