IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 6, 2011, 1:56:22 PM (15 years ago)
Author:
watersc1
Message:

merge from trunk before working on new stacking code

Location:
branches/czw_branch/20110406
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • branches/czw_branch/20110406

  • branches/czw_branch/20110406/ippToPsps/jython/stackbatch.py

    r31434 r31606  
    88from java.sql import *
    99
     10from batch import Batch
    1011from gpc1db import Gpc1Db
    11 from batch import Batch
     12from ipptopspsdb import IppToPspsDb
     13from scratchdb import ScratchDb
     14
    1215import logging.config
    1316
    … …  
    2023    Constructor
    2124    '''
    22     def __init__(self, logger, skyID, inputFile, stackType, useFullTables=False):
     25    def __init__(self,
     26                 logger,
     27                 gpc1Db,
     28                 ippToPspsDb,
     29                 scratchDb,
     30                 skyID,
     31                 inputFile,
     32                 stackType,
     33                 useFullTables=False):
     34
    2335       super(StackBatch, self).__init__(
    2436               logger,
     37               gpc1Db,
     38               ippToPspsDb,
     39               scratchDb,
     40               skyID,
    2541               "stack",
    2642               inputFile,
    … …  
    2844               useFullTables) # TODO
    2945
    30        self.logger.info("StackBatch constructor. Creating batch from: '" + inputFile + "'")
    31 
    32        self.skyID = skyID
    33 
    34        # get filterID using init table
    35        self.filter = self.header['FPA.FILTER']
    36        self.filter = self.filter[0:1]
    37 
    38        self.stackType = stackType
    39        meta = self.gpc1Db.getStackStageMeta(self.skyID, self.header['FPA.FILTER'])
    40        if len(meta) < 1: return
    41        self.stackID = meta[0];
    42        self.skycell = meta[1];
    43 
    44        # determine skycell from header value
    45        #self.skycell = "skycell.34" #= self.header['SKYCELL']
    46        self.skycell = self.skycell[8:]
    47 
    48        self.logger.info("Processing stack with ID: %d, type: %s and skycell: %s filter: %s" % (self.stackID, self.stackType, self.skycell, self.filter))
    49 
     46       if not self.everythingOK: return
     47
     48       self.expTime = gpc1Db.getStackExpTime(self.stackID)
     49
     50       self.logger.info("got exp time of %d" % self.expTime)
     51
     52       # meta data to the log
     53       self.logger.info("New Stack Batch:")
     54       self.logger.info("Sky ID:     %d" % self.id)
     55       self.logger.info("File:       %s" % inputFile)
     56       self.logger.info("Stack ID:   %d" % self.stackID)
     57       self.logger.info("Stack type: %s" % self.stackType)
     58       self.logger.info("Skycell:    %s" % self.skycell)
     59       self.logger.info("Filter:     %s" % self.filter)
    5060
    5161       # delete PSPS tables
    … …  
    5868       self.scratchDb.dropTable("ObjectCalColor")
    5969
    60        # delete IPP tables
    61        #self.scratchDb.dropTable("SkyChip_psf")
    62        #self.scratchDb.dropTable("SkyChip_xsrc")
    63        #self.scratchDb.dropTable("SkyChip_xfit")
    64        #self.scratchDb.dropTable("SkyChip_xrad")
    65 
    66        self.logger.info("Stack type: " + self.safeDictionaryAccess(self.header, self.stackType))
    67        # obs time makes no sense except for nightly stacks
    68        #if self.header['STK_TYPE'] != "NIGHTLY_STACK": self.header['MJD-OBS'] = "-999"
    69 
    7070       # create an output filename, which is {filterID}{skycellID}.FITS
    71        self.outputFitsFile = "%s%07d.FITS" % (self.filter, int(self.skycell))
     71       self.outputFitsFile = "%08d.FITS" % self.stackID
    7272       self.outputFitsPath = "%s/%s" % (self.localOutPath, self.outputFitsFile)
    7373
    … …  
    7777
    7878       # insert what we know about this stack batch into the stack table
    79        self.ippToPspsDb.insertStackMeta(self.batchID, self.skyID, self.stackID, self.filter, self.stackType)
     79       self.ippToPspsDb.insertStackMeta(self.batchID, self.id, self.stackID, self.filter, self.stackType)
    8080
    8181       # insert sourceID/imageID combo so DVO can look it up
    … …  
    8989
    9090        sql = "UPDATE " + table + "  SET stackMetaID=" + str(self.stackID)
    91         self.scratchDb.stmt.execute(sql)
     91        self.scratchDb.execute(sql)
    9292
    9393    '''
    … …  
    9797
    9898        sql = "UPDATE "+table+" AS a, StackType AS b SET a.stackTypeID=b.stackTypeID WHERE b.name = '" + self.stackType + "'"
    99         self.scratchDb.stmt.execute(sql)
     99        self.scratchDb.execute(sql)
    100100
    101101
    … …  
    148148        WHERE a.ippDetectID=b.IPP_IDET AND b.PSF_FWHM "+psfCondition
    149149
    150         self.scratchDb.stmt.execute(sql)
     150        self.scratchDb.execute(sql)
    151151
    152152    '''
    … …  
    196196        WHERE a.ippDetectID=b.IPP_IDET AND b.MODEL_TYPE = '"+ippModelType+"'"
    197197
    198         self.scratchDb.stmt.execute(sql)
     198        self.scratchDb.execute(sql)
    199199
    200200        # sersic fit has an extra parameter
    … …  
    213213            WHERE a.ippDetectID=b.IPP_IDET AND b.MODEL_TYPE = '"+ippModelType+"'"
    214214
    215             self.scratchDb.stmt.execute(sql)
     215            self.scratchDb.execute(sql)
    216216
    217217
    … …  
    220220    '''
    221221    def populateStackMeta(self):
     222
    222223        self.logger.info("Procesing StackMeta table")
    223224
    … …  
    246247        ," + str(self.scratchDb.getPhotoCalID(self.header['SOURCEID'], self.header['IMAGEID'])) + " \
    247248        ," + self.header['FPA.ZP'] + " \
    248         ," + self.header['EXPTIME'] + " \
     249        ," + str(self.expTime) + " \
    249250        ,'" + self.safeDictionaryAccess(self.header, 'PSFMODEL') + "' \
    250251        ,'" + self.header['CTYPE1'] + "' \
    … …  
    261262        ," + self.header['PC002002'] + " \
    262263        )"
    263         self.scratchDb.stmt.execute(sql)
     264        self.scratchDb.execute(sql)
    264265
    265266        self.scratchDb.updateAllRows("StackMeta", "surveyID", str(self.surveyID))
    … …  
    272273    '''
    273274    def populateStackDetection(self):
     275
    274276        self.logger.info("Procesing StackDetection table")
    275277
    … …  
    321323               ,X_PSF_SIG \
    322324               ,Y_PSF_SIG \
    323                ,POW(10.0, (-0.4*PSF_INST_MAG)) / "+self.header['EXPTIME']+" \
    324                ,ABS((PSF_INST_MAG_SIG*(POW(10.0, (-0.4*PSF_INST_MAG)) / "+self.header['EXPTIME']+")) / 1.085736) \
    325                ,POW(10.0, (-0.4*PEAK_FLUX_AS_MAG)) / "+self.header['EXPTIME']+" \
     325               ,POW(10.0, (-0.4*PSF_INST_MAG)) / "+str(self.expTime)+" \
     326               ,ABS((PSF_INST_MAG_SIG*(POW(10.0, (-0.4*PSF_INST_MAG)) / "+str(self.expTime)+")) / 1.085736) \
     327               ,POW(10.0, (-0.4*PEAK_FLUX_AS_MAG)) / "+str(self.expTime)+" \
    326328               ,SKY \
    327329               ,SKY_SIGMA \
    … …  
    352354               FROM SkyChip_psf"
    353355
    354         self.scratchDb.stmt.execute(sql)
     356        self.scratchDb.execute(sql)
    355357
    356358        self.scratchDb.updateAllRows("StackDetection", "surveyID", str(self.surveyID))
    … …  
    362364        self.updateStackTypeID("StackDetection")
    363365        self.updateDvoIDs("StackDetection")
    364 
    365         # now delete bad flux
     366        sql = "ALTER TABLE StackDetection ADD PRIMARY KEY (objID, stackDetectID)"
     367        self.scratchDb.execute(sql)
     368
     369        if self.stackType == "DEEP_STACK":
     370
     371            #if deep stack and instFlux = null and err not null
     372            sql = "UPDATE StackDetection AS a, SkyChip_psf AS b \
     373                   SET instFlux = 2*b.PSF_INST_FLUX_SIG \
     374                   WHERE instFlux IS NULL \
     375                   AND b.PSF_INST_FLUX_SIG IS NOT NULL"
     376            self.scratchDb.execute(sql)
     377            #    instFlux = 2*PSF_INST_FLUX_SIG
     378           
    366379        self.scratchDb.reportAndDeleteRowsWithNULLS("StackDetection", "instFlux")
    367380        self.scratchDb.reportAndDeleteRowsWithNULLS("StackDetection", "objID")
    … …  
    372385    '''
    373386    def populateStackApFlx(self):
     387
    374388        self.logger.info("Procesing StackApFlx table")
    375389 
    … …  
    381395
    382396        try:
    383             self.scratchDb.stmt.execute(sql)
     397            self.scratchDb.execute(sql)
    384398        except: return
    385399
    386400        # TODO temporarily loading 1st convolved fluxes into unconvolved fields
    387         self.logger.info("    Adding un-convolved fluxes")
     401        self.logger.info("Adding un-convolved fluxes")
    388402        self.updateApFlxs("", "< 7.0")
    389         self.logger.info("    Adding 1st convolved fluxes")
     403        self.logger.info("Adding 1st convolved fluxes")
    390404        self.updateApFlxs("c1", "< 7.0")
    391         self.logger.info("    Adding 2nd convolved fluxes")
     405        self.logger.info("Adding 2nd convolved fluxes")
    392406        self.updateApFlxs("c2", "> 7.0")
    393407
    394         self.logger.info("    Adding petrosians for extended sources")
     408        self.logger.info("Adding petrosians for extended sources")
    395409        sql = "UPDATE StackApFlx AS a, SkyChip_xsrc AS b SET \
    396410        petRadius=b.PETRO_RADIUS \
    … …  
    403417        ,petR90Err=b.PETRO_RADIUS_90_ERR \
    404418        WHERE a.ippDetectID=b.IPP_IDET"
    405         self.scratchDb.stmt.execute(sql)
     419        self.scratchDb.execute(sql)
    406420
    407421        self.scratchDb.updateAllRows("StackApFlx", "surveyID", str(self.surveyID))
    … …  
    413427        self.updateStackTypeID("StackApFlx")
    414428        self.updateDvoIDs("StackApFlx")
     429        self.scratchDb.reportAndDeleteRowsWithNULLS("StackApFlx", "objID")
     430        self.deleteDetectionsNotInStackDetection("StackApFlx")
     431
    415432
    416433    '''
    … …  
    418435    '''
    419436    def populateStackModelFit(self):
     437
    420438        self.logger.info("Procesing StackModelFit table")
    421439
    … …  
    423441        sql = "INSERT INTO StackModelFit (ippDetectID) SELECT DISTINCT IPP_IDET from SkyChip_xfit"
    424442        try:
    425             self.scratchDb.stmt.execute(sql)
     443            self.scratchDb.execute(sql)
    426444        except:
    427445            return
    428446
    429 
    430447        # populate model parameters
    431         self.logger.info("    Adding deVaucouleurs fit")
     448        self.logger.info("Adding deVaucouleurs fit")
    432449        self.updateModelFit("deV", "PS_MODEL_DEV")
    433         self.logger.info("    Adding exponential fit")
     450        self.logger.info("Adding exponential fit")
    434451        self.updateModelFit("exp", "PS_MODEL_EXP")
    435         self.logger.info("    Adding sersic fit")
     452        self.logger.info("Adding sersic fit")
    436453        self.updateModelFit("ser", "PS_MODEL_SERSIC")
    437454
    … …  
    444461        self.updateStackTypeID("StackModelFit")
    445462        self.updateDvoIDs("StackModelFit")
     463        self.scratchDb.reportAndDeleteRowsWithNULLS("StackModelFit", "objID")
     464        self.deleteDetectionsNotInStackDetection("StackModelFit")
     465
     466    '''
     467    Reports and deletes detections in this table that are not in StackDetection
     468    '''
     469    def deleteDetectionsNotInStackDetection(self, table):
     470
     471        sql = "SELECT COUNT(*) FROM " + table + " WHERE ippDetectID NOT IN (SELECT ippDetectID FROM StackDetection)"
     472        rs = self.scratchDb.executeQuery(sql)
     473        rs.first()
     474        nMissing = rs.getInt(1)
     475        self.logger.info("%5d detections in %s table that are not in StackDetection. Deleting" % (nMissing, table))
     476 
     477        if nMissing < 1: return
     478       
     479        sql = "DELETE FROM " + table + " WHERE ippDetectID NOT IN (SELECT ippDetectID FROM StackDetection)"
     480        self.scratchDb.execute(sql)
     481       
    446482
    447483    '''
    … …  
    449485    '''
    450486    def populateStackToImage(self):
     487
    451488        self.logger.info("Procesing StackToImage table")
    452489
    … …  
    457494                   VALUES (\
    458495                   " + str(self.stackID) + ", " + imageID + ")"
    459             self.scratchDb.stmt.execute(sql)
     496            self.scratchDb.execute(sql)
    460497
    461498        # now update StackMeta with correct number of inputs
    462499        sql = "UPDATE StackMeta SET nP2Images = (SELECT COUNT(*) FROM StackToImage)"
    463         self.scratchDb.stmt.execute(sql)
     500        self.scratchDb.execute(sql)
    464501
    465502    '''
    … …  
    467504    '''
    468505    def populateSkinnyObject(self):
     506
    469507        self.logger.info("Procesing SkinnyObject table")
    470508
    … …  
    474512               ) \
    475513               SELECT \
    476                objID \
     514               DISTINCT objID \
    477515               ,ippObjID \
    478516               FROM StackDetection"
    479         self.scratchDb.stmt.execute(sql)
     517        self.scratchDb.execute(sql)
    480518
    481519        self.scratchDb.updateAllRows("SkinnyObject", "surveyID", str(self.surveyID))
    … …  
    486524    '''
    487525    def populateObjectCalColor(self):
     526
    488527        self.logger.info("Procesing ObjectCalColor table")
    489528
    … …  
    493532               ) \
    494533               SELECT \
    495                objID \
     534               DISTINCT objID \
    496535               ,ippObjID \
    497536               FROM StackDetection"
    498         self.scratchDb.stmt.execute(sql)
     537        self.scratchDb.execute(sql)
    499538
    500539        self.scratchDb.updateFilterID("ObjectCalColor", self.filter)
    … …  
    508547
    509548        self.logger.info("Altering PSPS tables")
    510         self.scratchDb.makeColumnUnique("StackDetection", "objID")
     549        #self.scratchDb.makeColumnUnique("StackDetection", "objID")
    511550        self.scratchDb.createIndex("StackDetection", "ippDetectID")
    512551        self.scratchDb.createIndex("StackApFlx", "ippDetectID")
    … …  
    531570        imageID = self.scratchDb.getImageIDFromExternID(self.header['SOURCEID'], self.header['IMAGEID'])
    532571
    533         self.logger.info("Updating table '" + table + "' with DVO IDs...")
     572        self.logger.debug("Updating table '" + table + "' with DVO IDs...")
    534573        sql = "UPDATE IGNORE " + table + " AS a, dvoDetectionFull AS b SET \
    535574               a.ippObjID = b.ippObjID, \
    … …  
    539578               AND b.sourceID = " + self.header['SOURCEID'] + "\
    540579               AND b.imageID = " + str(imageID)
    541         self.scratchDb.stmt.execute(sql)
    542 
     580        self.scratchDb.execute(sql)
    543581
    544582    '''
    … …  
    553591        self.populateStackMeta()
    554592        self.populateStackDetection()
    555         self.populateStackModelFit()
    556         self.populateStackApFlx()
     593
     594        if self.stackType != "NIGHTLY_STACK":
     595            self.populateStackModelFit()
     596            self.populateStackApFlx()
     597   
    557598        self.populateStackToImage()
    558599        self.populateSkinnyObject()
    … …  
    560601
    561602        self.setMinMaxObjID(["StackDetection"])
    562        
     603       
     604        if self.totalDetections < 1:
     605
     606            self.logger.error("No detections to publish")
     607            return False
     608
    563609        return True
    564610
    … …  
    568614    def alreadyProcessed(self):
    569615
    570         return self.ippToPspsDb.alreadyProcessed("stack", "stack_id", self.stackID)
     616        # sadly, we have to read the FITS primary header first
     617        if not self.readPrimaryHeader(): return False
     618
     619        # get filterID using init table
     620        self.filter = self.header['FPA.FILTER']
     621        self.filter = self.filter[0:1]
     622
     623        self.stackType = stackType
     624        meta = self.gpc1Db.getStackStageMeta(self.id, self.header['FPA.FILTER'])
     625        if len(meta) < 1: return False
     626        self.stackID = meta[0];
     627        self.skycell = meta[1];
     628        self.skycell = self.skycell[8:]
     629
     630        #return self.ippToPspsDb.alreadyProcessed("stack", "stack_id", self.stackID)
     631        return False # TODOI
     632
     633
     634useFullTables=True
    571635
    572636logging.config.fileConfig("logging.conf")
    573637logger = logging.getLogger("stackbatch")
     638logger.setLevel(logging.INFO)
    574639logger.info("Starting")
     640
    575641gpc1Db = Gpc1Db(logger)
    576 stackType = "NIGHTLY_STACK"
    577 skyIDs = gpc1Db.getIDsInThisDVODbForThisStage("MD04.Staticsky", "staticsky")
    578 #skyIDs = gpc1Db.getIDsInThisDVODbForThisStage("MD04.GENE.PSPSDEEP", "staticsky")
    579 #stackType = "DEEP_STACK"
    580 #skyIDs = [689]
     642ippToPspsDb = IppToPspsDb(logger)
     643scratchDb = ScratchDb(logger, useFullTables)
     644
     645#stackType = "NIGHTLY_STACK"
     646#skyIDs = gpc1Db.getIDsInThisDVODbForThisStageFudge()
     647#skyIDs = gpc1Db.getIDsInThisDVODbForThisStage("MD04.Staticsky", "staticsky")
     648
     649stackType = "DEEP_STACK"
     650skyIDs = gpc1Db.getIDsInThisDVODbForThisStage("MD04.GENE.PSPSDEEP", "staticsky")
     651
     652#skyIDs = [942]
    581653#skyIDs = [299]
    582654#skyIDs = [302]
    583655#skyIDs = [8508]
    584 i = 0
     656#i = 0
    585657for skyID in skyIDs:
    586 
    587     logger.info("-------------------------------------------------- sky ID: %d" % skyID)
     658   
     659    #if skyID < 1340: continue # nightly
     660    #if skyID < 238: continue # deep
    588661
    589662    cmfFiles = gpc1Db.getStackStageCmfs(skyID)
    … …  
    591664    for file in cmfFiles:
    592665
    593         if not os.path.isfile(file):
    594             logger.error("Cannot read file at '" + file)
    595             continue
    596 
    597         stackBatch = StackBatch(logger, skyID, file, stackType, True)
    598 
    599         if not stackBatch.alreadyProcessed():
    600 
    601             stackBatch.createEmptyPspsTables()
    602             stackBatch.importIppTables("")
    603             if stackBatch.populatePspsTables():
    604  
    605                 #stackBatch.reportNullsInAllPspsTables(False)
    606                 stackBatch.exportPspsTablesToFits()
    607                 stackBatch.writeBatchManifest()
    608                 #stackBatch.createTarball()
    609                 #stackBatch.publishToDatastore()
    610 
    611                 i = i + 1
    612                 #if i > 0: sys.exit()
    613 
    614 logger.info("Finished")
     666        stackBatch = StackBatch(logger,
     667                                gpc1Db,
     668                                ippToPspsDb,
     669                                scratchDb,
     670                                skyID,
     671                                file,
     672                                stackType,
     673                                useFullTables)
     674
     675        stackBatch.run()
     676
Note: See TracChangeset for help on using the changeset viewer.