IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jul 31, 2014, 10:59:37 AM (12 years ago)
Author:
eugene
Message:

adding stack mags to dvopsps detection output; adding option to reset the dvoDetections table; adding makeEquals to sqlUtilities; intelligently(?) select photcode ranges for dvopsps; massive re-work of stackbatch.py

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20140717/ippToPsps/jython/stackbatch.py

    r37138 r37156  
    1717from ipptopspsdb import IppToPspsDb
    1818from scratchdb import ScratchDb
     19from sqlUtility import sqlUtility
    1920
    2021import logging.config
    … …  
    5455
    5556       self.stackType = "DEEP_STACK" # TODO
    56        ## = stuff I commented out for pv2 stacks
    5757       
    58        #heather tasks
    59 
    60        # get a list of stackIDs
    61        self.logger.infoPair ("getting stackID for: ","g.00000")
    62        gstackID = gpc1Db.getStackIDFromSkyIDAndFilter( skychunk.dvoLabel, skyID, "g.00000")
    63        self.logger.infoPair ("getting stackID for: ","r.00000")
    64        rstackID = gpc1Db.getStackIDFromSkyIDAndFilter( skychunk.dvoLabel, skyID, "r.00000")
    65        self.logger.infoPair ("getting stackID for: ","i.00000")
    66        istackID = gpc1Db.getStackIDFromSkyIDAndFilter( skychunk.dvoLabel, skyID, "i.00000")
    67        self.logger.infoPair ("getting stackID for: ","z.00000")
    68        zstackID = gpc1Db.getStackIDFromSkyIDAndFilter( skychunk.dvoLabel, skyID, "z.00000")
    69        self.logger.infoPair ("getting stackID for: ","y.00000")
    70        ystackID = gpc1Db.getStackIDFromSkyIDAndFilter( skychunk.dvoLabel, skyID, "y.00000")
    71  #      self.logger.infoPair("g stackID ",gstackID)       
    72  #      self.logger.infoPair("r stackID ",rstackID)
    73  #      self.logger.infoPair("i stackID ",istackID)
    74  #      self.logger.infoPair("z stackID ",zstackID)
    75  #      self.logger.infoPair("y stackID ",ystackID)
    76  #      raise
    77        # from each stack, get fits name from getStackStageCmf
    78        if gstackID > 0:
    79            self.logger.infoPair ("finding fits file for: ","g.00000")
    80            gfits = gpc1Db.getStackStageCmf(skychunk.dvoLabel, gstackID)
    81            self.gfits = gfits
    82        if rstackID > 0:   
    83            self.logger.infoPair ("finding fits file for: ","r.00000")
    84            rfits = gpc1Db.getStackStageCmf(skychunk.dvoLabel, rstackID)
    85            self.rfits = rfits
    86        if istackID > 0:   
    87            self.logger.infoPair ("finding fits file for: ","i.00000")
    88            ifits = gpc1Db.getStackStageCmf(skychunk.dvoLabel, istackID)
    89            self.ifits = ifits
    90        if zstackID > 0:   
    91            self.logger.infoPair ("finding fits file for: ","z.00000")
    92            zfits = gpc1Db.getStackStageCmf(skychunk.dvoLabel, zstackID)
    93            self.zfits = zfits
    94        if ystackID > 0:   
    95            self.logger.infoPair ("finding fits file for: ","y.00000")
    96            yfits = gpc1Db.getStackStageCmf(skychunk.dvoLabel, ystackID)
    97            self.yfits = yfits
    98 
    99        #from each of those get self.gheader, self.rheader, etc.
    100        if gstackID > 0:   
    101            if gfits:
    102                gheader = gfits.getPrimaryHeader()
    103                if not gheader:
    104                    self.logger.errorPair("could not read FITS PHU for ",gstackID)
    105                    raise
    106                self.gheader = gheader
    107        if rstackID > 0:       
    108            if rfits:
    109                rheader = rfits.getPrimaryHeader()
    110                if not rheader:
    111                    self.logger.errorPair("could not read FITS PHU for ",rstackID)
    112                    raise
    113                self.rheader = rheader
    114        if istackID > 0:       
    115            if ifits:
    116                iheader = ifits.getPrimaryHeader()
    117                if not iheader:
    118                    self.logger.errorPair("could not read FITS PHU for ",istackID)
    119                    raise
    120                self.iheader = iheader
    121        if zstackID > 0:
    122            if zfits:
    123                zheader = zfits.getPrimaryHeader()
    124                if not zheader:
    125                    self.logger.errorPair("could not read FITS PHU for ",zstackID)
    126                    raise
    127                self.zheader = zheader
    128        if ystackID > 0:
    129            if yfits:
    130                yheader = yfits.getPrimaryHeader()
    131                if not yheader:
    132                    self.logger.errorPair("could not read FITS PHU for ",ystackID)
    133                    raise
    134                self.yheader = yheader
    135        # get stack meta data
    136        self.gstackID = gstackID
    137        self.rstackID = rstackID
    138        self.istackID = istackID     
    139        self.zstackID = zstackID
    140        self.ystackID = ystackID
    141 
    142        metastackid = -999
    143        if gstackID > 0: metastackid = gstackID
    144        if rstackID > 0: metastackid = rstackID
    145        if istackID > 0: metastackid = istackID   
    146        if zstackID > 0: metastackid = zstackID
    147        if ystackID > 0: metastackid = ystackID
    148 
    149        #there is probably a better way to do this
    150        if metastackid < 0:
     58       self.filters = ['g', 'r', 'i', 'z', 'y']
     59       self.stackIDs = {}
     60       self.imageIDs = {}
     61       self.fits = {}
     62       self.headerSet = {}
     63
     64       # we have two sets of imageIDs here:
     65
     66       # stackID : this is the id from the gpc1 stack table and (should) match the
     67       # cmf header keyword 'IMAGEID', this is also called EXTERN_ID in dvoImagesTable
     68       
     69       # imageID : this is the DVO-internal image ID for the stack cmf, and is called
     70       # IMAGE_ID in dvoImagesTable
     71
     72       # we just need one stack ID to get the generic metadata
     73       metastackID = -999
     74
     75       # get a list of stackIDs, identify the CMFs, read the headers:
     76       for filter in self.filters:
     77           filterName = filter + ".00000"
     78
     79           self.logger.infoPair ("getting stackID for: ", filterName)
     80           stackID = gpc1Db.getStackIDFromSkyIDAndFilter(skychunk.dvoLabel, skyID, filterName)
     81           self.stackIDs[filter] = stackID
     82
     83           if (stackID <= 0):
     84               continue
     85               
     86           metastackID = stackID
     87
     88           # from each stack, get fits name from getStackStageCmf
     89           self.logger.infoPair ("finding fits file for: ", filterName)
     90           self.fits[filter] = gpc1Db.getStackStageCmf(skychunk.dvoLabel, stackID)
     91           if not self.fits[filter]:
     92               self.logger.errorPair("could not find cmf file name for ", stackID)
     93               raise
     94
     95           header = self.fits[filter].getPrimaryHeader()
     96           if not header:
     97               self.logger.errorPair("could not read FITS PHU for ", stackID)
     98               raise
     99
     100           self.headerSet[filter] = header
     101
     102           self.logger.infoPair(filter + " stackID = ", stackID)       
     103
     104           if not (str(stackID) == header['IMAGEID']):
     105               self.logger.errorPair("inconsistency: header IMAGEID does not match stackID", stackID + " vs " + header['IMAGEID'])
     106               raise
     107
     108           print "2"
     109
     110           imageID = self.scratchDb.getImageIDFromExternID(stackID)
     111           self.logger.infoPair(filter + " imageID = ", imageID)       
     112           self.imageIDs[filter] = imageID
     113
     114           print "3"
     115
     116       # did we find any valid stacks?
     117       if metastackID < 0:
    151118           self.logger.errorPair("can't find any stack ids...?? ","??")
    152119           raise
    153120   
    154        meta = self.gpc1Db.getStackStageMeta(metastackid) 
    155        ## this should be ok - it takes a stack_id and returns filter/skycell etc.
     121       # using the given stack ID, get the generic information: filter, skycell, etc.
     122       meta = self.gpc1Db.getStackStageMeta(metastackID) 
    156123
    157124       if not meta:
    158            self.logger.errorPair("Could not get stack", "metadata")
     125           self.logger.errorPair("Could not get stack metadata for", metastackID)
    159126           raise
    160127
    161        #self.filter = meta[0];
    162        #self.filter = self.filter[0:1]
    163        #self.filterID = self.scratchDb.getFilterID(self.filter)
    164        self.skycell = meta[1];
    165 
    166        # self.testprint()
    167 
     128       fullSkycell = meta[1];
     129
     130       # XXX EAM 20140729 : review and fix skycell vs projection cell ID
    168131       # skycell is, eg "skycell.1133.081"
    169132       # we need 1133.081 for skycell, but store as an int, so instead store 1133081
    170133       # projection cell is just the 1133 bit
    171134
    172        # This Is how it should be done
    173135       #self.projectioncell = self.skycell[8:12]
    174136       #self.skycell = self.skycell[8:]
    … …  
    177139
    178140       # TODO this is the wrong way, but is consistent with SkyCell table in IN data
    179        self.skycell = self.skycell[8:]
    180        self.projectioncell = self.skycell
    181 
    182        # self.testprint()
     141       self.skycell = fullSkycell[8:]
     142       self.projectioncell = fullSkycell
     143
     144       # XXX need to set this somewhere else, but where??
     145       self.dvoRegionID = 1
    183146
    184147       # proposed new values. Need to coordinate with the SkyCell table
    … …  
    188151       self.analysisVer = meta[2];
    189152
    190        #self.expTime = gpc1Db.getStackExpTime(self.id)
    191        
    192153       # delete PSPS tables
    193        self.logger.infoPair("dropping table:","gStackMeta")
    194        self.scratchDb.dropTable("gStackMeta")
    195        self.logger.infoPair("dropping table:","rStackMeta")
    196        self.scratchDb.dropTable("rStackMeta")
    197        self.logger.infoPair("dropping table:","iStackMeta")
    198        self.scratchDb.dropTable("iStackMeta")
    199        self.logger.infoPair("dropping table:","zStackMeta")
    200        self.scratchDb.dropTable("zStackMeta")
    201        self.logger.infoPair("dropping table:","yStackMeta")
    202        self.scratchDb.dropTable("yStackMeta")
    203        self.logger.infoPair("dropping table:","StackObject")
    204 
    205        self.scratchDb.dropTable("StackObject")
    206        self.logger.infoPair("dropping table:","StackModelFit")
    207        self.scratchDb.dropTable("SkinnyObject")
    208        self.scratchDb.dropTable("StackModelFit")
    209        self.logger.infoPair("dropping table:","StackApFlx")
    210 
    211        self.scratchDb.dropTable("StackApFlx")
    212        self.logger.infoPair("dropping table:","StackToImage")
    213 
    214        self.scratchDb.dropTable("StackToImage")
    215        # self.testprint()
    216 
    217        # for PV2 we will have (grizy) of stack meta and skychip     
     154       for filter in self.filters:
     155           tableName = filter + "StackMeta"
     156           self.dropTableVerbose(tableName)
     157
     158       self.dropTableVerbose("StackObjectThin")
     159       self.dropTableVerbose("StackObjectExtra")
     160
     161       self.dropTableVerbose("StackApFlx")
     162
     163       self.dropTableVerbose("StackModelFitThin")
     164       self.dropTableVerbose("StackModelFitDeV")
     165       self.dropTableVerbose("StackModelFitExp")
     166       self.dropTableVerbose("StackModelFitSer")
     167       self.dropTableVerbose("StackModelFitPet")
     168       self.dropTableVerbose("StackModelFitFlx")
     169       self.dropTableVerbose("StackModelFitFlxC1")
     170       self.dropTableVerbose("StackModelFitFlxC2")
     171
     172       self.dropTableVerbose("StackToImage")
    218173
    219174       # delete IPP tables
    220        self.scratchDb.dropTable("gSkyChip_psf")
    221        self.scratchDb.dropTable("gSkyChip_xrad")
    222        self.scratchDb.dropTable("gSkyChip_xfit")
    223        self.scratchDb.dropTable("gSkyChip_xsrc")
    224        self.scratchDb.dropTable("rSkyChip_psf")
    225        self.scratchDb.dropTable("rSkyChip_xrad")
    226        self.scratchDb.dropTable("rSkyChip_xfit")
    227        self.scratchDb.dropTable("rSkyChip_xsrc")
    228        self.scratchDb.dropTable("iSkyChip_psf")
    229        self.scratchDb.dropTable("iSkyChip_xrad")
    230        self.scratchDb.dropTable("iSkyChip_xfit")
    231        self.scratchDb.dropTable("iSkyChip_xsrc")
    232        self.scratchDb.dropTable("zSkyChip_psf")
    233        self.scratchDb.dropTable("zSkyChip_xrad")
    234        self.scratchDb.dropTable("zSkyChip_xfit")
    235        self.scratchDb.dropTable("zSkyChip_xsrc")
    236        self.scratchDb.dropTable("ySkyChip_psf")
    237        self.scratchDb.dropTable("ySkyChip_xrad")
    238        self.scratchDb.dropTable("ySkyChip_xfit")
    239        self.scratchDb.dropTable("ySkyChip_xsrc")
     175       self.logger.info("dropping Stack cmf tables")
     176       for filter in self.filters:
     177           tableName = filter + "SkyChip_psf"
     178           self.scratchDb.dropTable(tableName)
     179           tableName = filter + "SkyChip_xrad"
     180           self.scratchDb.dropTable(tableName)
     181           tableName = filter + "SkyChip_xsrc"
     182           self.scratchDb.dropTable(tableName)
     183           tableName = filter + "SkyChip_xfit"
     184           self.scratchDb.dropTable(tableName)
    240185
    241186       # create an output filename, which is {stackID}.FITS
    … …  
    257202       self.logger.infoPair("Skycell", "%s" % self.skycell)
    258203       self.logger.infoPair("Projectioncell", "%s" % self.projectioncell)
    259        ##self.logger.infoPair("Filter", "%s" % self.filter)
     204
     205    '''
     206    Drop a table and report the drop
     207    '''
     208    def dropTableVerbose(self, table):
     209        self.logger.infoPair("dropping table:",table)
     210        self.scratchDb.dropTable(table)
    260211
    261212    '''
    … …  
    264215    def updateStackMetaID(self, table):
    265216
    266         sql = "UPDATE " + table + "  SET gstackMetaID=" + str(self.gstackID) + " \
    267               , rstackMetaID=" + str(self.rstackID) + " \
    268               , istackMetaID=" + str(self.istackID) + " \
    269               , zstackMetaID=" + str(self.zstackID) + " \
    270               , ystackMetaID=" + str(self.ystackID)   
     217        sql = "UPDATE " + table + "  SET "
     218
     219        for i in range(len(self.filters)):
     220            filter = self.filters[i]
     221            field = filter + "stackMetaID"
     222            sql += field + " = '" + self.stackIDs[filter] + "'"
     223            if (i < len(self.filters) - 1):
     224                sql += ", "
    271225     
    272226        self.scratchDb.execute(sql)
    … …  
    367321        sql = "UPDATE " + tablename + " AS a, "+f+"SkyChip_xrad AS b SET "
    368322        cnt =0
     323
     324        # XXX : I need to worry about which header this is
    369325        exptime = self.safeDictionaryAccess(self.header, 'EXPTIME')
    370326        for number in numbers:
    … …  
    383339
    384340    '''
    385     Updates parameters for a particular model in the StackModelFit table
    386     '''
    387     def updateModelFit(self, model, ippModelType, filter, exptime):
    388         f = filter
    389  
    390  # idk what to do about PET
    391 
    392         sql = "DESCRIBE "+f+"SkyChip_xfit 'EXT_COVAR_%'"
    393         rs = self.scratchDb.executeQuery(sql)
    394         rs.first()
    395         hasResult = rs.next()
    396 
    397 
    398 
    399         sql = "UPDATE StackModelFit AS a, " + f + "SkyChip_xfit AS b SET \
    400         "+f+model+"Radius=b.EXT_WIDTH_MAJ,  \
    401         "+f+model+"Flux=POW(10, -0.4 * b.EXT_INST_MAG) / " + str(exptime) + " ,  \
    402         "+f+model+"FluxErr=ABS(b.EXT_INST_MAG_SIG) * POW(10, -0.4 * b.EXT_INST_MAG) / " + str(exptime) + " / 1.085736, \
    403         "+f+model+"Ab=b.EXT_WIDTH_MAJ/b.EXT_WIDTH_MIN, \
    404         "+f+model+"Phi=b.EXT_THETA  \
    405           \
    406         WHERE a."+f+"ippDetectID=b.IPP_IDET AND b.MODEL_TYPE = '"+ippModelType+"'"
    407 
    408         print sql
    409         self.scratchDb.execute(sql)
    410 
    411 
    412 
    413         # sersic fit has an extra parameter
    414         if (ippModelType == "PS_MODEL_SERSIC"):
    415             extra_sql = ""
    416             if hasResult:
    417                 extra_sql = ","+f+"serNuErr=SQRT(EXT_COVAR_07_07)"
    418             sql = "UPDATE StackModelFit AS a, "+ f+ "SkyChip_xfit AS b SET \
    419             "+f+"serNu=b.EXT_PAR_07   \
    420             "+extra_sql+" \
    421             WHERE a."+f+"ippDetectID=b.IPP_IDET AND b.MODEL_TYPE = '"+ippModelType+"'"
    422 #           "+f+"serNuErr=SQRT(EXT_COVAR_07_07)  \
    423             self.logger.infoPair("sql",sql)
    424             self.scratchDb.execute(sql)
    425 
    426 
    427     '''
    428341    Populates the StackMeta table, mainly from dictionary values found in IPP FITS header
    429342    '''
    430     def populateStackMeta(self,filterName):
    431 
    432         self.logger.infoPair("Procesing table", "StackMeta")
    433 
    434         # this should work : set header into (grizy)header and run from there
    435         if filterName == 'g.00000':
    436             f = "g"
    437             self.header = self.gheader
    438             tablename = 'gStackMeta'
    439             stackmetaid = self.gstackID
    440         if filterName == 'r.00000':
    441             f = "r"
    442             tablename = 'rStackMeta'
    443             self.header = self.rheader
    444             stackmetaid = self.rstackID
    445         if filterName == 'i.00000':
    446             f = "i"
    447             tablename = 'iStackMeta'
    448             self.header = self.iheader
    449             stackmetaid = self.istackID
    450         if filterName == 'z.00000':
    451             f = "z"
    452             tablename = 'zStackMeta'
    453             self.header = self.zheader
    454             stackmetaid = self.zstackID
    455         if filterName == 'y.00000':
    456             f = "y"
    457             tablename = 'yStackMeta'
    458             self.header = self.yheader
    459             stackmetaid = self.ystackID
    460 
    461         self.fwhm_maj    = self.safeDictionaryAccess(self.header, 'FWHM_MAJ')
    462         self.fwhm_maj_uq = self.safeDictionaryAccess(self.header, 'FW_MJ_UQ')
    463         self.psfmodel    = self.safeDictionaryAccess(self.header, 'PSFMODEL')
     343    def populateStackMeta(self,filter):
     344
     345        header = self.headerSet[filter]
     346        tablename = filter + "StackMeta"
     347        stackID = self.stackIDs[filter]
     348        filterName = filter + ".00000"
     349
     350        self.logger.infoPair("Populating table", tablename)
     351
     352        self.fwhm_maj    = self.getKeyValue(header, 'FWHM_MAJ')
     353        self.fwhm_maj_uq = self.getKeyValue(header, 'FW_MJ_UQ')
     354        self.psfmodel    = self.getKeyValue(header, 'PSFMODEL')
     355
    464356        if (self.fwhm_maj    == "NULL"): self.fwhm_maj    = -999
    465357        if (self.fwhm_maj_uq == "NULL"): self.fwhm_maj_uq = -999
    466358
    467         # print "fwhm_maj    = ", self.fwhm_maj
    468         # print "fwhm_maj_uq = ", self.fwhm_maj_uq
    469         # print "psfmodel    = ", self.psfmodel
    470 
    471         #make a table
    472 
    473         filterid = self.scratchDb.getFilterID(f)
    474         self.logger.infoPair("filterid is ",str(filterid))
     359        # make a table
     360        filterID = self.scratchDb.getFilterID(filter)
     361        self.logger.infoPair("filterID is ",str(filterID))
     362
     363        photoCalID = str(self.scratchDb.getPhotoCalID(stackID))
     364
     365        # XXX mysql is sensitive to values which are ambiugously float.  eg
     366        # a warning is raised if we try to insert '25.' into a float field.
     367        # I should make a function to sanitize float values to a desired number
     368        # of decimal points
     369        zpString = "%5.5f" % float(header['FPA.ZP'])
    475370
    476371        sql = "CREATE TABLE " + tablename + " LIKE StackMeta"
    … …  
    478373        except: pass
    479374
    480         sql = "INSERT INTO " + tablename + " (\
    481         stackMetaID \
    482         ,filterID \
    483         ,skyCellID \
    484         ,photoCalID \
    485         ,photoZero \
    486         ,expTime \
    487         ,psfModelID \
    488         ,psfFwhm_mean \
    489         ,psfFwhm_max \
    490         ,ctype1 \
    491         ,ctype2 \
    492         ,crval1 \
    493         ,crval2 \
    494         ,crpix1 \
    495         ,crpix2 \
    496         ,cdelt1 \
    497         ,cdelt2 \
    498         ,pc001001 \
    499         ,pc001002 \
    500         ,pc002001 \
    501         ,pc002002 \
    502          ) VALUES ( \
    503         " + str(stackmetaid) + " \
    504         , " + str(filterid) + "  \
    505         ," + self.skycell + " \
    506         ," + str(self.scratchDb.getPhotoCalID(self.header['IMAGEID'])) + " \
    507         ," + self.header['FPA.ZP'] + " \
    508         ," + self.header['EXPTIME'] + " \
    509         ,'" + self.psfmodel   + "' \
    510         ," + str(self.fwhm_maj)    + " \
    511         ," + str(self.fwhm_maj_uq) + " \
    512         ,'" + self.header['CTYPE1'] + "' \
    513         ,'" + self.header['CTYPE2'] + "' \
    514         ," + self.header['CRVAL1'] + " \
    515         ," + self.header['CRVAL2'] + " \
    516         ," + self.header['CRPIX1'] + " \
    517         ," + self.header['CRPIX2'] + " \
    518         ," + self.header['CDELT1'] + " \
    519         ," + self.header['CDELT2'] + " \
    520         ," + self.header['PC001001'] + " \
    521         ," + self.header['PC001002'] + " \
    522         ," + self.header['PC002001'] + " \
    523         ," + self.header['PC002002'] + " \
    524         )"
     375        sqlLine = sqlUtility("INSERT INTO " + tablename + " (")
     376
     377        sqlLine.group("batchID",       str(self.batchID))
     378        sqlLine.group("surveyID",      str(self.surveyID))
     379        sqlLine.group("dataRelease",   str(self.skychunk.dataRelease))
     380        sqlLine.group("stackMetaID",   str(stackID))       
     381        sqlLine.group("filterID",      str(filterID))           
     382        sqlLine.group("skyCellID",     self.skycell)           
     383        sqlLine.group("photoCalID",    photoCalID)
     384        sqlLine.group("photoZero",     zpString)    # XXX see note above
     385        sqlLine.group("expTime",       header['EXPTIME']) 
     386        sqlLine.group("psfModelID",    self.psfmodel)           
     387        sqlLine.group("psfFwhm_mean",  str(self.fwhm_maj))     
     388        sqlLine.group("psfFwhm_max",   str(self.fwhm_maj_uq))   
     389        sqlLine.group("ctype1",        header['CTYPE1']) 
     390        sqlLine.group("ctype2",        header['CTYPE2']) 
     391        sqlLine.group("crval1",        header['CRVAL1'])   
     392        sqlLine.group("crval2",        header['CRVAL2'])   
     393        sqlLine.group("crpix1",        header['CRPIX1'])   
     394        sqlLine.group("crpix2",        header['CRPIX2'])   
     395        sqlLine.group("cdelt1",        header['CDELT1'])   
     396        sqlLine.group("cdelt2",        header['CDELT2'])   
     397        sqlLine.group("pc001001",      header['PC001001'])
     398        sqlLine.group("pc001002",      header['PC001002'])
     399        sqlLine.group("pc002001",      header['PC002001'])
     400        sqlLine.group("pc002002",      header['PC002002'])
     401
     402        sql = sqlLine.make(") VALUES ( ", ")")
     403        print "stack meta SQL: " + sql
     404
    525405        self.scratchDb.execute(sql)
    526406
    527 
    528         self.scratchDb.updateAllRows(tablename, "batchID", str(self.batchID))
    529         self.scratchDb.updateAllRows(tablename, "surveyID", str(self.surveyID))
    530     #    self.scratchDb.updateFilterID(tablename, self.scratchDb.getFilterID(filterName))
    531         self.scratchDb.updateAllRows(tablename, "dataRelease", str(self.skychunk.dataRelease))
     407        # set stackTypeID in table based on lookup table & self.stackType
     408        # XXX include in the INSERT above?
    532409        self.updateStackTypeID(tablename)
    533410
    534     '''
    535     Populates the StackObject table
    536     '''
    537     def populateStackObject(self):
    538 
    539         self.logger.infoPair("Procesing table", "StackObject")
     411        self.tablesToExport.append(tablename)
     412
     413    '''
     414    Populates the StackObjectThin table
     415    '''
     416    def populateStackObjectThin(self):
     417
     418        self.logger.infoPair("Procesing table", "StackObjectThin")
     419        self.selectDvoObjIDs()
     420
     421        # XXX EAM 20140731 : if we are going to add indexes (objID?) to StackObjectThin, do it HERE
     422
     423        self.logger.infoPair("inserting filter dependent items into", "StackObjectThin")
     424
     425        for filter in self.filters:
     426            self.logger.infoPair("filter", filter)
     427
     428            stackID = self.stackIDs[filter]
     429            self.logger.infoPair(filter + "stackID = ", stackID)
     430
     431            if stackID <= 0: 
     432                self.logger.infoPair("no stack data for filter" , filter)
     433                continue
     434
     435            imageID = self.imageIDs[filter]
     436            self.logger.infoPair("selecting imageID", imageID)
     437
     438            # at this point, the StackObjectThin table includes objID and ippObjID
     439
     440            # insert detection information for each filter based on the DVO contents
     441            sqlLine = sqlUtility("UPDATE StackObjectThin as a, " + self.scratchDb.dvoDetectionTable + " as b SET")
     442
     443            sqlLine.group("a."+filter+"ippDetectID",   "b.ippDetectID") # eg, gippDetectID (from dvo.measure.detID)
     444            sqlLine.group("a."+filter+"stackDetectID", "b.detectID")    # eg, gstackDetectID (from dvo.measure.extID)
     445            sqlLine.group("a."+filter+"stackMetaID",    str(stackID))   # eg, gstackMetaID (from cmf.IMAGEID)
     446
     447            sqlLine.group("a."+filter+"ra",            "b.ra")
     448            sqlLine.group("a."+filter+"dec",           "b.dec_")
     449            sqlLine.group("a."+filter+"raErr",         "b.raErr")
     450            sqlLine.group("a."+filter+"decErr",        "b.decErr")
     451
     452            sqlLine.group("a."+filter+"PSFMag",        "b.Mpsf")
     453            sqlLine.group("a."+filter+"PSFMagErr",     "b.dMpsf")
     454            sqlLine.group("a."+filter+"KronMag",       "b.Mkron")
     455            sqlLine.group("a."+filter+"KronMagErr",    "b.dMkron")
     456            sqlLine.group("a."+filter+"ApMag",         "b.Map")
     457            sqlLine.group("a."+filter+"ApMagErr",      "b.dMap")
     458            sqlLine.group("a."+filter+"telluricExt",   "b.telluricExt")
     459
     460            sqlLine.group("a."+filter+"infoFlag2",     "(b.flags << 13)")
     461            sql = sqlLine.makeEquals("WHERE a.objID = b.objID AND b.imageID = " + str(imageID))
     462            self.logger.infoPair('sql', sql)     
     463
     464            try: self.scratchDb.execute(sql)
     465            except:
     466                self.logger.errorPair('failed sql: ', sql)
     467                raise
     468
     469            # insert values coming from the CMF, not carried by DVO
     470            header = self.headerSet[filter]
     471            exptime = header['EXPTIME']
     472
     473            sqlLine = sqlUtility("UPDATE StackObjectThin AS a , " + filter + "SkyChip_psf AS b SET")
     474
     475            sqlLine.group("a."+filter+"sky",           "b.SKY / " + str(exptime))
     476            sqlLine.group("a."+filter+"skyErr",        "b.SKY_SIGMA / " + str(exptime))
     477            sqlLine.group("a."+filter+"infoFlag",      "b.FLAGS")
     478            sqlLine.group("a."+filter+"infoFlag2",     "b.FLAGS2 | a."+filter+"infoFlag2")
     479            sqlLine.group("a."+filter+"nFrames",       "b.N_FRAMES")
     480
     481            sql = sqlLine.makeEquals("WHERE a." + filter + "ippDetectID=b.IPP_IDET")
     482            self.logger.infoPair('sql', sql)     
     483
     484            # index the (f)ippDetectIDs for the next steps?
     485            # for filter in self.filters:
     486            #     IDname = filter + "ippDetectID"
     487            #     self.scratchDb.createIndex("StackObjectThin", IDname)
     488
     489            try:
     490                self.scratchDb.execute(sql)
     491            except:
     492                self.logger.errorPair('failed sql: ', sql)
     493                raise
     494
     495    '''
     496    Populates the StackObjectExtra table
     497    '''
     498    def populateStackObjectExtra(self):
     499
     500        self.logger.infoPair("Procesing table", "StackObjectExtra")
     501        self.insertDvoIDs("StackObjectExtra", "StackObjectThin")
     502
     503        # if we are going to add a key, do it here so it is useful
     504        # self.scratchDb.createIndex("StackObjectExtra", "objID")
     505
     506        self.logger.infoPair("inserting filter dependent cmf items into", "StackObjectExtra")
     507        for filter in self.filters:
     508            self.logger.infoPair("filter", filter)
     509
     510            stackID = self.stackIDs[filter]
     511            self.logger.infoPair(filter + "stackID = ", stackID)
     512
     513            if stackID <= 0: 
     514                self.logger.infoPair("no stack data for filter" , filter)
     515                continue
     516
     517            header = self.headerSet[filter]
     518            exptime = header['EXPTIME']
     519
     520            # insert all the detections
     521            sqlLine = sqlUtility("UPDATE StackObjectExtra AS a , " + filter + "SkyChip_psf AS b SET")
     522
     523            sqlLine.group("a."+filter+"xPos",          "b.X_PSF")
     524            sqlLine.group("a."+filter+"yPos",          "b.Y_PSF")
     525            sqlLine.group("a."+filter+"xPosErr",       "b.X_PSF_SIG")
     526            sqlLine.group("a."+filter+"yPosErr",       "b.Y_PSF_SIG")
     527
     528            sqlLine.group("a."+filter+"psfMajorFWHM",  "b.PSF_FWHM_MAJ")
     529            sqlLine.group("a."+filter+"psfMinorFWHM",  "b.PSF_FWHM_MIN")
     530            sqlLine.group("a."+filter+"psfTheta",      "b.PSF_THETA")
     531            sqlLine.group("a."+filter+"psfCore",       "b.PSF_CORE")
     532            sqlLine.group("a."+filter+"psfLikelihood", "psfLikelihood(b.EXT_NSIGMA)")
     533            sqlLine.group("a."+filter+"psfQf",         "b.PSF_QF")
     534            sqlLine.group("a."+filter+"psfQfPerfect",  "b.PSF_QF_PERFECT")
     535            sqlLine.group("a."+filter+"psfChiSq",      "b.PSF_CHISQ / b.PSF_NDOF")
     536            sqlLine.group("a."+filter+"momentXX",      "b.MOMENTS_XX")
     537            sqlLine.group("a."+filter+"momentXY",      "b.MOMENTS_XY")
     538            sqlLine.group("a."+filter+"momentYY",      "b.MOMENTS_YY")
     539            sqlLine.group("a."+filter+"momentR1",      "b.MOMENTS_R1")
     540            sqlLine.group("a."+filter+"momentRH",      "b.MOMENTS_RH")
     541
     542            sqlLine.group("a."+filter+"PSFFlux",       "b.PSF_INST_FLUX / " + str(exptime))
     543            sqlLine.group("a."+filter+"PSFFluxErr",    "b.PSF_INST_FLUX_SIG / " + str(exptime))
     544            sqlLine.group("a."+filter+"ApFlux",        "b.AP_FLUX / " + str(exptime))
     545            sqlLine.group("a."+filter+"ApFluxErr",     "b.AP_FLUX_SIG / " + str(exptime))
     546            sqlLine.group("a."+filter+"KronFlux",      "b.KRON_FLUX / " + str(exptime))
     547            sqlLine.group("a."+filter+"KronFluxErr",   "b.KRON_FLUX_ERR / " + str(exptime))
     548
     549            sqlLine.group("a."+filter+"ApFillFac",     "b.AP_NPIX / (3.14159265359 * b.AP_MAG_RADIUS * b.AP_MAG_RADIUS)")
     550            sqlLine.group("a."+filter+"ApRadius",      "b.AP_MAG_RADIUS")
     551            sqlLine.group("a."+filter+"KronRad",       "b.MOMENTS_R1 * 2.5")
     552
     553            sql = sqlLine.makeEquals("WHERE a." + filter + "ippDetectID = b.IPP_IDET")
     554
     555            self.logger.infoPair('sql', sql)     
     556            try:
     557                self.scratchDb.execute(sql)
     558            except:
     559                self.logger.errorPair('failed sql',sql)
     560                return
     561
     562            # insert detection information for each filter based on the DVO contents
     563            sqlLine = sqlUtility("UPDATE StackObjectExtra as a, " + self.scratchDb.dvoDetectionTable + " as b SET")
     564            sqlLine.group("a."+filter+"expTime",       "b.expTime")
     565            sqlLine.group("a."+filter+"zp",            "b.zp")
     566
     567            # where should these go?
     568            # sqlLine.group("a."+filter+"airmass",       "b.airmass")
     569
     570            sql = sqlLine.makeEquals("WHERE a.objID = b.objID AND a." + filter + "ippDetectID = b.ippDetectID")
     571
     572            self.logger.infoPair('sql', sql)     
     573            try:
     574                self.scratchDb.execute(sql)
     575            except:
     576                self.logger.errorPair('failed sql',sql)
     577                return
     578
     579    '''
     580    Populates the StackModelFitThin table
     581    '''
     582    def populateStackModelFitThin(self):
     583
     584        self.logger.infoPair("Procesing table", "StackModelFitThin")
     585        self.insertDvoIDs("StackModelFitThin", "StackObjectThin")
     586
     587        # if we are going to add a key, do it here so it is useful
     588        # self.scratchDb.createIndex("StackObjectExtra", "objID")
     589
    540590       
    541         self.logger.infoPair("inserting non-filter dependent items into", "StackObject")
    542 
    543         #this is dvo crap
    544         #sql = "INSERT INTO StackObject(\
    545         #      objID, \
    546         #      gcobjID, \
    547         #      ippObjID, \
    548         #      surveyID, \
    549         #      skyCellID, \
    550         #      randomStackObjID, \
    551         #      stackDetectRowID, \
    552         #      dvoRegionID, \
    553         #      dataRelease) SELECT \
    554         #      -999,
    555         #      -999,
    556         #      -999,
    557         #      ,
    558              
    559        
    560        
    561 
    562         self.logger.infoPair("inserting filter dependent cmf items into", "StackObject")
    563         filters =['g','r','i','z','y']
    564         for f in filters:
    565           skip = 0
    566           if (f == "g"):
    567               self.logger.infoPair("gstackID = ",self.gstackID)
    568               if self.gstackID > 0: 
    569                   stackid = self.gstackID
    570                   exptime = self.gheader['EXPTIME']
    571               else:
    572                   skip = 1
    573           if (f == "r"):
    574               self.logger.infoPair("rstackID = ",self.rstackID)
    575               if self.rstackID > 0:
    576                   stackid = self.rstackID
    577                   exptime = self.rheader['EXPTIME']
    578               else:
    579                   skip = 1
    580           if (f == "i"):
    581               self.logger.infoPair("istackID = ",self.istackID)
    582               if self.istackID > 0:
    583                   stackid = self.istackID
    584                   exptime = self.iheader['EXPTIME']
    585               else:
    586                   skip = 1
    587           if (f == "z"):
    588               self.logger.infoPair("zstackID = ",self.zstackID)
    589               if self.zstackID > 0:
    590                   stackid = self.zstackID
    591                   exptime = self.zheader['EXPTIME']
    592               else:
    593                   skip = 1
    594           if (f == "y"):
    595               self.logger.infoPair("ystackID = ",self.ystackID)
    596               if self.ystackID > 0:
    597                   stackid = self.ystackID
    598                   exptime = self.yheader['EXPTIME']
    599               else:
    600                   skip = 1
    601 
    602           if skip == 1:
    603               self.logger.infoPair("nothing for filter" , f)
    604           else:
    605              self.logger.infoPair("filter",f)
    606 
    607 
    608 
    609              # insert all the detections
    610              sql = "UPDATE StackObject as a , " + f + "SkyChip_psf as b set \
    611                    a."+f+"xPos = b.X_PSF \
    612                    ,a."+f+"yPos = b.Y_PSF \
    613                    ,a."+f+"xPosErr = b.X_PSF_SIG \
    614                    ,a."+f+"yPosErr = b.Y_PSF_SIG \
    615                    ,a."+f+"PSFFlux = b.PSF_INST_FLUX / " + str(exptime) + " \
    616                    ,a."+f+"PSFFluxErr = b.PSF_INST_FLUX_SIG / " + str(exptime) + " \
    617                    ,a."+f+"sky = b.SKY / " + str(exptime) + " \
    618                    ,a."+f+"skyErr = b.SKY_SIGMA / " + str(exptime) + " \
    619                    ,a."+f+"psfMajorFWHM = b.PSF_MAJOR \
    620                    ,a."+f+"psfMinorFWHM = b.PSF_MINOR \
    621                    ,a."+f+"psfTheta = b.PSF_THETA \
    622                    ,a."+f+"psfCore = NULL \
    623                    ,a."+f+"psfLikelihood = psfLikelihood(b.EXT_NSIGMA) \
    624                    ,a."+f+"infoFlag = b.FLAGS2 << 32 | FLAGS \
    625                    ,a."+f+"psfQf = b.PSF_QF \
    626                    ,a."+f+"psfQfPerfect = b.PSF_QF_PERFECT \
    627                    ,a."+f+"psfChiSq = b.PSF_CHISQ / b.PSF_NDOF \
    628                    ,a."+f+"momentXX = b.MOMENTS_XX \
    629                    ,a."+f+"momentXY = b.MOMENTS_XY \
    630                    ,a."+f+"momentYY = b.MOMENTS_YY \
    631                    ,a."+f+"momentR1 = b.MOMENTS_R1 \
    632                    ,a."+f+"momentRH = b.MOMENTS_RH \
    633                    ,a."+f+"ApFlux = POW(10.0, -0.4*b.AP_MAG) / " + str(exptime) + " \
    634                    ,a."+f+"ApFluxErr = NULL \
    635                    ,a."+f+"ApFillFac = NULL \
    636                    ,a."+f+"KronFlux = b.KRON_FLUX / " + str(exptime) + " \
    637                    ,a."+f+"KronFluxErr = b.KRON_FLUX_ERR / " + str(exptime) + " \
    638                    ,a."+f+"KronRad = b.MOMENTS_R1 * 2.5 \
    639                    ,a."+f+"PSFMag = b.PSF_INST_MAG    \
    640                    ,a."+f+"PSFMagErr = b.PSF_INST_MAG_SIG    \
    641                    ,a."+f+"ApMag = b.AP_MAG    \
    642                    ,a."+f+"ApMagErr = NULL    \
    643                    ,a."+f+"KronMag = NULL    \
    644                    ,a."+f+"KronMagErr = NULL    \
    645                    ,a."+f+"nFrames = b. N_FRAMES \
    646                    WHERE a." + f + "ippDetectID=b.IPP_IDET "
    647              self.logger.infoPair('sql', sql)     
    648              try:
    649                  self.scratchDb.execute(sql)
    650              except:
    651                  self.logger.errorPair('failed sql',sql)
    652                  return
    653              #it is possible to drop some detections from dvo (that are present in the cmf). when that happens we get a 0 for objid
    654         #we drop those...
    655 
    656         self.logger.infoPair("Deleting", "entries with StackObject.objID = 0")
    657         sql="DELETE FROM StackObject where objID = 0"
    658         try:
    659             self.scratchDb.execute(sql)
    660         except:
    661             self.logger.errorPair('failed sql',sql)
    662             return
    663        
    664         try:
    665             self.scratchDb.updateAllRows("StackObject", "surveyID", str(self.surveyID))
    666         except:
    667             self.logger.errorPair('failed update surveyID on','StackObject')
    668             raise
    669 #        self.scratchDb.updateFilterID("StackObject", f+".00000")
    670        
    671         self.scratchDb.updateAllRows("StackObject", "dataRelease", str(self.skychunk.dataRelease))
    672         try:
    673             self.updateStackMetaID("StackObject")
    674         except:
    675             self.logger.errorPair("failed update stack meta id on ", "StackObject")
    676             raise
    677         ##self.updateStackTypeID("StackObject")
    678        
    679         #self.updateDvoIDsAndFlags("StackObject")
    680         #this now updates primary F as well
    681         # response = raw_input("updated dvo ")
    682        
    683         # XXX EAM : note that in mysql versions later than 5.1, this fails
    684         # unless the following is called first:
    685         # set session old_alter_table=1
    686         # follow the command with
    687         # set session old_alter_table=0
    688         # OF COURSE, this fails for mysql version < 5.5...
    689         if self.scratchDb.version > 5.1:
    690             self.scratchDb.execute("set session old_alter_table=1")
    691 
    692         sql = "ALTER IGNORE TABLE StackObject ADD PRIMARY KEY (objID)"
    693        
    694         if self.scratchDb.version > 5.1:
    695             self.scratchDb.execute("set session old_alter_table=0")
    696 
     591    '''
     592    Populates the StackModelFitExp table
     593    '''
     594    def populateStackModelFit(self, model, ippModelType):
     595
     596        table = "StackModelFit" + model
     597
     598        self.logger.infoPair("Procesing table", table)
     599        self.insertDvoIDs(table, "StackObjectThin")
     600
     601        # if we are going to add a key, do it here so it is useful
     602        # self.scratchDb.createIndex(table, "objID")
     603
     604        for filter in self.filters:
     605            populateStackModelFitFilter(model, ippModelType, filter)
     606
     607    '''
     608    Updates parameters for a particular model in the StackModelFit table
     609    '''
     610    def populateStackModelFitFilter(self, model, ippModelType, filter, exptime):
     611
     612        header  = self.headerSet[filter]
     613        exptime = header['EXPTIME']
     614
     615        sqlLine = sqlUtility("UPDATE StackModelFit AS a, " + filter + "SkyChip_xfit AS b SET")
     616
     617        # these lines yield the flux, flux error values, but I do not think we want those in the database...
     618        # sqlLine.group("a." + filter + model + "Flux",    "POW(10, -0.4 * b.EXT_INST_MAG) / " + str(exptime))
     619        # sqlLine.group("a." + filter + model + "FluxErr", "ABS(b.EXT_INST_MAG_SIG) * POW(10, -0.4 * b.EXT_INST_MAG) / " + str(exptime) + " / 1.085736")
     620
     621        sqlLine.group("a." + filter + model + "Mag",       "b.EXT_INST_MAG") # need to modify by zero point and 2.5*log10(exptime)
     622        sqlLine.group("a." + filter + model + "MagErr",    "b.EXT_INST_MAG_SIG") # need to modify by zero point and 2.5*log10(exptime)
     623                     
     624        sqlLine.group("a." + filter + model + "Radius",    "b.EXT_WIDTH_MAJ")
     625        sqlLine.group("a." + filter + model + "Ab",        "b.EXT_WIDTH_MAJ/b.EXT_WIDTH_MIN")
     626        sqlLine.group("a." + filter + model + "Phi",       "b.EXT_THETA")
     627
     628        sqlLine.group("a." + filter + model + "RadiusErr", "b.EXT_WIDTH_MAJ_ERR") # these are not correctly defined.
     629        sqlLine.group("a." + filter + model + "AbErr",     "b.EXT_WIDTH_MIN_ERR") # these are not correctly defined.
     630        sqlLine.group("a." + filter + model + "PhiErr",    "b.EXT_THETA_ERR") # these are not correctly defined.
     631
     632        sqlLine.group("a." + filter + model + "Ra",        "b.RA_EXT")
     633        sqlLine.group("a." + filter + model + "Dec",       "b.DEC_EXT")
     634
     635        sqlLine.group("a." + filter + model + "RaErr",     "b.X_EXT_SIG * b.PLTSCALE")
     636        sqlLine.group("a." + filter + model + "DecErr",    "b.Y_EXT_SIG * b.PLTSCALE")
     637
     638        # sersic fit has an extra parameter
     639        if (ippModelType == "PS_MODEL_SERSIC"):
     640            sqlLine.group("a." + filter + model + "Nu",    "b.EXT_PAR_07")
     641            sqlLine.group("a." + filter + model + "NuErr", "'0.1'") # this is not measured at the moment
     642
     643        # missing these two fields?
     644        # sqlLine.group("a." + filter + model + "CF",         "b.XX")
     645        # sqlLine.group("a." + filter + model + "Likelihood", "b.XX")
     646
     647        sql = sqlLine.makeEquals("WHERE a." + filter + "ippDetectID = b.IPP_IDET AND b.MODEL_TYPE = '" + ippModelType + "'")
     648
     649        print sql
    697650        self.scratchDb.execute(sql)
    698         # response = raw_input("add primary key? ")
    699  
    700         ### XXX this should not be a DEEP_STACK only case...
    701         if False and self.stackType == "DEEP_STACK":
    702             ## need to do for all filters?
    703             #if deep stack and instFlux = null and err not null
    704             sql = "UPDATE StackObject AS a, SkyChip_psf AS b \
    705                    SET psfFlux = 2*b.PSF_INST_FLUX_SIG / " + str(self.expTime) + " \
    706                    WHERE psfFlux IS NULL \
    707                    AND a.ippDetectID = b.IPP_IDET  \
    708                    AND b.PSF_INST_FLUX_SIG IS NOT NULL"
    709            
    710             self.scratchDb.execute(sql)
    711             # response = raw_input("add psf flux ")
    712          
    713         #filter dependent
    714         # NOTE : Flux limits : in the current PSPS schema, negative fluxes
    715         # cause problems for sql queries which work in mags as SQL cannot do
    716         # something like (f < 0.0) ? -999 : -2.5*log10(f)
    717         # as a result, the negative fluxes here result in floating point errors
    718         sql = "UPDATE StackObject SET gPSFFlux = 1e20 WHERE gPSFFlux <= 0.0"
    719         self.scratchDb.execute(sql)
    720        
    721         sql = "UPDATE StackObject SET gApFlux = 1e20 WHERE gApFlux <= 0.0"
    722         self.scratchDb.execute(sql)
    723 
    724         sql = "UPDATE StackObject SET gKronFlux = 1e20 WHERE gKronFlux <= 0.0"
    725         self.scratchDb.execute(sql)
    726         sql = "UPDATE StackObject SET rPSFFlux = 1e20 WHERE rPSFFlux <= 0.0"
    727         self.scratchDb.execute(sql)
    728        
    729         sql = "UPDATE StackObject SET rApFlux = 1e20 WHERE rApFlux <= 0.0"
    730         self.scratchDb.execute(sql)
    731 
    732         sql = "UPDATE StackObject SET rKronFlux = 1e20 WHERE rKronFlux <= 0.0"
    733         self.scratchDb.execute(sql)
    734         sql = "UPDATE StackObject SET iPSFFlux = 1e20 WHERE iPSFFlux <= 0.0"
    735         self.scratchDb.execute(sql)
    736        
    737         sql = "UPDATE StackObject SET iApFlux = 1e20 WHERE iApFlux <= 0.0"
    738         self.scratchDb.execute(sql)
    739 
    740         sql = "UPDATE StackObject SET iKronFlux = 1e20 WHERE iKronFlux <= 0.0"
    741         self.scratchDb.execute(sql)
    742         sql = "UPDATE StackObject SET zPSFFlux = 1e20 WHERE zPSFFlux <= 0.0"
    743         self.scratchDb.execute(sql)
    744        
    745         sql = "UPDATE StackObject SET zApFlux = 1e20 WHERE zApFlux <= 0.0"
    746         self.scratchDb.execute(sql)
    747 
    748         sql = "UPDATE StackObject SET zKronFlux = 1e20 WHERE zKronFlux <= 0.0"
    749         self.scratchDb.execute(sql)
    750         sql = "UPDATE StackObject SET yPSFFlux = 1e20 WHERE yPSFFlux <= 0.0"
    751         self.scratchDb.execute(sql)
    752        
    753         sql = "UPDATE StackObject SET yApFlux = 1e20 WHERE yApFlux <= 0.0"
    754         self.scratchDb.execute(sql)
    755 
    756         sql = "UPDATE StackObject SET yKronFlux = 1e20 WHERE yKronFlux <= 0.0"
    757         self.scratchDb.execute(sql)
    758 
    759         #leave null instflux in
    760         #self.scratchDb.reportAndDeleteRowsWithNULLS("StackObject", "instFlux")
    761        
    762         self.scratchDb.reportAndDeleteRowsWithNULLS("StackObject", "objID")
    763         # response = raw_input("delete nulls ")
    764        
    765         sql="DELETE FROM StackObject where objID = 0"
    766        
    767         self.scratchDb.execute(sql)
    768         self.logger.infoPair("Deleting", "entries with StackObject.objID = 0")
    769         # response = raw_input("deleted objID is 0 ")
    770     '''
    771     Populates the SkinnyObject table
    772     '''
    773     def populateSkinnyObject(self):
    774 
    775         self.logger.infoPair("Procesing table", "SkinnyObject")
    776 
    777         sql = "INSERT INTO SkinnyObject (\
    778                objID \
    779                ,ippObjID \
    780                ,projectionCellID \
    781                ) \
    782                SELECT \
    783                DISTINCT objID \
    784                ,ippObjID \
    785                ,projectionCellID \
    786                FROM StackDetection"
    787         self.scratchDb.execute(sql)
    788 
    789         self.scratchDb.updateAllRows("SkinnyObject", "surveyID", str(self.surveyID))
    790         self.scratchDb.updateAllRows("SkinnyObject", "dataRelease", str(self.skychunk.dataRelease))
    791          
     651
     652
     653        # XXX old code for flux tables
     654        # self.logger.infoPair("Adding fluxes", "un-convolved")
     655        # self.updateModelFitFlxs("", "((b.table_index -1) % 3 = 0)","StackModelFit",f)
     656        # self.logger.infoPair("Adding fluxes", "1st convolved")
     657        # self.updateModelFitFlxs("c1", "((b.table_index -1) % 3 = 1)","StackModelFit",f)
     658        # self.logger.infoPair("Adding fluxes", "2nd convolved")
     659        # self.updateModelFitFlxs("c2", "((b.table_index -1) % 3 = 2)","StackModelFit",f)
     660
     661    '''
     662    Populates the StackApFlx table, mainly from dictionary values found in IPP FITS header
     663    '''
     664    # def populateStackApFlx(self,filter):
     665
     666        ## self.logger.infoPair("Adding", "petrosians for extended sources")
     667        ## sql = "UPDATE StackModelFit as a, "+f+"SkyChip_xsrc AS b SET \
     668        ## "+f+"petRadius=b.PETRO_RADIUS \
     669        ## ,"+f+"petRadiusErr=b.PETRO_RADIUS_ERR \
     670        ## ,"+f+"petFlux=POW(10.0, -0.4 * b.PETRO_MAG) /" + str(self.header['EXPTIME']) + " \
     671        ## ,"+f+"petFluxErr=-999  \
     672        ## ,"+f+"petR50=b.PETRO_RADIUS_50 \
     673        ## ,"+f+"petR50Err=b.PETRO_RADIUS_50_ERR \
     674        ## ,"+f+"petR90=b.PETRO_RADIUS_90 \
     675        ## ,"+f+"petR90Err=b.PETRO_RADIUS_90_ERR \
     676        ## ,"+f+"petCf=b.PETRO_FILL \
     677        ## WHERE a."+f+"ippDetectID=b.IPP_IDET"
     678        ## self.scratchDb.execute(sql)
     679        ##
     680        ## self.logger.infoPair("Adding", "petFluxErr for non nulls")
     681        ## sql = "UPDATE StackModelFit as a, "+f+"SkyChip_xsrc AS b SET \
     682        ## "+f+"petFluxErr=ABS(b.PETRO_MAG_ERR) * POW(10.0, (-0.4*b.PETRO_MAG)) / " + str(self.header['EXPTIME']) + " / 1.085736  \
     683        ## WHERE a."+f+"ippDetectID=b.IPP_IDET \
     684        ## AND (b.PETRO_MAG_ERR is not NULL AND b.PETRO_MAG is not NULL AND PETRO_MAG_ERR < 1000.0)"
     685        ## # added this because when the petromagerr is crazy large (10^29 it out of ranges the flux err calc)
     686        ## self.logger.infoPair("sql", sql)
     687        ## self.scratchDb.execute(sql)
     688
     689
     690        # self.scratchDb.updateAllRows("StackModelFit", "surveyID", str(self.surveyID))
     691        # self.scratchDb.updateAllRows("StackModelFit", "dataRelease", str(self.skychunk.dataRelease))
     692
     693        # self.logger.infoPair("not adding"," PrimaryF to stackApFlx")
     694        # sql = "UPDATE StackModelFit AS a, " + self.scratchDb.dvoDetectionTable + " AS b SET \
     695        #        a.primaryF = ((b.flags & 0x10000) >> 16 ) \
     696        #        WHERE a.ippDetectID = b.ippDetectID \
     697        #        AND b.imageID = " + str(imageID)
    792698
    793699    '''
    … …  
    795701    '''
    796702    def populateStackApFlx(self):
    797         filter = ['g','r','i','z','y']
    798 
    799         for f in filter:
    800             skip = 0
    801             if (f == 'g'):
    802                 if self.gstackID > 0:
    803                     self.header = self.gheader
    804                 else:
    805                     skip = 1
    806             if (f == 'r'):
    807                 if self.rstackID > 0:
    808                     self.header = self.rheader
    809                 else:
    810                     skip = 1
    811             if (f == 'i'):
    812                 if self.istackID > 0:
    813                     self.header = self.iheader
    814                 else:
    815                     skip = 1
    816             if (f == 'z'):
    817                 if self.zstackID > 0:
    818                     self.header = self.zheader
    819                 else:
    820                     skip = 1
    821             if (f == 'y'):
    822                 if self.ystackID > 0:
    823                     self.header = self.yheader
    824                 else:
    825                     skip =1
    826 
    827             if skip == 0:
    828                 self.logger.infoPair("Adding fluxes", "un-convolved")
    829                 self.updateModelFitFlxs("", "((b.table_index -1) % 3 = 0)", "StackApFlx", f)
    830                 self.logger.infoPair("Adding fluxes", "1st convolved")
    831                 self.updateModelFitFlxs("c1", "((b.table_index -1) % 3 = 1)","StackApFlx",f)
    832                 self.logger.infoPair("Adding fluxes", "2nd convolved")
    833                 self.updateModelFitFlxs("c2", "((b.table_index -1) % 3 = 2)","StackApFlx",f)
    834 
    835                 self.deleteDetectionsNotInStackObject("StackApFlx",f)
     703
     704        for filter in self.filters:
     705            if self.stackIDs[filter] <= 0:
     706                continue
     707
     708            # XXX is this a reasonable solution?
     709            self.header = self.headerSet[filter]
     710
     711            self.logger.infoPair("Adding fluxes", "un-convolved")
     712            self.updateModelFitFlxs("", "((b.table_index -1) % 3 = 0)", "StackApFlx", filter)
     713            self.logger.infoPair("Adding fluxes", "1st convolved")
     714            self.updateModelFitFlxs("c1", "((b.table_index -1) % 3 = 1)","StackApFlx", filter)
     715            self.logger.infoPair("Adding fluxes", "2nd convolved")
     716            self.updateModelFitFlxs("c2", "((b.table_index -1) % 3 = 2)","StackApFlx", filter)
     717
     718            self.deleteDetectionsNotInStackObject("StackApFlx",f)
    836719
    837720        self.scratchDb.reportAndDeleteRowsWithNULLS("StackApFlx", "objID")
    838        
    839 
    840 
    841     '''
    842     Populates the StackModelFit table
    843     '''
    844     def populateStackModelFit(self, filter):
    845         # for each filter
    846         f =filter
    847         if (filter == 'g'):
    848             self.header = self.gheader
    849            
    850         if (filter == 'r'):
    851             self.header = self.rheader
    852         if (filter == 'i'):
    853             self.header = self.iheader
    854         if (filter == 'z'):
    855             self.header = self.zheader
    856         if (filter == 'y'):
    857             self.header = self.yheader
    858            
    859 
    860 
    861 
    862 
    863         self.logger.infoPair("getting","imageID")
    864         imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    865         self.logger.infoPair("obtained","imageID")
    866         self.logger.infoPair("Procesing table", "StackModelFit")
    867 
    868 
    869         # insert all the detections
    870 
    871         # populate model parameters
    872         self.logger.infoPair("Adding model fit", "deVaucouleurs")
    873         self.updateModelFit("deV", "PS_MODEL_DEV", filter, self.header['EXPTIME'])
    874         self.logger.infoPair("Adding model fit", "exponential")
    875         self.updateModelFit("deV", "PS_MODEL_EXP", filter, self.header['EXPTIME'])
    876         self.logger.infoPair("Adding model fit", "sersic")
    877         self.updateModelFit("deV", "PS_MODEL_SERSIC", filter, self.header['EXPTIME'])
    878  
    879 
    880         self.logger.infoPair("Adding fluxes", "un-convolved")
    881         self.updateModelFitFlxs("", "((b.table_index -1) % 3 = 0)","StackModelFit",f)
    882         self.logger.infoPair("Adding fluxes", "1st convolved")
    883         self.updateModelFitFlxs("c1", "((b.table_index -1) % 3 = 1)","StackModelFit",f)
    884         self.logger.infoPair("Adding fluxes", "2nd convolved")
    885         self.updateModelFitFlxs("c2", "((b.table_index -1) % 3 = 2)","StackModelFit",f)
    886 
    887  
    888         self.logger.infoPair("Adding", "petrosians for extended sources")
    889         sql = "UPDATE StackModelFit as a, "+f+"SkyChip_xsrc AS b SET \
    890         "+f+"petRadius=b.PETRO_RADIUS \
    891         ,"+f+"petRadiusErr=b.PETRO_RADIUS_ERR \
    892         ,"+f+"petFlux=POW(10.0, -0.4 * b.PETRO_MAG) /" + str(self.header['EXPTIME']) + " \
    893         ,"+f+"petFluxErr=-999  \
    894         ,"+f+"petR50=b.PETRO_RADIUS_50 \
    895         ,"+f+"petR50Err=b.PETRO_RADIUS_50_ERR \
    896         ,"+f+"petR90=b.PETRO_RADIUS_90 \
    897         ,"+f+"petR90Err=b.PETRO_RADIUS_90_ERR \
    898         ,"+f+"petCf=b.PETRO_FILL \
    899         WHERE a."+f+"ippDetectID=b.IPP_IDET"
    900         self.scratchDb.execute(sql)
    901 
    902         self.logger.infoPair("Adding", "petFluxErr for non nulls")
    903         sql = "UPDATE StackModelFit as a, "+f+"SkyChip_xsrc AS b SET \
    904         "+f+"petFluxErr=ABS(b.PETRO_MAG_ERR) * POW(10.0, (-0.4*b.PETRO_MAG)) / " + str(self.header['EXPTIME']) + " / 1.085736  \
    905         WHERE a."+f+"ippDetectID=b.IPP_IDET \
    906         AND (b.PETRO_MAG_ERR is not NULL AND b.PETRO_MAG is not NULL AND PETRO_MAG_ERR < 1000.0)"
    907         # added this because when the petromagerr is crazy large (10^29 it out of ranges the flux err calc)
    908         self.logger.infoPair("sql", sql)
    909         self.scratchDb.execute(sql)
    910 
    911 
    912 
    913         self.scratchDb.updateAllRows("StackModelFit", "surveyID", str(self.surveyID))
    914         self.scratchDb.updateAllRows("StackModelFit", "dataRelease", str(self.skychunk.dataRelease))
    915 
    916         self.logger.infoPair("not adding"," PrimaryF to stackApFlx")
    917         sql = "UPDATE StackModelFit AS a, " + self.scratchDb.dvoDetectionTable + " AS b SET \
    918                a.primaryF = ((b.flags & 0x10000) >> 16 ) \
    919                WHERE a.ippDetectID = b.ippDetectID \
    920                AND b.imageID = " + str(imageID)
    921 
    922 #        try:
    923 #            self.scratchDb.execute(sql)
    924 #        except:
    925 #            return
    926 
    927 ##        self.scratchDb.updateAllRows("StackModelFit", "activeFlag", "0")
    928         ##self.updateStackMetaID("StackModelFit")
    929 ##        self.updateStackTypeID("StackModelFit")
    930        
    931         self.scratchDb.reportAndDeleteRowsWithNULLS("StackModelFit", "objID")
    932         self.deleteDetectionsNotInStackObject("StackModelFit", f)
    933721
    934722    '''
    … …  
    956744
    957745        self.logger.infoPair("Procesing table", "StackToImage")
    958         filters = ['g','r','i','z','y']
    959         for f in filters:
     746
     747        for filter in self.filters:
    960748           
    961             if f == 'g':
    962                 stackmetaid = self.gstackID
    963             if f == 'r':
    964                 stackmetaid = self.rstackID
    965             if f == 'i':
    966                 stackmetaid = self.istackID
    967             if f == 'z':
    968                 stackmetaid = self.zstackID
    969             if f == 'y':
    970                 stackmetaid = self.ystackID
    971             if stackmetaid > 0:
     749            stackmetaID = self.stackIDs[filter]
     750            if stackmetaID > 0:
    972751   
    973                 imageIDs = self.gpc1Db.getImageIDsForThisStackID(stackmetaid)
     752                imageIDs = self.gpc1Db.getImageIDsForThisStackID(stackmetaID)
    974753
    975754                for imageID in imageIDs:
     755
    976756                    sql = "INSERT INTO StackToImage (stackMetaID, imageID) \
    977757                   VALUES (\
    978                    " + str(stackmetaid) + ", " + imageID + ")"
     758                   " + str(stackmetaID) + ", " + imageID + ")"
    979759                    self.scratchDb.execute(sql)
    980760
    981         # now update StackMeta with correct number of inputs
    982                     sql = "UPDATE "+f+"StackMeta SET nP2Images = (SELECT COUNT(distinct(floor(imageID/100))) FROM StackToImage where stackMetaID = "+str(stackmetaid)+")"
     761                    # now update StackMeta with correct number of inputs
     762                    sql = "UPDATE "+filter+"StackMeta SET nP2Images = (SELECT COUNT(distinct(floor(imageID/100))) FROM StackToImage where stackMetaID = "+str(stackmetaID)+")"
    983763                    self.scratchDb.execute(sql)
    984764
    … …  
    1015795
    1016796       
     797    '''
     798    I think we are no longer using this function: this have been
     799    replaced with the code in 'selectDvoObjIDs' and 'selectDvoFilterIDs'
     800    '''
    1017801    def populateStackIPPDetectIDFromDvo(self, tableName, all):
    1018802
    … …  
    1022806        filters = ['g','r','i','z','y']
    1023807       
    1024         for f in filters:
    1025             skip = 0
    1026             #first: do we skip this filter
    1027             if f == 'g':
    1028                 if self.gstackID < 0:
    1029                     skip = 1
    1030                 else:
    1031                     self.header=self.gheader
    1032                     stackmetaid = self.gstackID
    1033             elif f == 'r':
    1034                 if self.rstackID < 0:
    1035                     skip = 1
    1036                 else:
    1037                     self.header = self.rheader
    1038                     stackmetaid = self.rstackID
    1039             elif f == 'i':
    1040                 if self.istackID < 0:
    1041                     skip = 1
    1042                 else:
    1043                     self.header = self.iheader
    1044                     stackmetaid = self.istackID
    1045             elif f == 'z':
    1046                 if self.zstackID < 0:
    1047                     skip = 1
    1048                 else:
    1049                     self.header = self.zheader
    1050                     stackmetaid = self.zstackID
    1051             elif f == 'y':
    1052                 if self.ystackID < 0:
    1053                     skip = 1
    1054                 else:
    1055                     self.header = self.yheader
    1056                     stackmetaid = self.ystackID
    1057             if skip == 0:       
    1058                 imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    1059                 self.logger.infoPair("obtained","imageID")
    1060                 addsql = ""
    1061                 if (all == 1):
    1062                     addsql = "a." + f + "ra = b.ra, \
    1063                       a." + f + "dec = b.dec_, \
    1064                       a." + f + "raErr = b.raErr, \
    1065                       a." + f + "decErr = b.decErr, \
    1066                       a." + f + "zp = b.zp, \
    1067                       a." + f + "expTime = b.expTime,"
    1068 
    1069                    
    1070                 sql = "UPDATE " + tableName + " AS a, "  + self.scratchDb.dvoDetectionTable + " AS b \
    1071                       SET a." + f + "ippDetectID = b.ippDetectID, \
    1072                       " + addsql + " \
    1073                       a." + f + "stackDetectID = b.detectID,   \
    1074                       a." + f + "ippObjID = b.ippObjID, \
    1075                       a." + f + "stackMetaID = " + str(stackmetaid) +  " \
    1076                       WHERE a.objID = b.objID  AND b.imageID = " + str(imageID)
    1077                 self.logger.infoPair('sql',sql)   
    1078                 self.scratchDb.execute(sql)
    1079             else:
     808        for filter in self.filters:
     809            if self.stackIDs[filter] < 0:
    1080810                self.logger.infoPair("skipping ingest of dvo for filter",f)
    1081         #out of the loops - give dataRelase to all       
     811                continue
     812
     813            self.header = self.headerSet[filter]
     814            stackmetaID = self.stackIDs[filter]
     815
     816            imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
     817            self.logger.infoPair("obtained","imageID")
     818            addsql = ""
     819            if (all == 1):
     820                addsql = "a." + filter + "ra = b.ra, \
     821                  a." + filter + "dec = b.dec_, \
     822                  a." + filter + "raErr = b.raErr, \
     823                  a." + filter + "decErr = b.decErr, \
     824                  a." + filter + "zp = b.zp, \
     825                  a." + filter + "expTime = b.expTime,"
     826
     827               
     828            sql = "UPDATE " + tableName + " AS a, "  + self.scratchDb.dvoDetectionTable + " AS b \
     829                  SET a." + filter + "ippDetectID = b.ippDetectID, \
     830                  " + addsql + " \
     831                  a." + filter + "stackDetectID = b.detectID,   \
     832                  a." + filter + "ippObjID = b.ippObjID, \
     833                  a." + filter + "stackMetaID = " + str(stackmetaID) +  " \
     834                  WHERE a.objID = b.objID  AND b.imageID = " + str(imageID)
     835
     836            self.logger.infoPair('sql',sql)   
     837            self.scratchDb.execute(sql)
     838
     839        # out of the loops - give dataRelase to all       
    1082840        self.scratchDb.updateAllRows(tableName, "dataRelease", str(self.skychunk.dataRelease))
    1083841
    … …  
    1122880
    1123881        return True
    1124     '''
    1125     Insert objid (from dvo) into table
    1126     '''
    1127     def insertDvoIDs(self, table, filterName):
    1128         self.logger.infoPair("getting imageID for ","filter")
    1129         if (filterName == 'g.00000'):
    1130             self.header=self.gheader
    1131         if (filterName == 'r.00000'):
    1132             self.header=self.rheader
    1133         if (filterName == 'i.00000'):
    1134             self.header=self.iheader
    1135         if (filterName == 'z.00000'):
    1136             self.header=self.zheader
    1137         if (filterName == 'y.00000'):
    1138             self.header=self.yheader
    1139 
    1140         imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    1141         self.logger.infoPair("obtained","imageID")
    1142         self.logger.debug("Updating table '" + table + "' with DVO IDs...")
    1143         sql = "INSERT IGNORE INTO " + table + " ( \
    1144                objID ) \
    1145                SELECT (objID) FROM " + self.scratchDb.dvoDetectionTable + "  \
    1146                WHERE " + self.scratchDb.dvoDetectionTable + ".imageID = " + str(imageID)
    1147         self.logger.infoPair("sql",sql)
     882
     883    '''
     884    select objID (psps object ID) from dvo restricted to this set of imageIDs. also insert
     885    ippObjID and several constants (for a skycell): surveyID, skyCellId, dvoRegionID, dataRelease
     886    '''
     887    def selectDvoObjIDs(self):
     888
     889        print "starting selectDvoObjIDs"
     890
     891        sql  = "INSERT INTO StackObjectThin (objID, ippObjID, surveyID, skyCellID, dvoRegionID, dataRelease) "
     892        sql += "SELECT DISTINCT objID, ippObjID, "
     893        sql += str(self.surveyID) + ", "
     894        sql += str(self.skycell) + ", "
     895        sql += str(self.dvoRegionID) + ", "
     896        sql += str(self.skychunk.dataRelease)
     897
     898        sql += " FROM " + self.scratchDb.dvoDetectionTable
     899        sql += " WHERE ("
     900
     901        print "sql so far: " + sql
     902
     903        imageIDs = self.imageIDs.values()
     904        for i in range(len(imageIDs)):
     905            imageID = imageIDs[i]
     906            self.logger.infoPair("selecting imageID", imageID)
     907
     908            print "table: self.scratchDb.dvoDetectionTable"
     909            print "imageID: " + str(imageID)
     910
     911            sql += "(" + self.scratchDb.dvoDetectionTable + ".imageID = " + str(imageID) + ")"
     912            print "sql: " + sql
     913
     914            if (i < len(imageIDs) - 1):
     915                sql += " or "
     916
     917        print "done segment"
     918
     919        sql += ")"
     920
     921        print "SQL: " + sql
    1148922        self.scratchDb.execute(sql)
    1149    
    1150 
     923
     924    ## XXX '''
     925    ## XXX select objid (psps object ID) from dvo restricted to this set of imageIDs
     926    ## XXX '''
     927    ## XXX def selectDvoFilterIDs(self, table):
     928    ## XXX
     929    ## XXX     # XXX I am using imageID a lot: generate a filter-index list
     930    ## XXX     for filter in self.filters:
     931    ## XXX         self.header = self.headerSet[filter]
     932    ## XXX         imageIDgpc = self.header['IMAGEID']
     933    ## XXX         imageIDdvo = self.scratchDb.getImageIDFromExternID(imageIDgpc)
     934    ## XXX         self.logger.infoPair("selecting imageID", imageIDdvo)
     935    ## XXX
     936    ## XXX         sql  = "UPDATE " + table + " AS a, " + self.scratchDb.dvoDetectionTable " AS b SET "
     937    ## XXX
     938    ## XXX         sql += "a." + filter + "ippDetectID   = b.ippDetectID, " # eg, gippDetectID (from dvo.measure.detID)
     939    ## XXX         sql += "a." + filter + "stackDetectID = b.detectID "     # eg, gstackDetectID (from dvo.measure.extID)
     940    ## XXX         sql += "a." + filter + "stackMetaID   = " + imageIDgpc   # eg, gstackMetaID (from cmf.IMAGEID)
     941    ## XXX
     942    ## XXX         sql += "WHERE a.objID = b.objID "
     943    ## XXX         sql += "AND b.imageID = " + imageIDdvo
     944    ## XXX
     945    ## XXX         print "SQL: " + sql
     946    ## XXX         self.scratchDb.execute(sql)
     947
     948    '''
     949    Insert objid (from dvo) into table from main table
     950    '''
     951    def insertDvoIDs(self, table, mainTable):
     952
     953        fields = "objID, ippObjID, surveyID, skyCellID, dvoRegionID, dataRelease, "
     954
     955        for i in range(len(self.filters)):
     956            filter = self.filters[i]
     957            fields += filter + "ippDetectID, "
     958            fields += filter + "stackDetectID, "
     959            fields += filter + "stackMetaID" # careful here: do not add comma to last entry
     960            if (i < len(self.filters) - 1):
     961                fields += ", "
     962       
     963        sql  = "INSERT INTO " + table + " (" + fields + ") "
     964        sql += "SELECT " + fields + " FROM " + mainTable
     965        print "SQL: " + sql
     966        self.scratchDb.execute(sql)
    1151967
    1152968    '''
    1153969    Updates provided table with DVO IDs from DVO table
    1154970    '''
    1155     def updateDvoIDs(self, table, filterName):
     971    def updateDvoIDs(self, table):
    1156972        self.logger.infoPair("getting imageID for ","filter")
    1157973        imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    … …  
    12031019        self.tablesToExport=[]   
    12041020
    1205         if self.gstackID > 0:       
    1206             self.logger.infoPair("populating","gStackMeta")   
    1207             self.populateStackMeta("g.00000")
    1208             self.insertDvoIDs("StackObject","g.00000")
    1209             self.insertDvoIDs("StackModelFit","g.00000")
    1210             self.insertDvoIDs("StackApFlx","g.00000")
    1211             self.tablesToExport.append("gStackMeta")
    1212         if self.rstackID > 0:   
    1213             self.logger.infoPair("populating","rStackMeta")   
    1214             self.populateStackMeta("r.00000")
    1215             self.insertDvoIDs("StackObject","r.00000")
    1216             self.insertDvoIDs("StackModelFit","r.00000")
    1217             self.insertDvoIDs("StackApFlx","r.00000")
    1218             self.tablesToExport.append("rStackMeta")
    1219         if self.istackID > 0:   
    1220             self.logger.infoPair("populating","iStackMeta")   
    1221             self.populateStackMeta("i.00000")
    1222             self.insertDvoIDs("StackObject","i.00000")
    1223             self.insertDvoIDs("StackModelFit","i.00000")
    1224             self.insertDvoIDs("StackApFlx","i.00000")
    1225             self.tablesToExport.append("iStackMeta")
    1226         if self.zstackID > 0:   
    1227             self.logger.infoPair("populating","zStackMeta")   
    1228             self.populateStackMeta("z.00000")
    1229             self.insertDvoIDs("StackObject","z.00000")
    1230             self.insertDvoIDs("StackModelFit","z.00000")
    1231             self.insertDvoIDs("StackApFlx","z.00000")
    1232             self.tablesToExport.append("zStackMeta")
    1233         if self.ystackID > 0:   
    1234             self.logger.infoPair("populating","yStackMeta")   
    1235             self.populateStackMeta("y.00000")
    1236             self.insertDvoIDs("StackObject","y.00000")
    1237             self.insertDvoIDs("StackModelFit","y.00000")
    1238             self.insertDvoIDs("StackApFlx","y.00000")
    1239             self.tablesToExport.append("yStackMeta")
    1240 
    1241         self.logger.infoPair("populating ","StackObject")
    1242         # need to index on objid and ippdetectid  or it is stupidly slow
    1243         self.scratchDb.createIndex("StackObject", "objID")
    1244         #populate from dvo the (f)ippDetectID into StackObject 
    1245         self.populateStackIPPDetectIDFromDvo("StackObject",1)
    1246         #index the ippDetectids for the next step
    1247         self.scratchDb.createIndex("StackObject", "gippDetectID")
    1248         self.scratchDb.createIndex("StackObject", "rippDetectID")
    1249         self.scratchDb.createIndex("StackObject", "iippDetectID")
    1250         self.scratchDb.createIndex("StackObject", "zippDetectID")
    1251         self.scratchDb.createIndex("StackObject", "yippDetectID")
    1252         self.populateStackObject()
    1253         self.populateRandomsAndSkyCellID()
    1254         # stackObject should be done, pending a few NULL columns (need help)
     1021        # insertDvoIDs called below populates the given StackDetection
     1022        # tables with the DVO object IDs by querying the dvoDetection
     1023        # table for detections associated with the corresponding image
     1024        # IDs.  XXX EAM 20140729 : Is this an efficient method?
     1025
     1026        # EAM 20140730 : I have revised the StackObjectXX construction process.
     1027        # The challenge here is that we have dvo-generated objIDs and ippObjIDs
     1028        # for each stack detection in seperate rows, but we want to merge the
     1029        # 5 filter sets into a single set of rows.  The old code was
     1030        # relying on INSERT IGNORE, making it hard to catch errors,
     1031        # and probably not doing the insert very efficiently
     1032       
     1033        # Now we do a first pass with SELECT DISTINCT to get the
     1034        # complete set of objIDs which are associated with detections
     1035        # from one of the relevant images (ie, measure.imageID matches
     1036        # the set of image IDs). 
     1037
     1038        # once we have determined the complete set of desired objects,
     1039        # then we can use an update to set the per-field fields with
     1040        # data selected for each filter.  Once we have constructed
     1041        # this basic common information in StackObjectThin, then we
     1042        # can uses this table to seed the same rows in the other Stack
     1043        # tables
     1044
     1045        for filter in self.filters:
     1046            if self.stackIDs[filter] > 0:       
     1047                self.populateStackMeta(filter)
     1048
     1049        self.populateStackObjectThin()
     1050
     1051        self.populateStackObjectExtra()
     1052
     1053        # self.populateRandomsAndSkyCellID()
    12551054
    12561055        if self.stackType != "NIGHTLY_STACK":
    12571056
    12581057            self.logger.infoPair("populating ","StackModelFit")
    1259 
    1260             self.scratchDb.createIndex("StackModelFit", "objID")
    1261         #populate from dvo the (f)ippdetectid into stackModelFit
    1262             self.populateStackIPPDetectIDFromDvo("StackModelFit",0)
    1263         #index the ippDetectIds for the next step
    1264             self.scratchDb.createIndex("StackModelFit", "gippDetectID")
    1265             self.scratchDb.createIndex("StackModelFit", "rippDetectID")
    1266             self.scratchDb.createIndex("StackModelFit", "iippDetectID")
    1267             self.scratchDb.createIndex("StackModelFit", "zippDetectID")
    1268             self.scratchDb.createIndex("StackModelFit", "yippDetectID")
    1269         #cull the entries that should not be (how?)       
    1270             self.deleteNULLippDetectIDs("StackModelFit")
    1271         #populate stackModelFit
    1272             if self.gstackID > 0:
    1273                 self.logger.infoPair("populating g filter for stackModelFit, stackmetaid =", self.gstackID)
    1274                 self.populateStackModelFit("g")
    1275             if self.rstackID > 0:
    1276                 self.logger.infoPair("populating r filter for stackModelFit, stackmetaid =", self.rstackID)
    1277                 self.populateStackModelFit("r")
    1278             if self.istackID > 0:
    1279                 self.logger.infoPair("populating i filter for stackModelFit, stackmetaid =", self.istackID)
    1280                 self.populateStackModelFit("i")
    1281             if self.zstackID > 0:
    1282                 self.logger.infoPair("populating z filter for stackModelFit, stackmetaid =", self.zstackID)
    1283                 self.populateStackModelFit("z")
    1284             if self.ystackID > 0:
    1285                 self.logger.infoPair("populating y filter for stackModelFit, stackmetaid =", self.ystackID)
    1286                 self.populateStackModelFit("y")
    1287            
    1288             self.copyRandomsAndSkyCellIDFromStackObject("StackModelFit")
    1289  
    1290             self.logger.infoPair("populating ","StackApFlx")
    1291            
    1292             self.scratchDb.createIndex("StackApFlx", "objID")
    1293         #populate from dvo the (f)ippDetectID into StackApFlx
    1294             self.populateStackIPPDetectIDFromDvo("StackApFlx",0)
    1295         #index the ippDetectIDs for the next step
    1296             self.scratchDb.createIndex("StackApFlx", "gippDetectID")
    1297             self.scratchDb.createIndex("StackApFlx", "rippDetectID")
    1298             self.scratchDb.createIndex("StackApFlx", "iippDetectID")
    1299             self.scratchDb.createIndex("StackApFlx", "zippDetectID")
    1300             self.scratchDb.createIndex("StackApFlx", "yippDetectID")
    1301         #populate StackApFlx
    1302             self.deleteNULLippDetectIDs("StackApFlx")
    1303             self.populateStackApFlx()
    1304             self.copyRandomsAndSkyCellIDFromStackObject("StackApFlx")
    1305         #cull the entries that should not be (how?)
    1306        
     1058            self.populateStackModelFit("Exp", "PS_MODEL_EXP")
     1059            self.populateStackModelFit("DeV", "PS_MODEL_DEV")
     1060            self.populateStackModelFit("Ser", "PS_MODEL_SERSIC")
     1061
     1062            #self.populateStackModelPet("Ser", "PS_MODEL_SERSIC")
     1063
     1064            #self.logger.infoPair("populating ","StackApFlx")
     1065            #self.populateStackApFlx()
    13071066       
    13081067        self.logger.infoPair("populating","StackToImage")
    13091068        self.populateStackToImage()
    13101069       
    1311         self.setMinMaxObjID(["StackObject"])
    1312       #  self.updateStackTypeID("StackModelFit")
    1313 
    1314         ##if self.totalDetections < 1:
    1315         #self.logger.infoPair("populating","SkinnyObject")
    1316         self.populateSkinnyObject()
    1317 
    1318             ##self.logger.error("No detections to publish")
    1319             ##return False
     1070        # self.setMinMaxObjID(["StackObject"])
     1071        # self.updateStackTypeID("StackModelFit")
     1072
    13201073        self.tablesToExport.append("StackToImage")
    13211074        self.tablesToExport.append("StackObject")
    … …  
    13251078        self.logger.infoPair("finishing","populatePspsTables");
    13261079        return True
     1080
    13271081    '''
    13281082    overidding this method - use regex to trimoff letter before stack
    … …  
    13401094      self.logger.infoPair("Importing ST tables with table match expression: ", tableRE)
    13411095
    1342       # print "trying to read ", self.fits.getPath()
    1343 
    1344       # ST has 5 cmf files - all with the same table names. To counter this we do it like this.
    1345 
    1346       filters = ["g","r","i","z","y"]
    13471096      count = 0
    1348       for f in filters:
    1349           skip = 0
    1350           if (f == "g"):
    1351               if self.gstackID > 0: 
    1352                   fileName = self.gfits.getPath()
    1353               else:
    1354                   skip = 1
    1355           if (f == "r"):
    1356               if self.rstackID > 0:
    1357                   fileName = self.rfits.getPath()
    1358               else:
    1359                   skip = 1
    1360           if (f == "i"):
    1361               if self.istackID > 0:
    1362                   fileName = self.ifits.getPath()
    1363               else:
    1364                   skip = 1
    1365           if (f == "z"):
    1366               if self.zstackID > 0:
    1367                   fileName = self.zfits.getPath()
    1368               else:
    1369                   skip = 1
    1370           if (f == "y"):
    1371               if self.ystackID > 0:
    1372                   fileName = self.yfits.getPath()
    1373               else:
    1374                   skip = 1
    1375 
    1376           if skip == 1:
    1377               self.logger.infoPair("no files for filter" , f)
    1378           else:
    1379              self.logger.infoPair("using filename:",fileName)
     1097      for filter in self.filters:
     1098          if self.stackIDs[filter] <= 0: 
     1099              self.logger.infoPair("no files for filter" , filter)
     1100              continue
     1101
     1102          fileName = self.fits[filter].getPath()
    13801103         
    1381              try:
     1104          self.logger.infoPair("using filename:",fileName)
     1105         
     1106          try:
    13821107              tables = stilts.treads(fileName)
    1383              except:
     1108          except:
    13841109              self.logger.errorPair("STILTS could not import from", fileName)
    13851110              return False
    13861111             
    1387              #count = 0
    1388              for table in tables:
     1112          # count = 0
     1113          for table in tables:
    13891114             
    13901115              # print "import smf table ", table
    13911116              match = re.match(tableRE, table.name)
    1392              
    13931117              if not match: continue
    1394               self.logger.infoPair("Reading IPP table", f + table.name)
     1118
     1119              self.logger.infoPair("Reading IPP table", filter + table.name)
    13951120              table = stilts.tpipe(table, cmd='addcol table_index $0')
    1396                  
    13971121              table = stilts.tpipe(table, cmd='explodeall')
    13981122                 
    … …  
    14001124                 
    14011125              # drop any previous tables before import
    1402               self.scratchDb.dropTable(f + table.name)
     1126              self.scratchDb.dropTable(filter + table.name)
    14031127                 
    14041128              # IPP FITS files are littered with infinities, so remove these
    … …  
    14101134                 
    14111135              try:
    1412                   table.write(self.scratchDb.url + '#' + f + table.name)
     1136                  table.write(self.scratchDb.url + '#' + filter + table.name)
    14131137                  count = count + 1
    14141138              except:
    1415                   self.logger.exception("Problem writing table '" + f + table.name + "' to the database")
     1139                  self.logger.exception("Problem writing table '" + filter + table.name + "' to the database")
    14161140                     
    14171141      self.logger.infoPair("Done. Imported", "%d tables" % count)
Note: See TracChangeset for help on using the changeset viewer.