IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 39049 for trunk


Ignore:
Timestamp:
Nov 6, 2015, 8:37:34 AM (11 years ago)
Author:
eugene
Message:

add 2nd diff detection pass to insert the negative image detections (inv.cmf)

Location:
trunk/ippToPsps/jython
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippToPsps/jython/diffbatch.py

    r39039 r39049  
    7777       self.expTime = {}
    7878       self.obsTime = {}
    79        self.fits = {}
     79       self.posFits = {}
     80       self.negFits = {}
    8081       self.tessID = {}
    8182       self.tessName = {}
    … …  
    101102           self.logger.infoPair("getting diff" ," metadata")
    102103           self.logger.infoPair("for diff skyfile id ", str(diffSkyFileID))
    103            meta = {}
     104
    104105           meta = self.gpc1Db.getDiffStageMeta(int(diffSkyFileID))
    105106
    106            # this code is very fragile: it depends on the right order in the output
    107            # of the sql call in another file (see forcedwarpbatch.py for a better method)
     107           # EAM 20151105 : I have changed the function above to return "meta" as a dictionary
    108108           if not meta:
    109109               self.logger.errorPair("Could not get", "diff metadata")
    110110               raise
    111            self.filterName[num] = meta[0];
    112 
    113            self.difftypeID[num] = meta[1];
    114            self.ippDiffID[num] = stageid
    115            self.posImageID[num] = meta[2];
    116            self.negImageID[num] = meta[3];
    117            self.skycellName[num] = meta[4];
    118            self.analysisVer[num] =  meta[5];
    119            self.expTime[num] = meta[6];
     111
     112           self.ippDiffID[num]  = stageid
     113
     114           self.filterName[num]  = meta['filter'];
     115           self.difftypeID[num]  = meta['diff_mode'];
     116           self.posImageID[num]  = meta['warp1'];
     117           self.negImageID[num]  = meta['stack2'];
     118           self.skycellName[num] = meta['skycell_id'];
     119           self.analysisVer[num] = meta['software_ver'];
     120           self.expTime[num]     = meta['exp_time'];
     121           self.expID[num]       = meta['exp_id'];
     122           self.tessName[num]    = meta['tess_id'];
     123
    120124           ## MEH -- should be able to use diff header now for mjd (see below)
    121            #self.obsTime[num] = meta[7];
    122            # tess_id is handled below, that's #8.
    123            self.expID[num] = meta[9];
     125           # self.obsTime[num] = meta['obsTime'];
     126
     127           # tessName could also come from the header...
     128           # tessName = None
     129           # tessName = self.getKeyValue(self.header[num], 'TESS_ID')
     130
    124131           self.logger.infoPair("loading diff stage cmf", diffSkyFileID)
    125            self.fits[num] = gpc1Db.getDiffStageCmf(skychunk.dvoLabel, int(diffSkyFileID))
     132
     133           # look up the path base once
     134           pathBase = gpc1Db.getDiffStagePathBase(skychunk.dvoLabel, int(diffSkyFileID))
     135
     136           # select the two (possible) cmf files (.cmf and .inv.cmf)
     137           self.posFits[num] = gpc1Db.getDiffStageCmfForPathBase(pathBase)
     138           self.negFits[num] = gpc1Db.getDiffStageCmfForPathBase(pathBase + ".inv")
     139
    126140           self.logger.infoPair("loading diff stage header", diffSkyFileID)
    127            self.header[num] = self.fits[num].getPrimaryHeader()
     141           self.header[num] = self.posFits[num].getPrimaryHeader()
     142
     143           # obsTime is the center of the exposure.  MJD-OBS is the start in days, expTime is the length in seconds
    128144           self.obsTime[num] = float(self.header[num]['MJD-OBS']) + (float(self.expTime[num]) / 172800.0)
    129   #         tessName = None
    130   #         tessName = self.getKeyValue(self.header[num], 'TESS_ID')
    131            self.tessName[num]= meta[8];
     145
    132146           tessName = self.tessName[num]
     147           self.logger.infoPair("TessName ", tessName)
     148           self.tessID[num] = self.scratchDb.getTessID(tessName)
    133149           self.logger.infoPair("TessName ",tessName)
    134            self.tessID[num] = self.scratchDb.getTessID(tessName)
    135 
    136            self.logger.infoPair("TessName ",tessName)
    137        # XXX EAM 20140812 : I am hardwiring the parsing logic for RINGS vs LOCAL
     150
     151           # XXX EAM 20140812 : I am hardwiring the parsing logic for RINGS vs LOCAL
    138152           if self.tessName[num] == 'RINGS.V3':
    139153           # skycell is, eg "skycell.1133.081"
    … …  
    152166
    153167           ## MEH md5sum test
    154            self.md5sum[num] = self.fits[num].getMd5sum()
    155 
    156        # drop the existing tables   
     168           self.md5sum[num] = self.posFits[num].getMd5sum()
     169
     170           # drop the existing tables   
    157171
    158172           self.dropTableVerbose("DiffMeta_"+str(num))
    … …  
    162176
    163177           if not self.analysisVer[num]: self.analysisVer[num] = -999
     178
    164179           self.logger.infoPair("getPhotoCalID",diffSkyFileID)
    165180           self.photoCalID[num] = str(self.scratchDb.getPhotoCalID(int(diffSkyFileID)))
     181
    166182           self.logger.infoPair("get filterID", diffSkyFileID)
    167183           self.filterID[num] = self.scratchDb.getFilterID(self.filterName[num][0])
     184
    168185           self.logger.infoPair("insertdiffmeta", diffSkyFileID)
    169186           self.logger.infoPair("insertdiffmeta", self.filterName[num][0])
    … …  
    171188           self.ippToPspsDb.insertDiffMeta(self.batchID, self.filterName[num][0], self.difftypeID[num])
    172189     
    173        # make some generic tables
    174            #sql = "CREATE TABLE DiffMeta_"+str(num)+" like DiffMeta"
    175            #try: self.scratchDb.execute(sql)
    176            #except: raise
    177            #sql = "CREATE TABLE DiffToImage_"+str(num)+" like DiffToImage"
    178            #try: self.scratchDb.execute(sql)
    179            #except: raise
    180            #sql = "CREATE TABLE DiffDetection_"+str(num)+" like DiffDetection"
    181            #try: self.scratchDb.execute(sql)
    182            #except: raise
    183 
    184 
    185 
    186190           num = num + 1
    187191
    188192       # create an output filename, which is {expID}.FITS
    189 
    190 
    191193       self.outputFitsFile = "%08d.FITS" % self.stageid
    192194       self.outputFitsPath = "%s/%s" % (self.localOutPath, self.outputFitsFile)
    193        
    194        
    195195
    196196       self.processingVersion = skychunk.processingVersion;
    197        
    198197
    199198       # dump stuff to log
    200199       self.logger.infoPair("stage_id", "%d" % self.stageid)
    201 
    202200
    203201    '''
    … …  
    257255    Populates the Diff table for this OTA
    258256    '''
    259     def populateDiffDetectionTable(self,num):
    260 
    261         pspsTableName = "DiffDetection_"+str(num)
    262         ippTableName =  "SkyChip_psf_"+str(num)
    263         diffSkyFileID = self.number[num]
    264         sql = "CREATE TABLE DiffDetection_"+str(num)+" like DiffDetection"
    265         try: self.scratchDb.execute(sql)
    266         except: raise
    267         #results['ORIGINALTOTAL'] = self.scratchDb.getRowCount(ippTableName)
    268 
    269         # drop then re-create table
    270         #self.scratchDb.dropTable(pspsTableName)
    271         #sql = "CREATE TABLE " + pspsTableName + " LIKE DiffDetection"
    272         #try: self.scratchDb.execute(sql)
    273         #except: pass
    274        
     257    def populateDiffDetectionTable(self, num, isPosFile):
     258
    275259        # XXX we no longer delete detections with funny mags (eg PSF_INST_MAG < -17.5)
    276260        # for examples of code which do this, go to r35097 or earlier
    277261
    278         BEFORE = self.scratchDb.getRowCount(ippTableName)
    279         #results['SATDET'] = 0
     262        if isPosFile:
     263            ippTableName =  "SkyChip_psf_"+str(num)
     264        else:
     265            ippTableName =  "SkyChip_psf_inv_"+str(num)
     266
     267        pspsTableName = "DiffDetection_" + str(num)
     268        diffSkyFileID = self.number[num]
     269
     270        if isPosFile:
     271            sql = "CREATE TABLE DiffDetection_" + str(num) + " like DiffDetection"
     272            self.scratchDb.execute(sql)
    280273
    281274        expTimeString = str(self.expTime[num])
    282 
    283         # insert all detections into table : do NOT include the IGNORE unless we have to
    284         # sqlLine = sqlUtility("INSERT IGNORE INTO " + pspsTableName + " (")
    285         sqlLine = sqlUtility("INSERT INTO " + pspsTableName + " (")
    286 
    287         # XXX WARNING: need to apply platescale to convert sizes to arcsec
    288         # XXX apFluxF or apFluxNpix + apFluxRadius?
    289 
    290         sqlLine.group("ippDetectID",     "IPP_IDET")
    291         sqlLine.group("diffImageID",     str(diffSkyFileID))
    292 
    293         sqlLine.group("randomDiffID",     "RAND("+str(self.batchID)+")")
    294         sqlLine.group("filterID",        str(self.filterID[num]))
    295         sqlLine.group("surveyID",        str(self.surveyID))
    296         sqlLine.group("skycellID",       str(self.skycellID[num]))
    297         sqlLine.group("expTime",         str(self.expTime[num]))
    298         sqlLine.group("obsTime",         str(self.obsTime[num]))
    299         sqlLine.group("xPos",            "X_PSF")
    300         sqlLine.group("yPos",            "Y_PSF")
    301         sqlLine.group("xPosErr",         "X_PSF_SIG")
    302         sqlLine.group("yPosErr",         "Y_PSF_SIG")
    303         if (self.id >= 982483):
    304             sqlLine.group("pltScale",        "PLTSCALE")
    305             sqlLine.group("posAngle",        "POSANGLE")
    306             sqlLine.group("raErr",           "X_PSF_SIG * abs(PLTSCALE)")
    307             sqlLine.group("decErr",          "Y_PSF_SIG * abs(PLTSCALE)")
     275        if isPosFile:
     276            fluxScaleStr = "1"
     277            detIDoffset = 0
    308278        else:
    309             sqlLine.group("pltScale",        "0.257")
    310             sqlLine.group("posAngle",        "-999")
    311             sqlLine.group("raErr",           "X_PSF_SIG * 0.25")
    312             sqlLine.group("decErr",          "Y_PSF_SIG * 0.25")
    313         sqlLine.group("DpsfFlux",         "PSF_INST_FLUX / " + expTimeString)
    314         sqlLine.group("DpsfFluxErr",      "PSF_INST_FLUX_SIG / " + expTimeString)
    315 
    316         if self.havePsfFwhm[num]:
    317             print "I have PSF_FWHM_MAJ, setting a value"
    318             sqlLine.group("DpsfMajorFWHM",    "PSF_FWHM_MAJ * abs(PLTSCALE)")
    319             sqlLine.group("DpsfMinorFWHM",    "PSF_FWHM_MIN * abs(PLTSCALE)")
    320             sqlLine.group("DpsfCore",         "PSF_CORE")
    321 
    322         if self.haveSrcPos[num]:
    323             print "I have SRC_CHIP_X, setting a value"
    324             sqlLine.group("xPosChip",          "SRC_CHIP_X")
    325             sqlLine.group("yPosChip",          "SRC_CHIP_Y")
    326             sqlLine.group("ccdID"   ,          "SRC_CHIP_NUM")
    327 
    328         sqlLine.group("DpsfTheta",        "PSF_THETA")
    329         sqlLine.group("DpsfQf",           "PSF_QF")
    330         sqlLine.group("DpsfQfPerfect",    "PSF_QF_PERFECT")
    331         sqlLine.group("DpsfChiSq",        "PSF_CHISQ")
    332         sqlLine.group("DpsfLikelihood",   "psfLikelihood(EXT_NSIGMA)")
    333         sqlLine.group("DmomentXX",        "MOMENTS_XX * PLTSCALE * PLTSCALE")
    334         sqlLine.group("DmomentXY",        "MOMENTS_XY * PLTSCALE * PLTSCALE")
    335         sqlLine.group("DmomentYY",        "MOMENTS_YY * PLTSCALE * PLTSCALE")
    336         sqlLine.group("DmomentR1",        "MOMENTS_R1 * abs(PLTSCALE)")
    337         sqlLine.group("DmomentRH",        "MOMENTS_RH * sqrt(abs(PLTSCALE))")
    338         if (self.id >= 982483):
    339             sqlLine.group("DapFlux",          "AP_FLUX / " + expTimeString)
    340             sqlLine.group("DapFluxErr",       "AP_FLUX_SIG / " + expTimeString)
    341 
    342         if self.haveApNpix[num]:
    343             sqlLine.group("DapFillF", "AP_NPIX / (3.14159265359 * AP_MAG_RADIUS * AP_MAG_RADIUS)")
    344         sqlLine.group("DkronFlux",        "KRON_FLUX / " + expTimeString)
    345         sqlLine.group("DkronFluxErr",     "KRON_FLUX_ERR / " + expTimeString)
    346         sqlLine.group("DkronRad",         "MOMENTS_R1 * 2.5 * abs(PLTSCALE)")
    347         sqlLine.group("diffNPos",         "DIFF_NPOS")
    348         sqlLine.group("diffFRatio",       "DIFF_FRATIO")
    349         sqlLine.group("diffNBad",         "DIFF_NRATIO_BAD")
    350         sqlLine.group("diffNMask",        "DIFF_NRATIO_MASK")
    351         sqlLine.group("diffNAll",         "DIFF_NRATIO_ALL")
    352         sqlLine.group("diffPdist",        "DIFF_R_P")
    353         sqlLine.group("diffNdist",        "DIFF_R_M")
    354         sqlLine.group("diffPSN",          "DIFF_SN_P")
    355         sqlLine.group("diffNSN",          "DIFF_SN_M")
    356         sqlLine.group("Dsky",             "SKY / PLTSCALE / PLTSCALE / " + expTimeString)
    357         sqlLine.group("DskyErr",          "SKY_SIGMA / PLTSCALE / PLTSCALE / " + expTimeString)
    358         sqlLine.group("DinfoFlag",        "FLAGS")
    359         sqlLine.group("DinfoFlag2",       "FLAGS2")
    360         sqlLine.group("processingVersion",     str(self.skychunk.processingVersion))                 
    361 
    362         sql = sqlLine.makeRaw(") SELECT ", " FROM " + ippTableName)
    363 
    364         try: self.scratchDb.execute(sql)
    365         except:
    366             self.logger.errorPair("failed sql: ", sql)
    367             raise
    368 
    369         # NOTE : Flux limits : in the current PSPS schema, negative fluxes
    370         # cause problems for sql queries which work in mags as SQL cannot do
    371         # something like (f < 0.0) ? -999 : -2.5*log10(f)
    372         # as a result, the negative fluxes here result in floating point errors
    373         # XXX EAM 2014072 : Is this still a problem?
    374  #       sql = "UPDATE " + pspsTableName + " SET psfFlux = 1e20 WHERE psfFlux <= 0.0"
    375  #       self.scratchDb.execute(sql)
    376        
    377  #       sql = "UPDATE " + pspsTableName + " SET apFlux = 1e20 WHERE apFlux <= 0.0"
    378  #       self.scratchDb.execute(sql)
    379 
    380  #       sql = "UPDATE " + pspsTableName + " SET kronFlux = 1e20 WHERE kronFlux <= 0.0"
    381  #       self.scratchDb.execute(sql)
    382 
    383         # we don't delete these anymore
    384         #results['NULLINSTFLUX'] = 0;
    385 
    386 
    387 # insert stuff from dvo
     279            fluxScaleStr = "-1"
     280            detIDoffset = self.posImageDetCount
     281
     282        if isPosFile or self.haveNegFits[num]:
     283
     284            # insert all detections into table : do NOT include the IGNORE unless we have to
     285            # sqlLine = sqlUtility("INSERT IGNORE INTO " + pspsTableName + " (")
     286            sqlLine = sqlUtility("INSERT INTO " + pspsTableName + " (")
     287           
     288            # XXX WARNING: need to apply platescale to convert sizes to arcsec
     289            # XXX apFluxF or apFluxNpix + apFluxRadius?
     290           
     291            sqlLine.group("ippDetectID",     "IPP_IDET + " + str(detIDoffset))
     292            sqlLine.group("diffImageID",     str(diffSkyFileID))
     293            sqlLine.group("fromPosImage",    str(isPosFile))
     294           
     295            sqlLine.group("randomDiffID",     "RAND("+str(self.batchID)+")")
     296            sqlLine.group("filterID",        str(self.filterID[num]))
     297            sqlLine.group("surveyID",        str(self.surveyID))
     298            sqlLine.group("skycellID",       str(self.skycellID[num]))
     299            sqlLine.group("expTime",         str(self.expTime[num]))
     300            sqlLine.group("obsTime",         str(self.obsTime[num]))
     301            sqlLine.group("xPos",            "X_PSF")
     302            sqlLine.group("yPos",            "Y_PSF")
     303            sqlLine.group("xPosErr",         "X_PSF_SIG")
     304            sqlLine.group("yPosErr",         "Y_PSF_SIG")
     305            if (self.id >= 982483):
     306                sqlLine.group("pltScale",        "PLTSCALE")
     307                sqlLine.group("posAngle",        "POSANGLE")
     308                sqlLine.group("raErr",           "X_PSF_SIG * abs(PLTSCALE)")
     309                sqlLine.group("decErr",          "Y_PSF_SIG * abs(PLTSCALE)")
     310            else:
     311                sqlLine.group("pltScale",        "0.257")
     312                sqlLine.group("posAngle",        "-999")
     313                sqlLine.group("raErr",           "X_PSF_SIG * 0.25")
     314                sqlLine.group("decErr",          "Y_PSF_SIG * 0.25")
     315                sqlLine.group("DpsfFlux",         "PSF_INST_FLUX / " + expTimeString + " * " + fluxScaleStr)
     316                sqlLine.group("DpsfFluxErr",      "PSF_INST_FLUX_SIG / " + expTimeString)
     317               
     318            if self.havePsfFwhm[num]:
     319                print "I have PSF_FWHM_MAJ, setting a value"
     320                sqlLine.group("DpsfMajorFWHM",    "PSF_FWHM_MAJ * abs(PLTSCALE)")
     321                sqlLine.group("DpsfMinorFWHM",    "PSF_FWHM_MIN * abs(PLTSCALE)")
     322                sqlLine.group("DpsfCore",         "PSF_CORE")
     323                   
     324            if self.haveSrcPos[num]:
     325                print "I have SRC_CHIP_X, setting a value"
     326                sqlLine.group("xPosChip",          "SRC_CHIP_X")
     327                sqlLine.group("yPosChip",          "SRC_CHIP_Y")
     328                sqlLine.group("ccdID"   ,          "SRC_CHIP_NUM")
     329                   
     330            sqlLine.group("DpsfTheta",        "PSF_THETA")
     331            sqlLine.group("DpsfQf",           "PSF_QF")
     332            sqlLine.group("DpsfQfPerfect",    "PSF_QF_PERFECT")
     333            sqlLine.group("DpsfChiSq",        "PSF_CHISQ")
     334            sqlLine.group("DpsfLikelihood",   "psfLikelihood(EXT_NSIGMA)")
     335            sqlLine.group("DmomentXX",        "MOMENTS_XX * PLTSCALE * PLTSCALE")
     336            sqlLine.group("DmomentXY",        "MOMENTS_XY * PLTSCALE * PLTSCALE")
     337            sqlLine.group("DmomentYY",        "MOMENTS_YY * PLTSCALE * PLTSCALE")
     338            sqlLine.group("DmomentR1",        "MOMENTS_R1 * abs(PLTSCALE)")
     339            sqlLine.group("DmomentRH",        "MOMENTS_RH * sqrt(abs(PLTSCALE))")
     340            if (self.id >= 982483):
     341                sqlLine.group("DapFlux",          "AP_FLUX / " + expTimeString + " * " + fluxScaleStr)
     342                sqlLine.group("DapFluxErr",       "AP_FLUX_SIG / " + expTimeString)
     343               
     344            if self.haveApNpix[num]:
     345                sqlLine.group("DapFillF", "AP_NPIX / (3.14159265359 * AP_MAG_RADIUS * AP_MAG_RADIUS)")
     346
     347            sqlLine.group("DkronFlux",        "KRON_FLUX / " + expTimeString + " * " + fluxScaleStr)
     348            sqlLine.group("DkronFluxErr",     "KRON_FLUX_ERR / " + expTimeString)
     349            sqlLine.group("DkronRad",         "MOMENTS_R1 * 2.5 * abs(PLTSCALE)")
     350            sqlLine.group("diffNPos",         "DIFF_NPOS")
     351            sqlLine.group("diffFPosRatio",    "DIFF_FRATIO")
     352            sqlLine.group("diffNPosRatio",    "DIFF_NRATIO_BAD")
     353            sqlLine.group("diffNPosMask",     "DIFF_NRATIO_MASK")
     354            sqlLine.group("diffNPosAll",      "DIFF_NRATIO_ALL")
     355            sqlLine.group("diffPosdist",      "DIFF_R_P")
     356            sqlLine.group("diffNegdist",      "DIFF_R_M")
     357            sqlLine.group("diffPosSN",        "DIFF_SN_P")
     358            sqlLine.group("diffNegSN",        "DIFF_SN_M")
     359            sqlLine.group("Dsky",             "SKY / PLTSCALE / PLTSCALE / " + expTimeString)
     360            sqlLine.group("DskyErr",          "SKY_SIGMA / PLTSCALE / PLTSCALE / " + expTimeString)
     361            sqlLine.group("DinfoFlag",        "FLAGS")
     362            sqlLine.group("DinfoFlag2",       "FLAGS2")
     363            sqlLine.group("processingVersion",     str(self.skychunk.processingVersion))                 
     364           
     365            sql = sqlLine.makeRaw(") SELECT ", " FROM " + ippTableName)
     366           
     367            self.scratchDb.execute(sql)
     368
     369        # XXX EAM 20151105 : Not sure how this must be modified to handle the inv data:
     370
     371        ## if we have a negative image (inv.cmf), do the ending chunk after loading the negative image data
     372        if isPosFile and self.haveNegFits[num]:
     373            return
     374
     375        # insert stuff from dvo
    388376        self.logger.infoPair("inserting dvo info:find imageID"," from externID")
    389377        imageID = self.scratchDb.getImageIDFromExternID(diffSkyFileID)
    390378        self.logger.infoPair("updating","diffdetection_"+str(num))
    391379        sqlLine  = sqlUtility("UPDATE DiffDetection_"+str(num)+" as a, " + self.scratchDb.dvoDetectionTable + " as b SET ")
    392         sqlLine.group("a.diffObjID", "b.objId")
    393         sqlLine.group("a.diffDetID", "b.detectID")
    394         sqlLine.group("a.ippObjID","b.ippObjID")
    395         sqlLine.group("a.dvoRegionID",             "b.catID")
    396         sqlLine.group("a.ra", "b.ra")
    397         sqlLine.group("a.dec", "b.dec_")
    398         sqlLine.group("a.raErr", "b.raErr")
    399         sqlLine.group("a.decErr", "b.decErr")
    400        
    401         sqlLine.group("a.zp","b.zp")
     380        sqlLine.group("a.diffObjID",   "b.objId")
     381        sqlLine.group("a.diffDetID",   "b.detectID")
     382        sqlLine.group("a.ippObjID",    "b.ippObjID")
     383        sqlLine.group("a.dvoRegionID", "b.catID")
     384        sqlLine.group("a.ra",          "b.ra")
     385        sqlLine.group("a.dec",         "b.dec_")
     386        sqlLine.group("a.raErr",       "b.raErr")   # NOTE: This is supplied above as well, is this needed??
     387        sqlLine.group("a.decErr",      "b.decErr") # NOTE: This is supplied above as well, is this needed??
     388        sqlLine.group("a.zp",          "b.zp")
    402389        sqlLine.group("a.telluricExt", "b.telluricExt")
    403         sqlLine.group("a.airmass","b.airmass")
    404 
     390        sqlLine.group("a.airmass",     "b.airmass")
    405391       
    406392        sql = sqlLine.makeEquals("WHERE a.ippDetectID = b.ippDetectID AND b.imageID = " +str( imageID))   
    … …  
    410396            self.logger.errorPair("failed sql:",sql)
    411397            raise
     398
    412399        self.logger.infoPair("need to cull"," nulls objid")
    413400        results= self.scratchDb.reportAndDeleteRowsWithNULLS("DiffDetection_"+str(num), "diffObjID")
    … …  
    529516
    530517        return True
    531 
    532 
    533 
    534 
    535518
    536519    '''
    … …  
    640623            self.logger.infoPair("populated","DiffToImage_"+str(num))
    641624            self.tablesToExport.append("DiffDetection_"+str(num))
    642             self.populateDiffDetectionTable(num)
     625            self.populateDiffDetectionTable(num, 1) # populate the positive image data
     626            self.populateDiffDetectionTable(num, 0) # populate the negative image data (if present)
    643627            self.logger.infoPair("populated","DiffDetection_"+str(num))
    644628            self.setMinMaxDiffObjID(["DiffDetection_"+str(num)])
    … …  
    647631            self.logger.infoPair("populated","DiffDetEffMeta_"+str(num))
    648632            # CZW: I appended to tablesToExport inside populateDiffDetEffMeta to be like stack.
     633
    649634        #test = self.scratchDb.getRowCount("Object")
    650635        #return False
    … …  
    682667        self.havePsfFwhm = {}
    683668        self.haveSrcPos = {}
     669        self.haveNegFits = {}
     670        self.posImageDetCount = 0
    684671
    685672        for num in self.number:
    686             diffSkyFileID = self.number[num]
    687             fileName = self.fits[num].getPath()
     673            fileNamePos = self.posFits[num].getPath()
    688674           
    689             self.logger.infoPair("using filename:",fileName)
     675            self.logger.infoPair("using filename:",fileNamePos)
    690676       
    691677            ## output table names need to have "_num" appended. 
    … …  
    697683
    698684            ## *** actually write the FITS data to mysql
    699             self.scratchDb.loadFITStoMYSQL(fileName, fitsOptions)
     685            self.scratchDb.loadFITStoMYSQL(fileNamePos, fitsOptions)
     686
     687            ## if we have a negative image (inv.cmf), load that as well:
     688            self.haveNegFits[num] = 0
     689            if not self.negFits[num] == None:
     690                fileNameNeg = self.negFits[num].getPath()
     691           
     692                self.logger.infoPair("using filename:", fileNameNeg)
     693       
     694                ## output table names need to have "_num" appended. 
     695                fitsOptions  = "-tablesuffix _inv_" + str(num)
     696
     697                # this option is equivalent to the stilts "addcol table_index $0" call
     698                fitsOptions += " -sequence-column table_index"
     699                fitsOptions += " -sequence-column-start 1"
     700
     701                ## *** actually write the FITS data to mysql
     702                self.scratchDb.loadFITStoMYSQL(fileNameNeg, fitsOptions)
     703                self.haveNegFits[num] = 1
     704
     705                posTableName = "SkyChip_psf_" + str(num)
     706                self.posImageDetCount = self.scratchDb.getRowCount(posTableName)
    700707
    701708            ## use stilts to get a list of the tables from the header
    702709            try:
    703                 tables = stilts.treads(fileName)
     710                tables = stilts.treads(fileNamePos)
    704711            except:
    705                 self.logger.errorPair("STILTS could not import from", fileName)
     712                self.logger.errorPair("STILTS could not import from", fileNamePos)
    706713                return False
    707714       
    … …  
    751758        for num in self.number:
    752759            diffSkyFileID = self.number[num]
    753             fileName = self.fits[num].getPath()
     760            fileName = self.posFits[num].getPath()
    754761           
    755762            self.logger.infoPair("using filename:",fileName)

  • trunk/ippToPsps/jython/gpc1db.py

    r39038 r39049  
    340340        return addIDs
    341341
    342 
    343 
    344 
    345 
    346 
    347 
    348 
    349342    '''
    350343    Gets some stack-stage meta data for this sky_id # TODO this SQL could surely be improved
    … …  
    408401               AND warp_skyfile_id = " +  str(warpSkyfileID)
    409402
    410         try:
    411             rs = self.executeQuery(sql)
    412             rs.first()
    413         except:
     403        rs = self.executeQuery(sql)
     404        if not rs.first():
    414405            self.logger.errorPair("Can't query for", "forced warp meta data")
     406            os._exit(3)
    415407
    416408        try:
    … …  
    435427        self.logger.debug("Querying GPC1 for diff meta data")
    436428
    437         meta = []
     429        meta = {}
     430
    438431        sql = "SELECT \
    439432               filter,\
    … …  
    442435               stack2, \
    443436               skycell_id, \
    444                diffRun.software_ver, \
     437               diffRun.software_ver as software_ver, \
    445438               exp_time, \
    446                (to_days(dateobs)-678941 + time_to_sec(dateobs)/86400.), \
     439               (to_days(dateobs)-678941 + time_to_sec(dateobs)/86400.) as obsTime, \
    447440               diffInputSkyfile.tess_id, \
    448441               exp_id \
    … …  
    454447               JOIN rawExp using (exp_id) \
    455448               WHERE diff_skyfile_id = %d" % diffSkyfileID
    456         #this is a crappy way to get the mjd from the diff but we don't save it anywhere       
    457         try:
    458             rs = self.executeQuery(sql)
    459             rs.first()
    460         except:
     449
     450        rs = self.executeQuery(sql)
     451        if not rs.first():
    461452            self.logger.infoPair ("this sql is broken:",sql)
    462453            self.logger.errorPair("Can't query for", "stack meta data")
     454            os._exit(3)
    463455           
    464456        try:
    465             meta.append(rs.getString(1))
    466             meta.append(rs.getString(2))
    467             meta.append(rs.getString(3))
    468             meta.append(rs.getString(4))
    469             meta.append(rs.getString(5))
    470             meta.append(rs.getString(6))
    471             meta.append(rs.getString(7))
    472             meta.append(rs.getString(8))
    473             meta.append(rs.getString(9))
    474             meta.append(rs.getString(10))
     457            meta['filter']       = rs.getString(1)
     458            meta['diff_mode']    = rs.getString(2)
     459            meta['warp1']        = rs.getString(3)
     460            meta['stack2']       = rs.getString(4)
     461            meta['skycell_id']   = rs.getString(5)
     462            meta['software_ver'] = rs.getString(6)
     463            meta['exp_time']     = rs.getString(7)
     464            meta['obsTime']      = rs.getString(8)
     465            meta['tess_id']      = rs.getString(9)
     466            meta['exp_id']       = rs.getString(10)
    475467
    476468        except:
    … …  
    515507       
    516508        if len(files) < 1: return None
     509        fits = Fits(self.logger, self.config, files[0])
     510        return fits
     511
     512    '''
     513    get diff stage cmf name
     514    '''
     515    def getDiffStagePathBase(self, dvoDb, diffSkyfileID):
     516        print "got here, diffstagecmf"
     517        sql = "SELECT DISTINCT diffSkyfile.path_base \
     518               FROM mergedvodbRun join minidvodbRun using (minidvodb_id) \
     519               JOIN addRun using (minidvodb_name) \
     520               JOIN diffInputSkyfile on (diff_skyfile_id = stage_extra1 \
     521               AND diff_id = stage_id AND stage = 'diff') \
     522               JOIN diffSkyfile using (diff_id, skycell_id, diff_skyfile_id) \
     523               WHERE diff_skyfile_id = " + str(diffSkyfileID) + " \
     524               AND minidvodbRun.state = 'merged' \
     525               AND mergedvodbRun.state = 'full' \
     526               AND mergedvodbRun.mergedvodb = '" + dvoDb + "' \
     527               AND stage = 'diff'"
     528
     529        rs = self.executeQuery(sql)
     530
     531        if not rs.first():
     532            self.logger.errorPair("missing cmf entry diff_skyfile_id:", str(diff_skyfile_id))
     533            # self.logger.errorPair("no diff cmfs found for diff_skyfile_id = %d" %diff_skyfile_id)
     534            return None
     535
     536        pathBase = rs.getString(1)
     537        return pathBase
     538
     539    '''
     540    get diff stage cmf name
     541    '''
     542    def getDiffStageCmfForPathBase(self, pathBase):
     543
     544        files = []
     545        if pathBase.startswith("neb"):
     546            self.logger.debugPair("searching for nebulous files", pathBase)
     547            f = os.popen("neb-ls -p " + pathBase + ".cmf")
     548            for i in f.readlines():
     549                self.logger.debugPair("real file", i.rstrip())
     550                files.append(i.rstrip())
     551        else:
     552            files = glob.glob(pathBase + ".cmf")
     553
     554        if len(files) < 1:
     555            self.logger.errorPair ("no cmf file found matching pathBase", pathBase + ".cmf")
     556            return None
     557
    517558        fits = Fits(self.logger, self.config, files[0])
    518559        return fits
Note: See TracChangeset for help on using the changeset viewer.