IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 7, 2014, 5:36:39 AM (12 years ago)
Author:
eugene
Message:

merge changes from trunk

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r36447 r36826  
    44import glob
    55import sys
     6
    67
    78import stilts
    … …  
    3738                 ippToPspsDb,
    3839                 scratchDb,
    39                  stackID,
     40                 skyID,
    4041                 batchID,
    4142                 useFullTables):
    … …  
    4849               ippToPspsDb,
    4950               scratchDb,
    50                stackID,
     51               skyID,
    5152               batchID,
    5253               "ST",
    53                gpc1Db.getStackStageCmf(skychunk.dvoLabel, stackID),
     54               "",
     55               #gpc1Db.getStackStageCmf(skychunk.dvoLabel, stackID),
    5456               useFullTables)
    5557
    5658       # self.printline = 0
    5759       # # self.testprint()
    58 
     60#       self.logger.infoPair("did I get", "here");
    5961       self.stackType = "DEEP_STACK" # TODO
    60 
     62       ## = stuff I commented out for pv2 stacks
     63       
     64       #heather tasks
     65
     66       # get a list of stackIDs
     67       self.logger.infoPair ("getting stackID for: ","g.00000")
     68       gstackID = gpc1Db.getStackIDFromSkyIDAndFilter( skychunk.dvoLabel, skyID, "g.00000")
     69       self.logger.infoPair ("getting stackID for: ","r.00000")
     70       rstackID = gpc1Db.getStackIDFromSkyIDAndFilter( skychunk.dvoLabel, skyID, "r.00000")
     71       self.logger.infoPair ("getting stackID for: ","i.00000")
     72       istackID = gpc1Db.getStackIDFromSkyIDAndFilter( skychunk.dvoLabel, skyID, "i.00000")
     73       self.logger.infoPair ("getting stackID for: ","z.00000")
     74       zstackID = gpc1Db.getStackIDFromSkyIDAndFilter( skychunk.dvoLabel, skyID, "z.00000")
     75       self.logger.infoPair ("getting stackID for: ","y.00000")
     76       ystackID = gpc1Db.getStackIDFromSkyIDAndFilter( skychunk.dvoLabel, skyID, "y.00000")
     77 #      self.logger.infoPair("g stackID ",gstackID)       
     78 #      self.logger.infoPair("r stackID ",rstackID)
     79 #      self.logger.infoPair("i stackID ",istackID)
     80 #      self.logger.infoPair("z stackID ",zstackID)
     81 #      self.logger.infoPair("y stackID ",ystackID)
     82 #      raise
     83       # from each stackget fits name from getStackStageCmf
     84       if gstackID > 0:
     85           self.logger.infoPair ("finding fits file for: ","g.00000")
     86           gfits = gpc1Db.getStackStageCmf(skychunk.dvoLabel, gstackID)
     87           self.gfits = gfits
     88       if rstackID > 0:   
     89           self.logger.infoPair ("finding fits file for: ","r.00000")
     90           rfits = gpc1Db.getStackStageCmf(skychunk.dvoLabel, rstackID)
     91           self.rfits = rfits
     92       if istackID > 0:   
     93           self.logger.infoPair ("finding fits file for: ","i.00000")
     94           ifits = gpc1Db.getStackStageCmf(skychunk.dvoLabel, istackID)
     95           self.ifits = ifits
     96       if zstackID > 0:   
     97           self.logger.infoPair ("finding fits file for: ","z.00000")
     98           zfits = gpc1Db.getStackStageCmf(skychunk.dvoLabel, zstackID)
     99           self.zfits = zfits
     100       if ystackID > 0:   
     101           self.logger.infoPair ("finding fits file for: ","y.00000")
     102           yfits = gpc1Db.getStackStageCmf(skychunk.dvoLabel, ystackID)
     103           self.yfits = yfits
     104
     105       #from each of those get self.gheader, self.rheader, etc.
     106       if gstackID > 0:   
     107           if gfits:
     108               gheader = gfits.getPrimaryHeader()
     109               if not gheader:
     110                   self.logger.errorPair("could not read FITS PHU for ",gstackID)
     111                   raise
     112               self.gheader = gheader
     113       if rstackID > 0:       
     114           if rfits:
     115               rheader = rfits.getPrimaryHeader()
     116               if not rheader:
     117                   self.logger.errorPair("could not read FITS PHU for ",rstackID)
     118                   raise
     119               self.rheader = rheader
     120       if istackID > 0:       
     121           if ifits:
     122               iheader = ifits.getPrimaryHeader()
     123               if not iheader:
     124                   self.logger.errorPair("could not read FITS PHU for ",istackID)
     125                   raise
     126               self.iheader = iheader
     127       if zstackID > 0:
     128           if zfits:
     129               zheader = zfits.getPrimaryHeader()
     130               if not zheader:
     131                   self.logger.errorPair("could not read FITS PHU for ",zstackID)
     132                   raise
     133               self.zheader = zheader
     134       if ystackID > 0:
     135           if yfits:
     136               yheader = yfits.getPrimaryHeader()
     137               if not yheader:
     138                   self.logger.errorPair("could not read FITS PHU for ",ystackID)
     139                   raise
     140               self.yheader = yheader
    61141       # get stack meta data
    62        meta = self.gpc1Db.getStackStageMeta(self.id)
     142       self.gstackID = gstackID
     143       self.rstackID = rstackID
     144       self.istackID = istackID     
     145       self.zstackID = zstackID
     146       self.ystackID = ystackID
     147
     148       metastackid = -999
     149       if gstackID > 0:
     150           metastackid = gstackID
     151       if rstackID > 0:
     152           metastackid = rstackID
     153       if istackID > 0:
     154           metastackid = istackID   
     155       if zstackID > 0:
     156           metastackid = zstackID
     157       if ystackID > 0:
     158           metastackid = ystackID
     159       #there is probably a better way to do this
     160       if metastackid < 0:
     161           self.logger.errorPair("can't find any stack ids...?? ","??")
     162           raise
     163   
     164       meta = self.gpc1Db.getStackStageMeta(metastackid) 
     165       ## this should be ok - it takes a stack_id and returns filter/skycell etc.
     166
     167
    63168       if not meta:
    64169           self.logger.errorPair("Could not get stack", "metadata")
    65170           raise
    66171
    67        self.filter = meta[0];
    68        self.filter = self.filter[0:1]
    69        self.filterID = self.scratchDb.getFilterID(self.filter)
     172       #self.filter = meta[0];
     173       #self.filter = self.filter[0:1]
     174       #self.filterID = self.scratchDb.getFilterID(self.filter)
    70175       self.skycell = meta[1];
    71176
    … …  
    75180       # we need 1133.081 for skycell, but store as an int, so instead store 1133081
    76181       # projection cell is just the 1133 bit
    77        # this is how it should be done
     182       # This Is how it should be done
    78183       #self.projectioncell = self.skycell[8:12]
    79184       #self.skycell = self.skycell[8:]
    … …  
    82187
    83188       # TODO this is the wrong way, but is consistent with SkyCell table in IN data
    84        self.skycell = self.skycell[8:12]
     189       self.skycell = self.skycell[8:]
    85190       self.projectioncell = self.skycell
    86191
    … …  
    94199
    95200       #self.expTime = gpc1Db.getStackExpTime(self.id)
    96        self.expTime = self.header['EXPTIME']
    97 
     201       
    98202       # delete PSPS tables
    99        self.scratchDb.dropTable("StackMeta")
    100        self.scratchDb.dropTable("StackDetection")
     203       self.logger.infoPair("dropping table:","gStackMeta")
     204       self.scratchDb.dropTable("gStackMeta")
     205       self.logger.infoPair("dropping table:","rStackMeta")
     206       self.scratchDb.dropTable("rStackMeta")
     207       self.logger.infoPair("dropping table:","iStackMeta")
     208       self.scratchDb.dropTable("iStackMeta")
     209       self.logger.infoPair("dropping table:","zStackMeta")
     210       self.scratchDb.dropTable("zStackMeta")
     211       self.logger.infoPair("dropping table:","yStackMeta")
     212       self.scratchDb.dropTable("yStackMeta")
     213       self.logger.infoPair("dropping table:","StackObject")
     214
     215       self.scratchDb.dropTable("StackObject")
     216       self.logger.infoPair("dropping table:","StackModelFit")
     217             
    101218       self.scratchDb.dropTable("StackModelFit")
     219       self.logger.infoPair("dropping table:","StackApFlx")
     220
    102221       self.scratchDb.dropTable("StackApFlx")
     222       self.logger.infoPair("dropping table:","StackToImage")
     223
    103224       self.scratchDb.dropTable("StackToImage")
    104        self.scratchDb.dropTable("SkinnyObject")
    105        #self.scratchDb.dropTable("ObjectCalColor")
    106        self.scratchDb.dropTable("StackDetectionCalib")
    107 
    108        # self.testprint()
     225             # self.testprint()
     226
     227       # for PV2 we will have (grizy) of stack meta and skychip     
     228
    109229
    110230       # delete IPP tables
    111        self.scratchDb.dropTable("SkyChip_psf")
    112        self.scratchDb.dropTable("SkyChip_xrad")
    113        self.scratchDb.dropTable("SkyChip_xfit")
    114        self.scratchDb.dropTable("SkyChip_xsrc")
     231       self.scratchDb.dropTable("gSkyChip_psf")
     232       self.scratchDb.dropTable("gSkyChip_xrad")
     233       self.scratchDb.dropTable("gSkyChip_xfit")
     234       self.scratchDb.dropTable("gSkyChip_xsrc")
     235       self.scratchDb.dropTable("rSkyChip_psf")
     236       self.scratchDb.dropTable("rSkyChip_xrad")
     237       self.scratchDb.dropTable("rSkyChip_xfit")
     238       self.scratchDb.dropTable("rSkyChip_xsrc")
     239       self.scratchDb.dropTable("iSkyChip_psf")
     240       self.scratchDb.dropTable("iSkyChip_xrad")
     241       self.scratchDb.dropTable("iSkyChip_xfit")
     242       self.scratchDb.dropTable("iSkyChip_xsrc")
     243       self.scratchDb.dropTable("zSkyChip_psf")
     244       self.scratchDb.dropTable("zSkyChip_xrad")
     245       self.scratchDb.dropTable("zSkyChip_xfit")
     246       self.scratchDb.dropTable("zSkyChip_xsrc")
     247       self.scratchDb.dropTable("ySkyChip_psf")
     248       self.scratchDb.dropTable("ySkyChip_xrad")
     249       self.scratchDb.dropTable("ySkyChip_xfit")
     250       self.scratchDb.dropTable("ySkyChip_xsrc")
    115251
    116252       # create an output filename, which is {stackID}.FITS
     253       self.logger.infoPair( "self.id", self.id)
     254       self.logger.infoPair ("self.localOutPath",self.localOutPath)
    117255       self.outputFitsFile = "%08d.FITS" % self.id
    118256       self.outputFitsPath = "%s/%s" % (self.localOutPath, self.outputFitsFile)
    119 
     257       self.logger.infoPair("self.outputFitsFile",self.outputFitsFile)
     258       
    120259       # set some constants
    121260       self.historyModNum = "0"
    122261
    123262       # insert what we know about this stack batch into the stack table
    124        self.ippToPspsDb.insertStackMeta(self.batchID, self.filter, self.stackType)
     263       self.ippToPspsDb.insertStackMeta(self.batchID, "x" , self.stackType)
    125264
    126265       # insert sourceID/imageID combo so DVO can look it up
    127        if not self.useFullTables:
    128            self.scratchDb.insertNewDvoExternID(self.header['SOURCEID'], self.header['IMAGEID'])
     266       ##if not self.useFullTables:
     267       ##    self.scratchDb.insertNewDvoExternID(self.header['SOURCEID'], self.header['IMAGEID'])
    129268
    130269       # self.testprint()
    … …  
    135274       self.logger.infoPair("Skycell", "%s" % self.skycell)
    136275       self.logger.infoPair("Projectioncell", "%s" % self.projectioncell)
    137        self.logger.infoPair("Filter", "%s" % self.filter)
     276       ##self.logger.infoPair("Filter", "%s" % self.filter)
    138277
    139278    '''
    … …  
    142281    def updateStackMetaID(self, table):
    143282
    144         sql = "UPDATE " + table + "  SET stackMetaID=" + str(self.id)
     283        sql = "UPDATE " + table + "  SET gstackMetaID=" + str(self.gstackID) + " \
     284              , rstackMetaID=" + str(self.rstackID) + " \
     285              , istackMetaID=" + str(self.istackID) + " \
     286              , zstackMetaID=" + str(self.zstackID) + " \
     287              , ystackMetaID=" + str(self.ystackID)   
     288     
    145289        self.scratchDb.execute(sql)
    146290
    … …  
    161305    Updates aperture fluxes for StackApFkx table
    162306    '''
    163     def updateApFlxs(self, prefix, psfCondition):
     307    def updateModelFitFlxs(self, prefix, psfCondition, tablename, filter):
    164308        #properly -999 these to start with:
    165 
    166         sql = "UPDATE StackApFlx AS a, SkyChip_xrad AS b SET \
    167         "+prefix+"flxR1=-999, \
    168         "+prefix+"flxR1Err=-999, \
    169         "+prefix+"flxR1Std=-999, \
    170         "+prefix+"flxR1Fill=-999, \
    171         "+prefix+"flxR2=-999, \
    172         "+prefix+"flxR2Err=-999, \
    173         "+prefix+"flxR2Std=-999, \
    174         "+prefix+"flxR2Fill=-999, \
    175         "+prefix+"flxR3=-999, \
    176         "+prefix+"flxR3Err=-999, \
    177         "+prefix+"flxR3Std=-999, \
    178         "+prefix+"flxR3Fill=-999, \
    179         "+prefix+"flxR4=-999, \
    180         "+prefix+"flxR4Err=-999, \
    181         "+prefix+"flxR4Std=-999, \
    182         "+prefix+"flxR4Fill=-999, \
    183         "+prefix+"flxR5=-999, \
    184         "+prefix+"flxR5Err=-999, \
    185         "+prefix+"flxR5Std=-999, \
    186         "+prefix+"flxR5Fill=-999, \
    187         "+prefix+"flxR6=-999, \
    188         "+prefix+"flxR6Err=-999, \
    189         "+prefix+"flxR6Std=-999, \
    190         "+prefix+"flxR6Fill=-999, \
    191         "+prefix+"flxR7=-999, \
    192         "+prefix+"flxR7Err=-999, \
    193         "+prefix+"flxR7Std=-999, \
    194         "+prefix+"flxR7Fill=-999, \
    195         "+prefix+"flxR8=-999, \
    196         "+prefix+"flxR8Err=-999, \
    197         "+prefix+"flxR8Std=-999, \
    198         "+prefix+"flxR8Fill=-999, \
    199         "+prefix+"flxR9=-999, \
    200         "+prefix+"flxR9Err=-999, \
    201         "+prefix+"flxR9Std=-999, \
    202         "+prefix+"flxR9Fill=-999, \
    203         "+prefix+"flxR10=-999, \
    204         "+prefix+"flxR10Err=-999, \
    205         "+prefix+"flxR10Std=-999, \
    206         "+prefix+"flxR10Fill=-999 \
    207         WHERE a.ippDetectID=b.IPP_IDET "
     309        f = filter
     310        if tablename == 'StackModelFit':
     311            sql = "UPDATE " + tablename + " AS a, "+f+"SkyChip_xrad AS b SET \
     312        "+f+prefix+"flxR1=-999, \
     313        "+f+prefix+"flxR1Err=-999, \
     314        "+f+prefix+"flxR1Std=-999, \
     315        "+f+prefix+"flxR1Fill=-999, \
     316        "+f+prefix+"flxR2=-999, \
     317        "+f+prefix+"flxR2Err=-999, \
     318        "+f+prefix+"flxR2Std=-999, \
     319        "+f+prefix+"flxR2Fill=-999, \
     320        "+f+prefix+"flxR3=-999, \
     321        "+f+prefix+"flxR3Err=-999, \
     322        "+f+prefix+"flxR3Std=-999, \
     323        "+f+prefix+"flxR3Fill=-999, \
     324        "+f+prefix+"flxR4=-999, \
     325        "+f+prefix+"flxR4Err=-999, \
     326        "+f+prefix+"flxR4Std=-999, \
     327        "+f+prefix+"flxR4Fill=-999, \
     328        "+f+prefix+"flxR5=-999, \
     329        "+f+prefix+"flxR5Err=-999, \
     330        "+f+prefix+"flxR5Std=-999, \
     331        "+f+prefix+"flxR5Fill=-999, \
     332        "+f+prefix+"flxR6=-999, \
     333        "+f+prefix+"flxR6Err=-999, \
     334        "+f+prefix+"flxR6Std=-999, \
     335        "+f+prefix+"flxR6Fill=-999, \
     336        "+f+prefix+"flxR7=-999, \
     337        "+f+prefix+"flxR7Err=-999, \
     338        "+f+prefix+"flxR7Std=-999, \
     339        "+f+prefix+"flxR7Fill=-999, \
     340        "+f+prefix+"flxR8=-999, \
     341        "+f+prefix+"flxR8Err=-999, \
     342        "+f+prefix+"flxR8Std=-999, \
     343        "+f+prefix+"flxR8Fill=-999, \
     344        "+f+prefix+"flxR9=-999, \
     345        "+f+prefix+"flxR9Err=-999, \
     346        "+f+prefix+"flxR9Std=-999, \
     347        "+f+prefix+"flxR9Fill=-999, \
     348        "+f+prefix+"flxR10=-999, \
     349        "+f+prefix+"flxR10Err=-999, \
     350        "+f+prefix+"flxR10Std=-999, \
     351        "+f+prefix+"flxR10Fill=-999 \
     352        WHERE a."+f+"ippDetectID=b.IPP_IDET "
    208353        #self.logger.infoPair("sql", sql)
    209         self.scratchDb.execute(sql)
     354            self.scratchDb.execute(sql)
    210355
    211356
    212357        #we have variable numbers of these columns. find out which are in use
    213         sql = "DESCRIBE SkyChip_xrad 'aper_fill_%'"
     358        sql = "DESCRIBE "+f+"SkyChip_xrad 'aper_fill_%'"
    214359        rs = self.scratchDb.executeQuery(sql)
    215360        rs.first()
    … …  
    225370
    226371        numbers = []
     372        min = 1
     373        max = 10
     374        if tablename == 'StackApFlx':
     375            min = 3
     376            max = 5
    227377        for column in columns:
    228378            number = re.sub("APER_FILL_","",column)
    229             if (int(number) >= 1 and int(number) <=10):
     379            if (int(number) >= min and int(number) <=max):
    230380                numbers.append(number)
    231381                self.logger.infoPair("Aperture Numbers",number)
    232382
    233383        #generate the sql to do the necessary ops on the columns   
    234         sql = "UPDATE StackApFlx AS a, SkyChip_xrad AS b SET "
     384        sql = "UPDATE " + tablename + " AS a, "+f+"SkyChip_xrad AS b SET "
    235385        cnt =0
     386        exptime = self.safeDictionaryAccess(self.header, 'EXPTIME')
    236387        for number in numbers:
    237388            if (cnt>0):
    238389                sql=sql+" , "
    239             sql=sql+prefix+"flxR"+number+"=b.APER_FLUX_"+number +" / " + str(self.expTime) + ", "
    240             sql=sql+prefix+"flxR"+number+"Err=b.APER_FLUX_ERR_"+number +" / " + str(self.expTime) + ", "
    241             sql=sql+prefix+"flxR"+number+"Std=b.APER_FLUX_STDEV_"+number +" / " + str(self.expTime) + ", "
    242             sql=sql+prefix+"flxR"+number+"Fill=b.APER_FILL_"+number + " "
     390            sql=sql+f+prefix+"flxR"+number+"=b.APER_FLUX_"+number +" / " + str(exptime) + ", "
     391            sql=sql+f+prefix+"flxR"+number+"Err=b.APER_FLUX_ERR_"+number +" / " + str(exptime) + ", "
     392            sql=sql+f+prefix+"flxR"+number+"Std=b.APER_FLUX_STDEV_"+number +" / " + str(exptime) + ", "
     393            sql=sql+f+prefix+"flxR"+number+"Fill=b.APER_FILL_"+number + " "
    243394            cnt=cnt+1
    244395           
    245         sql=sql+"WHERE a.ippDetectID=b.IPP_IDET AND  "+psfCondition     
    246         self.scratchDb.execute(sql)
    247 
    248         #self.logger.infoPair("sql",sql)
    249 
    250         #sql = "UPDATE StackApFlx AS a, SkyChip_xrad AS b SET \
    251         #"+prefix+"flxR1=b.APER_FLUX_1 / " + str(self.expTime) + ", \
    252         #"+prefix+"flxR1Err=b.APER_FLUX_ERR_1 / " + str(self.expTime) + ", \
    253         #"+prefix+"flxR1Std=b.APER_FLUX_STDEV_1 / " + str(self.expTime) + ", \
    254         #"+prefix+"flxR1Fill=b.APER_FILL_1, \
    255         #"+prefix+"flxR2=b.APER_FLUX_2 / " + str(self.expTime) + ", \
    256         ##"+prefix+"flxR2Err=b.APER_FLUX_ERR_2 / " + str(self.expTime) + ", \
    257         #"+prefix+"flxR2Std=b.APER_FLUX_STDEV_2 / " + str(self.expTime) + ", \
    258         #"+prefix+"flxR2Fill=b.APER_FILL_2, \
    259         #"+prefix+"flxR3=b.APER_FLUX_3 / " + str(self.expTime) + ", \
    260         #"+prefix+"flxR3Err=b.APER_FLUX_ERR_3 / " + str(self.expTime) + ", \
    261         #"+prefix+"flxR3Std=b.APER_FLUX_STDEV_3 / " + str(self.expTime) + ", \
    262         #"+prefix+"flxR3Fill=b.APER_FILL_3, \
    263         #"+prefix+"flxR4=b.APER_FLUX_4 / " + str(self.expTime) + ", \
    264         #"+prefix+"flxR4Err=b.APER_FLUX_ERR_4 / " + str(self.expTime) + ", \
    265         #"+prefix+"flxR4Std=b.APER_FLUX_STDEV_4 / " + str(self.expTime) + ", \
    266         #"+prefix+"flxR4Fill=b.APER_FILL_4, \
    267         #"+prefix+"flxR5=b.APER_FLUX_5 / " + str(self.expTime) + ", \
    268         #"+prefix+"flxR5Err=b.APER_FLUX_ERR_5 / " + str(self.expTime) + ", \
    269         #"+prefix+"flxR5Std=b.APER_FLUX_STDEV_5 / " + str(self.expTime) + ", \
    270         #"+prefix+"flxR5Fill=b.APER_FILL_5, \
    271         #"+prefix+"flxR6=b.APER_FLUX_6 / " + str(self.expTime) + ", \
    272         #"+prefix+"flxR6Err=b.APER_FLUX_ERR_6 / " + str(self.expTime) + ", \
    273         #"+prefix+"flxR6Std=b.APER_FLUX_STDEV_6 / " + str(self.expTime) + ", \
    274         #"+prefix+"flxR6Fill=b.APER_FILL_6, \
    275         #"+prefix+"flxR7=b.APER_FLUX_7 / " + str(self.expTime) + ", \
    276         #"+prefix+"flxR7Err=b.APER_FLUX_ERR_7 / " + str(self.expTime) + ", \
    277         #"+prefix+"flxR7Std=b.APER_FLUX_STDEV_7 / " + str(self.expTime) + ", \
    278         #"+prefix+"flxR7Fill=b.APER_FILL_7, \
    279         #"+prefix+"flxR8=b.APER_FLUX_8 / " + str(self.expTime) + ", \
    280         #"+prefix+"flxR8Err=b.APER_FLUX_ERR_8 / " + str(self.expTime) + ", \
    281         #"+prefix+"flxR8Std=b.APER_FLUX_STDEV_8 / " + str(self.expTime) + ", \
    282         #"+prefix+"flxR8Fill=b.APER_FILL_8, \
    283         #"+prefix+"flxR9=b.APER_FLUX_9 / " + str(self.expTime) + ", \
    284         #"+prefix+"flxR9Err=b.APER_FLUX_ERR_9 / " + str(self.expTime) + ", \
    285         #"+prefix+"flxR9Std=b.APER_FLUX_STDEV_9 / " + str(self.expTime) + ", \
    286         #"+prefix+"flxR9Fill=b.APER_FILL_9, \
    287         #"+prefix+"flxR10=b.APER_FLUX_10 / " + str(self.expTime) + ", \
    288         #"+prefix+"flxR10Err=b.APER_FLUX_ERR_10 / " + str(self.expTime) + ", \
    289         #"+prefix+"flxR10Std=b.APER_FLUX_STDEV_10 / " + str(self.expTime) + ", \
    290         #"+prefix+"flxR10Fill=b.APER_FILL_10 \
    291         #WHERE a.ippDetectID=b.IPP_IDET AND b.PSF_FWHM "+psfCondition
    292 
    293         #self.scratchDb.execute(sql)
     396        sql=sql+"WHERE a."+f+"ippDetectID=b.IPP_IDET AND  "+psfCondition   
     397        self.logger.infoPair("sql",sql)
     398        self.scratchDb.execute(sql)
     399
    294400
    295401    '''
    296402    Updates parameters for a particular model in the StackModelFit table
    297403    '''
    298     def updateModelFit(self, model, ippModelType):
    299 
    300         if model == "ser":
    301             modelLong = "sersic"
    302         else:
    303             modelLong = model;
    304 
    305         #does it have the EXT_COVAR in there?
    306 
    307         sql = "DESCRIBE SkyChip_xfit 'EXT_COVAR_%'"
     404    def updateModelFit(self, model, ippModelType, filter, exptime):
     405        f = filter
     406 
     407 # idk what to do about PET
     408
     409        sql = "DESCRIBE "+f+"SkyChip_xfit 'EXT_COVAR_%'"
    308410        rs = self.scratchDb.executeQuery(sql)
    309411        rs.first()
    310412        hasResult = rs.next()
    311         if hasResult:
    312            print "EXT_COVARs exist"
    313         else:
    314            print "No EXT_COVARS here"
    315 
    316         ext_covar_sql = ""
    317  
    318         if (hasResult):
    319             ext_covar_sql = ", "+modelLong+"Covar11=b.EXT_COVAR_00_00,  \
    320             "+modelLong+"Covar12=b.EXT_COVAR_00_01,  \
    321             "+modelLong+"Covar13=b.EXT_COVAR_00_02,  \
    322             "+modelLong+"Covar14=b.EXT_COVAR_00_03,  \
    323             "+modelLong+"Covar15=b.EXT_COVAR_00_04,  \
    324             "+modelLong+"Covar16=b.EXT_COVAR_00_05,  \
    325             "+modelLong+"Covar17=b.EXT_COVAR_00_06,  \
    326             "+modelLong+"Covar22=b.EXT_COVAR_01_01,  \
    327             "+modelLong+"Covar23=b.EXT_COVAR_01_02,  \
    328             "+modelLong+"Covar24=b.EXT_COVAR_01_03,  \
    329             "+modelLong+"Covar25=b.EXT_COVAR_01_04,  \
    330             "+modelLong+"Covar26=b.EXT_COVAR_01_05,  \
    331             "+modelLong+"Covar27=b.EXT_COVAR_01_06,  \
    332             "+modelLong+"Covar33=b.EXT_COVAR_02_02,  \
    333             "+modelLong+"Covar34=b.EXT_COVAR_02_03,  \
    334             "+modelLong+"Covar35=b.EXT_COVAR_02_04,  \
    335             "+modelLong+"Covar36=b.EXT_COVAR_02_05,  \
    336             "+modelLong+"Covar37=b.EXT_COVAR_02_06,  \
    337             "+modelLong+"Covar44=b.EXT_COVAR_03_03,  \
    338             "+modelLong+"Covar45=b.EXT_COVAR_03_04,  \
    339             "+modelLong+"Covar46=b.EXT_COVAR_03_05,  \
    340             "+modelLong+"Covar47=b.EXT_COVAR_03_06,  \
    341             "+modelLong+"Covar55=b.EXT_COVAR_04_04,  \
    342             "+modelLong+"Covar56=b.EXT_COVAR_04_05,  \
    343             "+modelLong+"Covar57=b.EXT_COVAR_04_06,  \
    344             "+modelLong+"Covar66=b.EXT_COVAR_05_05,  \
    345             "+modelLong+"Covar67=b.EXT_COVAR_05_06,  \
    346             "+modelLong+"Covar77=b.EXT_COVAR_06_06"
    347        
    348        
    349 
    350 
    351         sql = "UPDATE StackModelFit AS a, SkyChip_xfit AS b SET \
    352         "+model+"Radius=b.EXT_WIDTH_MAJ,  \
    353         "+model+"Flux=POW(10, -0.4 * b.EXT_INST_MAG) / " + str(self.expTime) + " ,  \
    354         "+model+"FluxErr=ABS(b.EXT_INST_MAG_SIG) * POW(10, -0.4 * b.EXT_INST_MAG) / " + str(self.expTime) + " / 1.085736, \
    355         "+model+"Ab=b.EXT_WIDTH_MAJ/b.EXT_WIDTH_MIN, \
    356         "+model+"Phi=b.EXT_THETA  \
    357         "+ext_covar_sql+"  \
    358         WHERE a.ippDetectID=b.IPP_IDET AND b.MODEL_TYPE = '"+ippModelType+"'"
     413
     414
     415
     416        sql = "UPDATE StackModelFit AS a, " + f + "SkyChip_xfit AS b SET \
     417        "+f+model+"Radius=b.EXT_WIDTH_MAJ,  \
     418        "+f+model+"Flux=POW(10, -0.4 * b.EXT_INST_MAG) / " + str(exptime) + " ,  \
     419        "+f+model+"FluxErr=ABS(b.EXT_INST_MAG_SIG) * POW(10, -0.4 * b.EXT_INST_MAG) / " + str(exptime) + " / 1.085736, \
     420        "+f+model+"Ab=b.EXT_WIDTH_MAJ/b.EXT_WIDTH_MIN, \
     421        "+f+model+"Phi=b.EXT_THETA  \
     422          \
     423        WHERE a."+f+"ippDetectID=b.IPP_IDET AND b.MODEL_TYPE = '"+ippModelType+"'"
    359424
    360425        print sql
    361426        self.scratchDb.execute(sql)
    362427
     428
     429
    363430        # sersic fit has an extra parameter
    364         if (ippModelType == "PS_MODEL_SERSIC" and hasResult > 0):
    365             sql = "UPDATE StackModelFit AS a, SkyChip_xfit AS b SET \
    366             "+modelLong+"Covar18=b.EXT_COVAR_00_07,  \
    367             "+modelLong+"Covar28=b.EXT_COVAR_01_07,  \
    368             "+modelLong+"Covar38=b.EXT_COVAR_02_07,  \
    369             "+modelLong+"Covar48=b.EXT_COVAR_03_07,  \
    370             "+modelLong+"Covar58=b.EXT_COVAR_04_07,  \
    371             "+modelLong+"Covar68=b.EXT_COVAR_05_07,  \
    372             "+modelLong+"Covar78=b.EXT_COVAR_06_07,  \
    373             "+modelLong+"Covar88=b.EXT_COVAR_07_07,   \
    374             "+"serNu=b.EXT_PAR_07,   \
    375             "+"serNuErr=SQRT(EXT_COVAR_07_07)  \
    376             WHERE a.ippDetectID=b.IPP_IDET AND b.MODEL_TYPE = '"+ippModelType+"'"
    377 
     431        if (ippModelType == "PS_MODEL_SERSIC"):
     432            extra_sql = ""
     433            if hasResult:
     434                extra_sql = ","+f+"serNuErr=SQRT(EXT_COVAR_07_07)"
     435            sql = "UPDATE StackModelFit AS a, "+ f+ "SkyChip_xfit AS b SET \
     436            "+f+"serNu=b.EXT_PAR_07   \
     437            "+extra_sql+" \
     438            WHERE a."+f+"ippDetectID=b.IPP_IDET AND b.MODEL_TYPE = '"+ippModelType+"'"
     439#           "+f+"serNuErr=SQRT(EXT_COVAR_07_07)  \
     440            self.logger.infoPair("sql",sql)
    378441            self.scratchDb.execute(sql)
    379442
    … …  
    382445    Populates the StackMeta table, mainly from dictionary values found in IPP FITS header
    383446    '''
    384     def populateStackMeta(self):
     447    def populateStackMeta(self,filterName):
    385448
    386449        self.logger.infoPair("Procesing table", "StackMeta")
     450
     451        # this should work : set header into (grizy)header and run from there
     452        if filterName == 'g.00000':
     453            f = "g"
     454            self.header = self.gheader
     455            tablename = 'gStackMeta'
     456            stackmetaid = self.gstackID
     457        if filterName == 'r.00000':
     458            f = "r"
     459            tablename = 'rStackMeta'
     460            self.header = self.rheader
     461            stackmetaid = self.rstackID
     462        if filterName == 'i.00000':
     463            f = "i"
     464            tablename = 'iStackMeta'
     465            self.header = self.iheader
     466            stackmetaid = self.istackID
     467        if filterName == 'z.00000':
     468            f = "z"
     469            tablename = 'zStackMeta'
     470            self.header = self.zheader
     471            stackmetaid = self.zstackID
     472        if filterName == 'y.00000':
     473            f = "y"
     474            tablename = 'yStackMeta'
     475            self.header = self.yheader
     476            stackmetaid = self.ystackID
    387477
    388478        self.fwhm_maj    = self.safeDictionaryAccess(self.header, 'FWHM_MAJ')
    … …  
    396486        # print "psfmodel    = ", self.psfmodel
    397487
    398         sql = "INSERT INTO StackMeta (\
     488        #make a table
     489
     490        filterid = self.scratchDb.getFilterID(f)
     491        self.logger.infoPair("filterid is ",str(filterid))
     492
     493        sql = "CREATE TABLE " + tablename + " LIKE StackMeta"
     494        try: self.scratchDb.execute(sql)
     495        except: pass
     496
     497        sql = "INSERT INTO " + tablename + " (\
    399498        stackMetaID \
    400         ,skycellID \
     499        ,filterID \
     500        ,skyCellID \
    401501        ,photoCalID \
    402502        ,photoZero \
    … …  
    418518        ,pc002002 \
    419519         ) VALUES ( \
    420         " + str(self.id) + " \
     520        " + str(stackmetaid) + " \
     521        , " + str(filterid) + "  \
    421522        ," + self.skycell + " \
    422523        ," + str(self.scratchDb.getPhotoCalID(self.header['IMAGEID'])) + " \
    423524        ," + self.header['FPA.ZP'] + " \
    424         ," + self.expTime + " \
     525        ," + self.header['EXPTIME'] + " \
    425526        ,'" + self.psfmodel   + "' \
    426527        ," + str(self.fwhm_maj)    + " \
    … …  
    440541        )"
    441542        self.scratchDb.execute(sql)
    442         self.scratchDb.updateAllRows("StackMeta", "batchID", str(self.batchID))
    443         self.scratchDb.updateAllRows("StackMeta", "surveyID", str(self.surveyID))
    444         self.scratchDb.updateFilterID("StackMeta", self.filter)
    445         self.scratchDb.updateAllRows("StackMeta", "dataRelease", str(self.skychunk.dataRelease))
    446         self.updateStackTypeID("StackMeta")
    447 
    448     '''
    449     Populates the StackDetection table
    450     '''
    451     def populateStackDetection(self):
    452 
    453         self.logger.infoPair("Procesing table", "StackDetection")
    454 
    455         # insert all the detections
    456         sql = "INSERT INTO StackDetection (\
    457                ippDetectID \
    458                ,skyCellID \
    459                ,projectionCellID \
    460                ,xPos \
    461                ,yPos \
    462                ,xPosErr \
    463                ,yPosErr \
    464                ,psfFlux \
    465                ,psfFluxErr \
    466                ,peakFlux \
    467                ,sky \
    468                ,skyErr \
    469                ,sgSep \
    470                ,psfWidMajor \
    471                ,psfWidMinor \
    472                ,psfTheta \
    473                ,psfLikelihood \
    474                ,infoFlag \
    475                ,psfQf \
    476                ,psfQfPerfect \
    477                ,psfChiSq \
    478                ,momentXX \
    479                ,momentXY \
    480                ,momentYY \
    481                ,momentM3C \
    482                ,momentM3S \
    483                ,momentM4C \
    484                ,momentM4S \
    485                ,momentR1 \
    486                ,momentRH \
    487                ,apFlux \
    488                ,apFluxErr \
    489                ,kronFlux \
    490                ,kronFluxErr \
    491                ,kronRad \
    492                ,nFrames \
    493                ,assocDate \
    494                ,historyModNum \
    495                ) \
    496                SELECT \
    497                IPP_IDET \
    498                ," + self.skycell + " \
    499                ," + self.projectioncell + " \
    500                ,X_PSF \
    501                ,Y_PSF \
    502                ,X_PSF_SIG \
    503                ,Y_PSF_SIG \
    504                ,PSF_INST_FLUX / " + str(self.expTime) + " \
    505                ,PSF_INST_FLUX_SIG / " + str(self.expTime) + " \
    506                ,POW(10.0, (-0.4*PEAK_FLUX_AS_MAG)) / " + str(self.expTime) + " \
    507                ,SKY / " + str(self.expTime) + " \
    508                ,SKY_SIGMA / " + str(self.expTime) + " \
    509                ,EXT_NSIGMA \
    510                ,PSF_MAJOR \
    511                ,PSF_MINOR \
    512                ,PSF_THETA \
    513                ,psfLikelihood(EXT_NSIGMA) \
    514                , FLAGS2 << 32 | FLAGS \
    515                ,PSF_QF \
    516                ,PSF_QF_PERFECT \
    517                ,PSF_CHISQ / PSF_NDOF \
    518                ,MOMENTS_XX \
    519                ,MOMENTS_XY \
    520                ,MOMENTS_YY \
    521                ,MOMENTS_M3C \
    522                ,MOMENTS_M3S \
    523                ,MOMENTS_M4C \
    524                ,MOMENTS_M4S \
    525                ,MOMENTS_R1 \
    526                ,MOMENTS_RH \
    527                ,POW(10.0, -0.4*AP_MAG) / " + str(self.expTime) + " \
    528                ,NULL \
    529                ,KRON_FLUX / " + str(self.expTime) + " \
    530                ,KRON_FLUX_ERR / " + str(self.expTime) + " \
    531                ,MOMENTS_R1 * 2.5 \
    532                ,N_FRAMES \
    533                , '" + self.dateStr + "' \
    534                ," + self.historyModNum + " \
    535                FROM SkyChip_psf"
    536 
    537 # these were used above (left over from before PSF_INST_FLUX, PSF_INST_FLUX_SIG were available?
    538 #               ,POW(10.0, (-0.4*PSF_INST_MAG)) / " + str(self.expTime) + "
    539 #               ,ABS((PSF_INST_MAG_SIG*(POW(10.0, (-0.4*PSF_INST_MAG)) / " + str(self.expTime) + ")) / 1.085736)
    540 #               ,POW(10.0, -0.4*AP_MAG) / " + str(self.expTime) + "
    541 
    542 # I need a way to choose the sql above based on the cmf version: V3 (LAP.PV1) does not have AP_FLUX
    543 #               ,AP_FLUX / " + str(self.expTime) + "
    544 
    545         # print "sql: ", sql
    546         # response = raw_input("ready to insert stack det ")
    547 
    548         self.scratchDb.execute(sql)
    549 
    550         #it is possible to drop some detections from dvo (that are present in the cmf). when that happens we get a 0 for objid
     543
     544
     545        self.scratchDb.updateAllRows(tablename, "batchID", str(self.batchID))
     546        self.scratchDb.updateAllRows(tablename, "surveyID", str(self.surveyID))
     547    #    self.scratchDb.updateFilterID(tablename, self.scratchDb.getFilterID(filterName))
     548        self.scratchDb.updateAllRows(tablename, "dataRelease", str(self.skychunk.dataRelease))
     549        self.updateStackTypeID(tablename)
     550
     551    '''
     552    Populates the StackObject table
     553    '''
     554    def populateStackObject(self):
     555
     556        self.logger.infoPair("Procesing table", "StackObject")
     557       
     558        self.logger.infoPair("inserting non-filter dependent items into", "StackObject")
     559
     560        #this is dvo crap
     561        #sql = "INSERT INTO StackObject(\
     562        #      objID, \
     563        #      gcobjID, \
     564        #      ippObjID, \
     565        #      surveyID, \
     566        #      skyCellID, \
     567        #      randomStackObjID, \
     568        #      stackDetectRowID, \
     569        #      dvoRegionID, \
     570        #      dataRelease) SELECT \
     571        #      -999,
     572        #      -999,
     573        #      -999,
     574        #      ,
     575             
     576       
     577       
     578
     579        self.logger.infoPair("inserting filter dependent cmf items into", "StackObject")
     580        filters =['g','r','i','z','y']
     581        for f in filters:
     582          skip = 0
     583          if (f == "g"):
     584              self.logger.infoPair("gstackID = ",self.gstackID)
     585              if self.gstackID > 0: 
     586                  stackid = self.gstackID
     587                  exptime = self.gheader['EXPTIME']
     588              else:
     589                  skip = 1
     590          if (f == "r"):
     591              self.logger.infoPair("rstackID = ",self.rstackID)
     592              if self.rstackID > 0:
     593                  stackid = self.rstackID
     594                  exptime = self.rheader['EXPTIME']
     595              else:
     596                  skip = 1
     597          if (f == "i"):
     598              self.logger.infoPair("istackID = ",self.istackID)
     599              if self.istackID > 0:
     600                  stackid = self.istackID
     601                  exptime = self.iheader['EXPTIME']
     602              else:
     603                  skip = 1
     604          if (f == "z"):
     605              self.logger.infoPair("zstackID = ",self.zstackID)
     606              if self.zstackID > 0:
     607                  stackid = self.zstackID
     608                  exptime = self.zheader['EXPTIME']
     609              else:
     610                  skip = 1
     611          if (f == "y"):
     612              self.logger.infoPair("ystackID = ",self.ystackID)
     613              if self.ystackID > 0:
     614                  stackid = self.ystackID
     615                  exptime = self.yheader['EXPTIME']
     616              else:
     617                  skip = 1
     618
     619          if skip == 1:
     620              self.logger.infoPair("nothing for filter" , f)
     621          else:
     622             self.logger.infoPair("filter",f)
     623
     624
     625
     626             # insert all the detections
     627             sql = "UPDATE StackObject as a , " + f + "SkyChip_psf as b set \
     628                   a."+f+"xPos = b.X_PSF \
     629                   ,a."+f+"yPos = b.Y_PSF \
     630                   ,a."+f+"xPosErr = b.X_PSF_SIG \
     631                   ,a."+f+"yPosErr = b.Y_PSF_SIG \
     632                   ,a."+f+"PSFFlux = b.PSF_INST_FLUX / " + str(exptime) + " \
     633                   ,a."+f+"PSFFluxErr = b.PSF_INST_FLUX_SIG / " + str(exptime) + " \
     634                   ,a."+f+"sky = b.SKY / " + str(exptime) + " \
     635                   ,a."+f+"skyErr = b.SKY_SIGMA / " + str(exptime) + " \
     636                   ,a."+f+"psfMajorFWHM = b.PSF_MAJOR \
     637                   ,a."+f+"psfMinorFWHM = b.PSF_MINOR \
     638                   ,a."+f+"psfTheta = b.PSF_THETA \
     639                   ,a."+f+"psfCore = NULL \
     640                   ,a."+f+"psfLikelihood = psfLikelihood(b.EXT_NSIGMA) \
     641                   ,a."+f+"infoFlag = b.FLAGS2 << 32 | FLAGS \
     642                   ,a."+f+"psfQf = b.PSF_QF \
     643                   ,a."+f+"psfQfPerfect = b.PSF_QF_PERFECT \
     644                   ,a."+f+"psfChiSq = b.PSF_CHISQ / b.PSF_NDOF \
     645                   ,a."+f+"momentXX = b.MOMENTS_XX \
     646                   ,a."+f+"momentXY = b.MOMENTS_XY \
     647                   ,a."+f+"momentYY = b.MOMENTS_YY \
     648                   ,a."+f+"momentR1 = b.MOMENTS_R1 \
     649                   ,a."+f+"momentRH = b.MOMENTS_RH \
     650                   ,a."+f+"ApFlux = POW(10.0, -0.4*b.AP_MAG) / " + str(exptime) + " \
     651                   ,a."+f+"ApFluxErr = NULL \
     652                   ,a."+f+"ApFillFac = NULL \
     653                   ,a."+f+"KronFlux = b.KRON_FLUX / " + str(exptime) + " \
     654                   ,a."+f+"KronFluxErr = b.KRON_FLUX_ERR / " + str(exptime) + " \
     655                   ,a."+f+"KronRad = b.MOMENTS_R1 * 2.5 \
     656                   ,a."+f+"PSFMag = b.PSF_INST_MAG    \
     657                   ,a."+f+"PSFMagErr = b.PSF_INST_MAG_SIG    \
     658                   ,a."+f+"ApMag = b.AP_MAG    \
     659                   ,a."+f+"ApMagErr = NULL    \
     660                   ,a."+f+"KronMag = NULL    \
     661                   ,a."+f+"KronMagErr = NULL    \
     662                   ,a."+f+"nFrames = b. N_FRAMES \
     663                   WHERE a." + f + "ippDetectID=b.IPP_IDET "
     664             self.logger.infoPair('sql', sql)     
     665             try:
     666                 self.scratchDb.execute(sql)
     667             except:
     668                 self.logger.errorPair('failed sql',sql)
     669                 return
     670             #it is possible to drop some detections from dvo (that are present in the cmf). when that happens we get a 0 for objid
    551671        #we drop those...
    552         sql="DELETE FROM StackDetection where objID = 0"
    553         self.scratchDb.execute(sql)
    554         self.logger.infoPair("Deleting", "entries with StackDetection.objID = 0")
    555        
    556         # XXX EAM : this seems quite inefficient : these commands use updates to set
    557         # fields which are constant across all rows.  Why not just include these in
    558         # the original insert above?
    559 
    560         self.scratchDb.updateAllRows("StackDetection", "surveyID", str(self.surveyID))
    561        
    562         self.scratchDb.updateFilterID("StackDetection", self.filter)
    563        
    564         self.scratchDb.updateAllRows("StackDetection", "dataRelease", str(self.skychunk.dataRelease))
    565         #set primary F to 0
    566         self.scratchDb.updateAllRows("StackDetection", "primaryF", "0")
    567        
    568         self.scratchDb.updateAllRows("StackDetection", "activeFlag", "0")
    569        
    570         self.updateStackMetaID("StackDetection")
    571        
    572         self.updateStackTypeID("StackDetection")
    573        
    574         self.updateDvoIDsAndFlags("StackDetection")
     672
     673        self.logger.infoPair("Deleting", "entries with StackObject.objID = 0")
     674        sql="DELETE FROM StackObject where objID = 0"
     675        try:
     676            self.scratchDb.execute(sql)
     677        except:
     678            self.logger.errorPair('failed sql',sql)
     679            return
     680       
     681        try:
     682            self.scratchDb.updateAllRows("StackObject", "surveyID", str(self.surveyID))
     683        except:
     684            self.logger.errorPair('failed update surveyID on','StackObject')
     685            raise
     686#        self.scratchDb.updateFilterID("StackObject", f+".00000")
     687       
     688        self.scratchDb.updateAllRows("StackObject", "dataRelease", str(self.skychunk.dataRelease))
     689        try:
     690            self.updateStackMetaID("StackObject")
     691        except:
     692            self.logger.errorPair("failed update stack meta id on ", "StackObject")
     693            raise
     694        ##self.updateStackTypeID("StackObject")
     695       
     696        #self.updateDvoIDsAndFlags("StackObject")
    575697        #this now updates primary F as well
    576698        # response = raw_input("updated dvo ")
    … …  
    585707            self.scratchDb.execute("set session old_alter_table=1")
    586708
    587         sql = "ALTER IGNORE TABLE StackDetection ADD PRIMARY KEY (objID)"
     709        sql = "ALTER IGNORE TABLE StackObject ADD PRIMARY KEY (objID)"
    588710       
    589711        if self.scratchDb.version > 5.1:
    … …  
    595717        ### XXX this should not be a DEEP_STACK only case...
    596718        if False and self.stackType == "DEEP_STACK":
    597 
     719            ## need to do for all filters?
    598720            #if deep stack and instFlux = null and err not null
    599             sql = "UPDATE StackDetection AS a, SkyChip_psf AS b \
     721            sql = "UPDATE StackObject AS a, SkyChip_psf AS b \
    600722                   SET psfFlux = 2*b.PSF_INST_FLUX_SIG / " + str(self.expTime) + " \
    601723                   WHERE psfFlux IS NULL \
    … …  
    605727            self.scratchDb.execute(sql)
    606728            # response = raw_input("add psf flux ")
    607            
     729         
     730        #filter dependent
    608731        # NOTE : Flux limits : in the current PSPS schema, negative fluxes
    609732        # cause problems for sql queries which work in mags as SQL cannot do
    610733        # something like (f < 0.0) ? -999 : -2.5*log10(f)
    611734        # as a result, the negative fluxes here result in floating point errors
    612         sql = "UPDATE StackDetection SET psfFlux = 1e20 WHERE psfFlux <= 0.0"
    613         self.scratchDb.execute(sql)
    614        
    615         sql = "UPDATE StackDetection SET apFlux = 1e20 WHERE apFlux <= 0.0"
    616         self.scratchDb.execute(sql)
    617 
    618         sql = "UPDATE StackDetection SET kronFlux = 1e20 WHERE kronFlux <= 0.0"
     735        sql = "UPDATE StackObject SET gPSFFlux = 1e20 WHERE gPSFFlux <= 0.0"
     736        self.scratchDb.execute(sql)
     737       
     738        sql = "UPDATE StackObject SET gApFlux = 1e20 WHERE gApFlux <= 0.0"
     739        self.scratchDb.execute(sql)
     740
     741        sql = "UPDATE StackObject SET gKronFlux = 1e20 WHERE gKronFlux <= 0.0"
     742        self.scratchDb.execute(sql)
     743        sql = "UPDATE StackObject SET rPSFFlux = 1e20 WHERE rPSFFlux <= 0.0"
     744        self.scratchDb.execute(sql)
     745       
     746        sql = "UPDATE StackObject SET rApFlux = 1e20 WHERE rApFlux <= 0.0"
     747        self.scratchDb.execute(sql)
     748
     749        sql = "UPDATE StackObject SET rKronFlux = 1e20 WHERE rKronFlux <= 0.0"
     750        self.scratchDb.execute(sql)
     751        sql = "UPDATE StackObject SET iPSFFlux = 1e20 WHERE iPSFFlux <= 0.0"
     752        self.scratchDb.execute(sql)
     753       
     754        sql = "UPDATE StackObject SET iApFlux = 1e20 WHERE iApFlux <= 0.0"
     755        self.scratchDb.execute(sql)
     756
     757        sql = "UPDATE StackObject SET iKronFlux = 1e20 WHERE iKronFlux <= 0.0"
     758        self.scratchDb.execute(sql)
     759        sql = "UPDATE StackObject SET zPSFFlux = 1e20 WHERE zPSFFlux <= 0.0"
     760        self.scratchDb.execute(sql)
     761       
     762        sql = "UPDATE StackObject SET zApFlux = 1e20 WHERE zApFlux <= 0.0"
     763        self.scratchDb.execute(sql)
     764
     765        sql = "UPDATE StackObject SET zKronFlux = 1e20 WHERE zKronFlux <= 0.0"
     766        self.scratchDb.execute(sql)
     767        sql = "UPDATE StackObject SET yPSFFlux = 1e20 WHERE yPSFFlux <= 0.0"
     768        self.scratchDb.execute(sql)
     769       
     770        sql = "UPDATE StackObject SET yApFlux = 1e20 WHERE yApFlux <= 0.0"
     771        self.scratchDb.execute(sql)
     772
     773        sql = "UPDATE StackObject SET yKronFlux = 1e20 WHERE yKronFlux <= 0.0"
    619774        self.scratchDb.execute(sql)
    620775
    621776        #leave null instflux in
    622         #self.scratchDb.reportAndDeleteRowsWithNULLS("StackDetection", "instFlux")
    623        
    624         self.scratchDb.reportAndDeleteRowsWithNULLS("StackDetection", "objID")
     777        #self.scratchDb.reportAndDeleteRowsWithNULLS("StackObject", "instFlux")
     778       
     779        self.scratchDb.reportAndDeleteRowsWithNULLS("StackObject", "objID")
    625780        # response = raw_input("delete nulls ")
    626781       
    627         sql="DELETE FROM StackDetection where objID = 0"
    628        
    629         self.scratchDb.execute(sql)
    630         self.logger.infoPair("Deleting", "entries with StackDetection.objID = 0")
     782        sql="DELETE FROM StackObject where objID = 0"
     783       
     784        self.scratchDb.execute(sql)
     785        self.logger.infoPair("Deleting", "entries with StackObject.objID = 0")
    631786        # response = raw_input("deleted objID is 0 ")
    632787       
    … …  
    636791    '''
    637792    def populateStackApFlx(self):
    638         self.logger.infoPair("getting","imageID")
    639         imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    640         self.logger.infoPair("obtained","imageID")
    641 
    642         self.logger.infoPair("Procesing", "StackApFlx")
    643  
    644         sql = "INSERT INTO StackApFlx \
    645                (ippDetectID ) \
    646                SELECT \
    647                DISTINCT IPP_IDET \
    648                FROM SkyChip_xrad"
    649 
    650         try:
    651             self.scratchDb.execute(sql)
    652         except: return
    653 
    654         # TODO temporarily loading 1st convolved fluxes into unconvolved fields
    655 
    656         #This assumes that there are 3 different fluxs, the first is unconv, and the 2nd and 3rd are convolved. If there are more than 3 fluxes it will break.   
    657         # If there are more than 3 types of fluxes, we should do a count to find out how many there are and adjust this accordingly (make it more robust)
    658 
    659         self.logger.infoPair("Adding fluxes", "un-convolved")
    660         self.updateApFlxs("", "((b.table_index -1) % 3 = 0)")
    661         self.logger.infoPair("Adding fluxes", "1st convolved")
    662         self.updateApFlxs("c1", "((b.table_index -1) % 3 = 1)")
    663         self.logger.infoPair("Adding fluxes", "2nd convolved")
    664         self.updateApFlxs("c2", "((b.table_index -1) % 3 = 2)")
    665 
    666         self.logger.infoPair("Adding", "petrosians for extended sources")
    667         sql = "UPDATE StackApFlx AS a, SkyChip_xsrc AS b SET \
    668         petRadius=b.PETRO_RADIUS \
    669         ,petRadiusErr=b.PETRO_RADIUS_ERR \
    670         ,petFlux=POW(10.0, -0.4 * b.PETRO_MAG) /" + str(self.expTime) + " \
    671         ,petFluxErr=-999  \
    672         ,petR50=b.PETRO_RADIUS_50 \
    673         ,petR50Err=b.PETRO_RADIUS_50_ERR \
    674         ,petR90=b.PETRO_RADIUS_90 \
    675         ,petR90Err=b.PETRO_RADIUS_90_ERR \
    676         ,petCf=b.PETRO_FILL \
    677         WHERE a.ippDetectID=b.IPP_IDET"
    678         self.scratchDb.execute(sql)
    679 
    680         self.logger.infoPair("Adding", "petFluxErr for non nulls")
    681         sql = "UPDATE StackApFlx as a, SkyChip_xsrc AS b SET \
    682         petFluxErr=ABS(b.PETRO_MAG_ERR) * POW(10.0, (-0.4*b.PETRO_MAG)) / " + str(self.expTime) + " / 1.085736  \
    683         WHERE a.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 
    691         self.logger.infoPair("adding"," PrimaryF to stackApFlx")
    692         sql = "UPDATE StackApFlx AS a, " + self.scratchDb.dvoDetectionTable + " AS b SET \
    693                a.primaryF = ((b.flags & 0x10000) >> 16 ) \
    694                WHERE a.ippDetectID = b.ippDetectID \
    695                AND b.imageID = " + str(imageID)
    696 
    697         print "update dvo sql: ", sql
    698         # response = raw_input("update dvo...")
    699         self.scratchDb.execute(sql)
    700 
    701        
    702 
    703         self.scratchDb.updateAllRows("StackApFlx", "surveyID", str(self.surveyID))
    704         self.scratchDb.updateFilterID("StackApFlx", self.filter)
    705         self.scratchDb.updateAllRows("StackApFlx", "dataRelease", str(self.skychunk.dataRelease))
    706         self.scratchDb.updateAllRows("StackApFlx", "activeFlag", "0")
    707         self.updateStackMetaID("StackApFlx")
    708         self.updateStackTypeID("StackApFlx")
    709         self.updateDvoIDs("StackApFlx")
     793        filter = ['g','r','i','z','y']
     794
     795        for f in filter:
     796            skip = 0
     797            if (f == 'g'):
     798                if self.gstackID > 0:
     799                    self.header = self.gheader
     800                else:
     801                    skip = 1
     802            if (f == 'r'):
     803                if self.rstackID > 0:
     804                    self.header = self.rheader
     805                else:
     806                    skip = 1
     807            if (f == 'i'):
     808                if self.istackID > 0:
     809                    self.header = self.iheader
     810                else:
     811                    skip = 1
     812            if (f == 'z'):
     813                if self.zstackID > 0:
     814                    self.header = self.zheader
     815                else:
     816                    skip = 1
     817            if (f == 'y'):
     818                if self.ystackID > 0:
     819                    self.header = self.yheader
     820                else:
     821                    skip =1
     822
     823            if skip == 0:
     824                self.logger.infoPair("Adding fluxes", "un-convolved")
     825                self.updateModelFitFlxs("", "((b.table_index -1) % 3 = 0)", "StackApFlx", f)
     826                self.logger.infoPair("Adding fluxes", "1st convolved")
     827                self.updateModelFitFlxs("c1", "((b.table_index -1) % 3 = 1)","StackApFlx",f)
     828                self.logger.infoPair("Adding fluxes", "2nd convolved")
     829                self.updateModelFitFlxs("c2", "((b.table_index -1) % 3 = 2)","StackApFlx",f)
     830
     831                self.deleteDetectionsNotInStackObject("StackApFlx",f)
     832
    710833        self.scratchDb.reportAndDeleteRowsWithNULLS("StackApFlx", "objID")
    711         self.deleteDetectionsNotInStackDetection("StackApFlx")
     834       
    712835
    713836
    … …  
    715838    Populates the StackModelFit table
    716839    '''
    717     def populateStackModelFit(self):
     840    def populateStackModelFit(self, filter):
     841        # for each filter
     842        f =filter
     843        if (filter == 'g'):
     844            self.header = self.gheader
     845           
     846        if (filter == 'r'):
     847            self.header = self.rheader
     848        if (filter == 'i'):
     849            self.header = self.iheader
     850        if (filter == 'z'):
     851            self.header = self.zheader
     852        if (filter == 'y'):
     853            self.header = self.yheader
     854           
     855
     856
     857
     858
    718859        self.logger.infoPair("getting","imageID")
    719860        imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    … …  
    723864
    724865        # insert all the detections
    725         sql = "INSERT INTO StackModelFit (ippDetectID) SELECT DISTINCT IPP_IDET from SkyChip_xfit"
    726         try:
    727             self.scratchDb.execute(sql)
    728         except:
    729             return
    730866
    731867        # populate model parameters
    732868        self.logger.infoPair("Adding model fit", "deVaucouleurs")
    733         self.updateModelFit("deV", "PS_MODEL_DEV")
     869        self.updateModelFit("deV", "PS_MODEL_DEV", filter, self.header['EXPTIME'])
    734870        self.logger.infoPair("Adding model fit", "exponential")
    735         self.updateModelFit("exp", "PS_MODEL_EXP")
     871        self.updateModelFit("deV", "PS_MODEL_EXP", filter, self.header['EXPTIME'])
    736872        self.logger.infoPair("Adding model fit", "sersic")
    737         self.updateModelFit("ser", "PS_MODEL_SERSIC")
     873        self.updateModelFit("deV", "PS_MODEL_SERSIC", filter, self.header['EXPTIME'])
     874 
     875
     876        self.logger.infoPair("Adding fluxes", "un-convolved")
     877        self.updateModelFitFlxs("", "((b.table_index -1) % 3 = 0)","StackModelFit",f)
     878        self.logger.infoPair("Adding fluxes", "1st convolved")
     879        self.updateModelFitFlxs("c1", "((b.table_index -1) % 3 = 1)","StackModelFit",f)
     880        self.logger.infoPair("Adding fluxes", "2nd convolved")
     881        self.updateModelFitFlxs("c2", "((b.table_index -1) % 3 = 2)","StackModelFit",f)
     882
     883 
     884        self.logger.infoPair("Adding", "petrosians for extended sources")
     885        sql = "UPDATE StackModelFit as a, "+f+"SkyChip_xsrc AS b SET \
     886        "+f+"petRadius=b.PETRO_RADIUS \
     887        ,"+f+"petRadiusErr=b.PETRO_RADIUS_ERR \
     888        ,"+f+"petFlux=POW(10.0, -0.4 * b.PETRO_MAG) /" + str(self.header['EXPTIME']) + " \
     889        ,"+f+"petFluxErr=-999  \
     890        ,"+f+"petR50=b.PETRO_RADIUS_50 \
     891        ,"+f+"petR50Err=b.PETRO_RADIUS_50_ERR \
     892        ,"+f+"petR90=b.PETRO_RADIUS_90 \
     893        ,"+f+"petR90Err=b.PETRO_RADIUS_90_ERR \
     894        ,"+f+"petCf=b.PETRO_FILL \
     895        WHERE a."+f+"ippDetectID=b.IPP_IDET"
     896        self.scratchDb.execute(sql)
     897
     898        self.logger.infoPair("Adding", "petFluxErr for non nulls")
     899        sql = "UPDATE StackModelFit as a, "+f+"SkyChip_xsrc AS b SET \
     900        "+f+"petFluxErr=ABS(b.PETRO_MAG_ERR) * POW(10.0, (-0.4*b.PETRO_MAG)) / " + str(self.header['EXPTIME']) + " / 1.085736  \
     901        WHERE a."+f+"ippDetectID=b.IPP_IDET \
     902        AND (b.PETRO_MAG_ERR is not NULL AND b.PETRO_MAG is not NULL AND PETRO_MAG_ERR < 1000.0)"
     903        # added this because when the petromagerr is crazy large (10^29 it out of ranges the flux err calc)
     904        self.logger.infoPair("sql", sql)
     905        self.scratchDb.execute(sql)
     906
     907
    738908
    739909        self.scratchDb.updateAllRows("StackModelFit", "surveyID", str(self.surveyID))
    740         self.scratchDb.updateFilterID("StackModelFit", self.filter)
    741910        self.scratchDb.updateAllRows("StackModelFit", "dataRelease", str(self.skychunk.dataRelease))
    742911
    743         self.logger.infoPair("adding"," PrimaryF to stackApFlx")
     912        self.logger.infoPair("not adding"," PrimaryF to stackApFlx")
    744913        sql = "UPDATE StackModelFit AS a, " + self.scratchDb.dvoDetectionTable + " AS b SET \
    745914               a.primaryF = ((b.flags & 0x10000) >> 16 ) \
    … …  
    747916               AND b.imageID = " + str(imageID)
    748917
    749         print "update dvo sql: ", sql
    750         # response = raw_input("update dvo...")
    751         try:
    752             self.scratchDb.execute(sql)
    753         except:
    754             return
    755 
    756         self.scratchDb.updateAllRows("StackModelFit", "activeFlag", "0")
    757         self.updateStackMetaID("StackModelFit")
    758         self.updateStackTypeID("StackModelFit")
    759         self.updateDvoIDs("StackModelFit")
     918#        try:
     919#            self.scratchDb.execute(sql)
     920#        except:
     921#            return
     922
     923##        self.scratchDb.updateAllRows("StackModelFit", "activeFlag", "0")
     924        ##self.updateStackMetaID("StackModelFit")
     925##        self.updateStackTypeID("StackModelFit")
     926       
    760927        self.scratchDb.reportAndDeleteRowsWithNULLS("StackModelFit", "objID")
    761         self.deleteDetectionsNotInStackDetection("StackModelFit")
    762 
    763     '''
    764     Reports and deletes detections in this table that are not in StackDetection
    765     '''
    766     def deleteDetectionsNotInStackDetection(self, table):
    767 
    768         sql = "SELECT COUNT(*) FROM " + table + " WHERE ippDetectID NOT IN (SELECT ippDetectID FROM StackDetection)"
     928        self.deleteDetectionsNotInStackObject("StackModelFit", f)
     929
     930    '''
     931    Reports and deletes detections in this table that are not in StackObject
     932    '''
     933    def deleteDetectionsNotInStackObject(self, table, filter):
     934        f= filter
     935
     936        sql = "SELECT COUNT(*) FROM " + table + " WHERE "+f+"ippDetectID NOT IN (SELECT "+f+"ippDetectID FROM StackObject)"
    769937        rs = self.scratchDb.executeQuery(sql)
    770938        rs.first()
    … …  
    773941        if nMissing < 1: return
    774942       
    775         sql = "DELETE FROM " + table + " WHERE ippDetectID NOT IN (SELECT ippDetectID FROM StackDetection)"
    776         self.scratchDb.execute(sql)
    777         self.logger.infoPair("Detections not in StackDetection", "%d deleted from %s" % (nMissing, table))
     943        sql = "DELETE FROM " + table + " WHERE "+f+"ippDetectID NOT IN (SELECT "+f+"ippDetectID FROM StackObject)"
     944        self.scratchDb.execute(sql)
     945        self.logger.infoPair("Detections not in StackObject", "%d deleted from %s" % (nMissing, table))
    778946       
    779947
    … …  
    784952
    785953        self.logger.infoPair("Procesing table", "StackToImage")
    786 
    787         imageIDs = self.gpc1Db.getImageIDsForThisStackID(self.id)
    788 
    789         for imageID in imageIDs:
    790             sql = "INSERT INTO StackToImage (stackMetaID, imageID) \
     954        filters = ['g','r','i','z','y']
     955        for f in filters:
     956           
     957            if f == 'g':
     958                stackmetaid = self.gstackID
     959            if f == 'r':
     960                stackmetaid = self.rstackID
     961            if f == 'i':
     962                stackmetaid = self.istackID
     963            if f == 'z':
     964                stackmetaid = self.zstackID
     965            if f == 'y':
     966                stackmetaid = self.ystackID
     967            if stackmetaid > 0:
     968   
     969                imageIDs = self.gpc1Db.getImageIDsForThisStackID(stackmetaid)
     970
     971                for imageID in imageIDs:
     972                    sql = "INSERT INTO StackToImage (stackMetaID, imageID) \
    791973                   VALUES (\
    792                    " + str(self.id) + ", " + imageID + ")"
     974                   " + str(stackmetaid) + ", " + imageID + ")"
     975                    self.scratchDb.execute(sql)
     976
     977        # now update StackMeta with correct number of inputs
     978                    sql = "UPDATE "+f+"StackMeta SET nP2Images = (SELECT COUNT(distinct(floor(imageID/100))) FROM StackToImage where stackMetaID = "+str(stackmetaid)+")"
     979                    self.scratchDb.execute(sql)
     980
     981    '''
     982    Generates the randomStackIds
     983    '''
     984    def populateRandomsAndSkyCellID(self):
     985
     986        self.logger.infoPair("Generating Randoms","for StackObject")
     987        sql = "update StackObject set randomStackObjID = FLOOR(RAND()*9223372036854775807) \
     988              ,skyCellID = " + str(self.skycell)+ " \
     989              ,surveyID = " + str(self.surveyID)
     990        try:
    793991            self.scratchDb.execute(sql)
    794 
    795         # now update StackMeta with correct number of inputs
    796         sql = "UPDATE StackMeta SET nP2Images = (SELECT COUNT(distinct(floor(imageID/100))) FROM StackToImage)"
    797         self.scratchDb.execute(sql)
    798 
    799     '''
    800     Populates the SkinnyObject table
    801     '''
    802     def populateSkinnyObject(self):
    803 
    804         self.logger.infoPair("Procesing table", "SkinnyObject")
    805 
    806         sql = "INSERT INTO SkinnyObject (\
    807                objID \
    808                ,ippObjID \
    809                ,projectionCellID \
    810                ) \
    811                SELECT \
    812                DISTINCT objID \
    813                ,ippObjID \
    814                ,projectionCellID \
    815                FROM StackDetection"
    816         self.scratchDb.execute(sql)
    817 
    818         self.scratchDb.updateAllRows("SkinnyObject", "surveyID", str(self.surveyID))
    819         self.scratchDb.updateAllRows("SkinnyObject", "dataRelease", str(self.skychunk.dataRelease))
    820 
    821     '''   
    822     Populates the StackDetectionCalib table
    823     XXX this can probably get a big speed increase by using 'SELECT () INTO OUTFILE '/tmp/name' and then
    824     calling the load data infile '/tmp/name' into table;
    825     '''
    826     def populateStackDetectionCalibInsertUpdate(self):
    827         self.logger.infoPair("Processing table", "StackDetectionCalib")
    828         tableName = "StackDetectionCalib"
    829         # insert all detections into table
    830         sql = "INSERT INTO " + tableName + " ( \
    831                objID \
    832                ,stackDetectID \
    833                ,ippObjID \
    834                ,ippDetectID \
    835                ,filterID \
    836                ,surveyID \
    837                ) \
    838                SELECT \
    839                objID \
    840                ,stackDetectID \
    841                ,ippObjID \
    842                ,ippDetectID \
    843                ,filterID \
    844                ,surveyID \
    845                FROM StackDetection"
    846         self.scratchDb.execute(sql)
    847 
    848         imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    849         self.logger.infoPair("obtained","imageID")
    850 
    851         # insert calibration information from dvoDetections into the Table
    852         sql = "UPDATE " + tableName + " AS a, "  + self.scratchDb.dvoDetectionTable + " AS b \
    853             SET a.ra = b.ra, \
    854             a.dec = b.dec_, \
    855             a.raErr = b.raErr, \
    856             a.decErr = b.decErr, \
    857             a.zp = b.zp, \
    858             a.zpErr = b.zpErr, \
    859             a.expTime = b.expTime, \
    860             a.airMass = b.airMass   \
    861             WHERE a.stackDetectID = b.detectID \
    862             AND b.imageID = " + str(imageID)
    863         self.scratchDb.execute(sql)
     992        except:
     993            self.logger.infoPair("failed sql", sql)
     994
     995    '''
     996    copies randomStackIds from StackObject to tableName
     997    '''
     998    def copyRandomsAndSkyCellIDFromStackObject(self, tableName):
     999
     1000        self.logger.infoPair("copying Randoms from StackObject to ", tableName)
     1001        sql = "update " + tableName + " join StackObject using (objID) \
     1002        set " + tableName + ".randomStackObjID = StackObject.randomStackObjID \
     1003        , " + tableName + ".skyCellID = StackObject.skyCellID \
     1004        , " + tableName + ".surveyID = StackObject.surveyID"
     1005        self.logger.infoPair("sql", sql)
     1006        try:
     1007            self.scratchDb.execute(sql)
     1008        except:
     1009            self.logger.infoPair("failed sql", sql)
     1010
     1011
     1012       
     1013    def populateStackIPPDetectIDFromDvo(self, tableName, all):
     1014
     1015        #tableName = "StackObject"
     1016        self.logger.infoPair("Processing table", tableName)
     1017
     1018        filters = ['g','r','i','z','y']
     1019       
     1020        for f in filters:
     1021            skip = 0
     1022            #first: do we skip this filter
     1023            if f == 'g':
     1024                if self.gstackID < 0:
     1025                    skip = 1
     1026                else:
     1027                    self.header=self.gheader
     1028                    stackmetaid = self.gstackID
     1029            elif f == 'r':
     1030                if self.rstackID < 0:
     1031                    skip = 1
     1032                else:
     1033                    self.header = self.rheader
     1034                    stackmetaid = self.rstackID
     1035            elif f == 'i':
     1036                if self.istackID < 0:
     1037                    skip = 1
     1038                else:
     1039                    self.header = self.iheader
     1040                    stackmetaid = self.istackID
     1041            elif f == 'z':
     1042                if self.zstackID < 0:
     1043                    skip = 1
     1044                else:
     1045                    self.header = self.zheader
     1046                    stackmetaid = self.zstackID
     1047            elif f == 'y':
     1048                if self.ystackID < 0:
     1049                    skip = 1
     1050                else:
     1051                    self.header = self.yheader
     1052                    stackmetaid = self.ystackID
     1053            if skip == 0:       
     1054                imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
     1055                self.logger.infoPair("obtained","imageID")
     1056                addsql = ""
     1057                if (all == 1):
     1058                    addsql = "a." + f + "ra = b.ra, \
     1059                      a." + f + "dec = b.dec_, \
     1060                      a." + f + "raErr = b.raErr, \
     1061                      a." + f + "decErr = b.decErr, \
     1062                      a." + f + "zp = b.zp, \
     1063                      a." + f + "expTime = b.expTime,"
     1064
     1065                   
     1066                sql = "UPDATE " + tableName + " AS a, "  + self.scratchDb.dvoDetectionTable + " AS b \
     1067                      SET a." + f + "ippDetectID = b.ippDetectID, \
     1068                      " + addsql + " \
     1069                      a." + f + "stackDetectID = b.detectID,   \
     1070                      a." + f + "ippObjID = b.ippObjID, \
     1071                      a." + f + "stackMetaID = " + str(stackmetaid) +  " \
     1072                      WHERE a.objID = b.objID  AND b.imageID = " + str(imageID)
     1073                self.logger.infoPair('sql',sql)   
     1074                self.scratchDb.execute(sql)
     1075            else:
     1076                self.logger.infoPair("skipping ingest of dvo for filter",f)
     1077        #out of the loops - give dataRelase to all       
    8641078        self.scratchDb.updateAllRows(tableName, "dataRelease", str(self.skychunk.dataRelease))
    865        
    866     def populateStackDetectionCalib(self):
    867 
    868         tableName = "StackDetectionCalib"
    869         self.logger.infoPair("Processing table", tableName)
    870 
    871         imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    872         self.logger.infoPair("obtained","imageID")
    873 
    874         # check for & create output directory first
    875         datadumpDir = "/tmp/datadump"
    876         try:
    877             statinfo = os.stat(datadumpDir)
    878             # check on the stat results?
    879         except:
    880             print "making the data dump directory ", datadumpDir
    881             os.mkdir(datadumpDir)
    882             os.chmod(datadumpDir, 0777)
    883             statinfo = os.stat(datadumpDir)
    884 
    885         dumpFile = datadumpDir + "/genetest.xx.dat"
    886         files = glob.glob(dumpFile)
    887         if len(files) > 0:
    888             os.unlink(dumpFile)
    889 
    890         # insert all detections into table
    891         sql = "SELECT \
    892           a.objID,    \
    893           a.stackDetectID, \
    894           a.ippObjID,      \
    895           a.ippDetectID,   \
    896           a.filterID,      \
    897           a.surveyID,      \
    898           b.ra,            \
    899           b.dec_,          \
    900           b.raErr,         \
    901           b.decErr,        \
    902           b.zp,            \
    903           b.zpErr,         \
    904           b.expTime,       \
    905           b.airMass,       \
    906           " + str(self.skychunk.dataRelease) + " \
    907          FROM              \
    908            StackDetection as a \
    909          JOIN " + self.scratchDb.dvoDetectionTable + " as b \
    910          ON (a.stackDetectID = b.detectID) where b.imageID = " + str(imageID) + \
    911          " INTO OUTFILE '" + dumpFile + "'"
    912 
    913         try: self.scratchDb.execute(sql)
    914         except:
    915             self.logger.info("failed to select data for stackDetectionCalib")
    916             self.logger.infoPair("sql: ", sql)
    917             raise
    918 
    919         sql = "LOAD DATA INFILE '" + dumpFile + "' INTO TABLE " + tableName
    920         try: self.scratchDb.execute(sql)
    921         except:
    922             self.logger.info("failed to load data from infile for stackDetectionCalib")
    923             self.logger.infoPair("sql: ", sql)
    924             raise
    925 
    926         ## XXX write this with the select/insert
    927         # self.scratchDb.updateAllRows(tableName, "dataRelease", str(self.skychunk.dataRelease))
    928 
    929     '''
    930     Populates the ObjectCalColor table
    931     '''
    932     def populateObjectCalColor(self):
    933 
    934         self.logger.infoPair("Procesing table", "ObjectCalColor table")
    935 
    936         sql = "INSERT INTO ObjectCalColor (\
    937                objID \
    938                ,ippObjID \
    939                ) \
    940                SELECT \
    941                DISTINCT objID \
    942                ,ippObjID \
    943                FROM StackDetection"
    944         self.scratchDb.execute(sql)
    945 
    946         self.scratchDb.updateFilterID("ObjectCalColor", self.filter)
    947         self.scratchDb.updateAllRows("ObjectCalColor", "dataRelease", str(self.skychunk.dataRelease))
    948 
     1079
     1080
     1081    def deleteNULLippDetectIDs(self, tableName):
     1082
     1083        self.logger.infoPair("Deleting NULL ippdetectIDs from table", tableName)
     1084        sql = "DELETE FROM " + tableName + " WHERE \
     1085              gippDetectID is NULL AND \
     1086              rippDetectID is NULL AND \
     1087              iippDetectID is NULL AND \
     1088              zippDetectID is NULL AND \
     1089              yippDetectID is NULL "
     1090        self.logger.infoPair('sql',sql)   
     1091        self.scratchDb.execute(sql)
    9491092
    9501093    '''
    … …  
    9551098        self.logger.debug("Altering PSPS tables")
    9561099        # heather uncommented the unique line -- well that no worky
    957         #self.scratchDb.makeColumnUnique("StackDetection", "objID")
    958         self.scratchDb.createIndex("StackDetection", "ippDetectID")
    959         self.scratchDb.createIndex("StackDetection", "stackDetectID")
     1100        #self.scratchDb.makeColumnUnique("StackObject", "objID")
     1101        self.scratchDb.createIndex("StackObject", "ippDetectID")
     1102        self.scratchDb.createIndex("StackObject", "stackDetectID")
    9601103        self.scratchDb.createIndex("StackApFlx", "ippDetectID")
    9611104        self.scratchDb.createIndex("StackModelFit", "ippDetectID")
    962 
    963         # dec is reserved in MySQL, so STILTS replaces if with dec_, which is not the name of
    964         # the column in PSPS
    965         self.scratchDb.execute("ALTER TABLE StackDetectionCalib CHANGE dec_ `dec` double")
    9661105
    9671106        return True
    … …  
    9791118
    9801119        return True
     1120    '''
     1121    Insert objid (from dvo) into table
     1122    '''
     1123    def insertDvoIDs(self, table, filterName):
     1124        self.logger.infoPair("getting imageID for ","filter")
     1125        if (filterName == 'g.00000'):
     1126            self.header=self.gheader
     1127        if (filterName == 'r.00000'):
     1128            self.header=self.rheader
     1129        if (filterName == 'i.00000'):
     1130            self.header=self.iheader
     1131        if (filterName == 'z.00000'):
     1132            self.header=self.zheader
     1133        if (filterName == 'y.00000'):
     1134            self.header=self.yheader
     1135
     1136        imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
     1137        self.logger.infoPair("obtained","imageID")
     1138        self.logger.debug("Updating table '" + table + "' with DVO IDs...")
     1139        sql = "INSERT IGNORE INTO " + table + " ( \
     1140               objID ) \
     1141               SELECT (objID) FROM " + self.scratchDb.dvoDetectionTable + "  \
     1142               WHERE " + self.scratchDb.dvoDetectionTable + ".imageID = " + str(imageID)
     1143        self.logger.infoPair("sql",sql)
     1144        self.scratchDb.execute(sql)
     1145   
     1146
    9811147
    9821148    '''
    9831149    Updates provided table with DVO IDs from DVO table
    9841150    '''
    985     def updateDvoIDs(self, table):
    986         self.logger.infoPair("getting","imageID")
     1151    def updateDvoIDs(self, table, filterName):
     1152        self.logger.infoPair("getting imageID for ","filter")
    9871153        imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    9881154        self.logger.infoPair("obtained","imageID")
    … …  
    10141180
    10151181        print "update dvo sql: ", sql
    1016         # response = raw_input("update dvo...")
    10171182        self.scratchDb.execute(sql)
    10181183   
    … …  
    10221187    '''
    10231188    def populatePspsTables(self):
    1024 
     1189        self.logger.infoPair("starting","populatePspsTables");
    10251190        self.skipBatch = False
    1026 
    10271191        if not self.useFullTables:
    1028             if not self.getIDsFromDVO():
     1192             if not self.getIDsFromDVO():
    10291193                return False
    1030         #self.logger.infoPair("populating","StackMeta")   
    1031         self.populateStackMeta()
    1032         #self.logger.infoPair("populating","StackDetection")
    1033         self.populateStackDetection()
    1034        
    1035         if self.stackType != "NIGHTLY_STACK":
    1036             #self.logger.infoPair("populating","StackModelFit")
    1037             self.populateStackModelFit()
    1038             #self.logger.infoPair("populating","StackApFlx")
     1194        #do some basics first
     1195        # populate stack meta per filter
     1196        # insert objid/stackdetectid per filter to each table           
     1197        self.tablesToExport=[]   
     1198
     1199        if self.gstackID > 0:       
     1200            self.logger.infoPair("populating","gStackMeta")   
     1201            self.populateStackMeta("g.00000")
     1202            self.insertDvoIDs("StackObject","g.00000")
     1203            self.insertDvoIDs("StackModelFit","g.00000")
     1204            self.insertDvoIDs("StackApFlx","g.00000")
     1205            self.tablesToExport.append("gStackMeta")
     1206        if self.rstackID > 0:   
     1207            self.logger.infoPair("populating","rStackMeta")   
     1208            self.populateStackMeta("r.00000")
     1209            self.insertDvoIDs("StackObject","r.00000")
     1210            self.insertDvoIDs("StackModelFit","r.00000")
     1211            self.insertDvoIDs("StackApFlx","r.00000")
     1212            self.tablesToExport.append("rStackMeta")
     1213        if self.istackID > 0:   
     1214            self.logger.infoPair("populating","iStackMeta")   
     1215            self.populateStackMeta("i.00000")
     1216            self.insertDvoIDs("StackObject","i.00000")
     1217            self.insertDvoIDs("StackModelFit","i.00000")
     1218            self.insertDvoIDs("StackApFlx","i.00000")
     1219            self.tablesToExport.append("iStackMeta")
     1220        if self.zstackID > 0:   
     1221            self.logger.infoPair("populating","zStackMeta")   
     1222            self.populateStackMeta("z.00000")
     1223            self.insertDvoIDs("StackObject","z.00000")
     1224            self.insertDvoIDs("StackModelFit","z.00000")
     1225            self.insertDvoIDs("StackApFlx","z.00000")
     1226            self.tablesToExport.append("zStackMeta")
     1227        if self.ystackID > 0:   
     1228            self.logger.infoPair("populating","yStackMeta")   
     1229            self.populateStackMeta("y.00000")
     1230            self.insertDvoIDs("StackObject","y.00000")
     1231            self.insertDvoIDs("StackModelFit","y.00000")
     1232            self.insertDvoIDs("StackApFlx","y.00000")
     1233            self.tablesToExport.append("yStackMeta")
     1234
     1235        self.logger.infoPair("populating ","StackObject")
     1236        # need to index on objid and ippdetectid  or it is stupidly slow
     1237        self.scratchDb.createIndex("StackObject", "objID")
     1238        #populate from dvo the (f)ippDetectID into StackObject 
     1239        self.populateStackIPPDetectIDFromDvo("StackObject",1)
     1240        #index the ippDetectids for the next step
     1241        self.scratchDb.createIndex("StackObject", "gippDetectID")
     1242        self.scratchDb.createIndex("StackObject", "rippDetectID")
     1243        self.scratchDb.createIndex("StackObject", "iippDetectID")
     1244        self.scratchDb.createIndex("StackObject", "zippDetectID")
     1245        self.scratchDb.createIndex("StackObject", "yippDetectID")
     1246        self.populateStackObject()
     1247        self.populateRandomsAndSkyCellID()
     1248        # stackObject should be done, pending a few NULL columns (need help)
     1249
     1250        if self.stackType != "NIGHTLY_STACK":
     1251
     1252            self.logger.infoPair("populating ","StackModelFit")
     1253
     1254            self.scratchDb.createIndex("StackModelFit", "objID")
     1255        #populate from dvo the (f)ippdetectid into stackModelFit
     1256            self.populateStackIPPDetectIDFromDvo("StackModelFit",0)
     1257        #index the ippDetectIds for the next step
     1258            self.scratchDb.createIndex("StackModelFit", "gippDetectID")
     1259            self.scratchDb.createIndex("StackModelFit", "rippDetectID")
     1260            self.scratchDb.createIndex("StackModelFit", "iippDetectID")
     1261            self.scratchDb.createIndex("StackModelFit", "zippDetectID")
     1262            self.scratchDb.createIndex("StackModelFit", "yippDetectID")
     1263        #cull the entries that should not be (how?)       
     1264            self.deleteNULLippDetectIDs("StackModelFit")
     1265        #populate stackModelFit
     1266            if self.gstackID > 0:
     1267                self.logger.infoPair("populating g filter for stackModelFit, stackmetaid =", self.gstackID)
     1268                self.populateStackModelFit("g")
     1269            if self.rstackID > 0:
     1270                self.logger.infoPair("populating r filter for stackModelFit, stackmetaid =", self.rstackID)
     1271                self.populateStackModelFit("r")
     1272            if self.istackID > 0:
     1273                self.logger.infoPair("populating i filter for stackModelFit, stackmetaid =", self.istackID)
     1274                self.populateStackModelFit("i")
     1275            if self.zstackID > 0:
     1276                self.logger.infoPair("populating z filter for stackModelFit, stackmetaid =", self.zstackID)
     1277                self.populateStackModelFit("z")
     1278            if self.ystackID > 0:
     1279                self.logger.infoPair("populating y filter for stackModelFit, stackmetaid =", self.ystackID)
     1280                self.populateStackModelFit("y")
     1281           
     1282            self.copyRandomsAndSkyCellIDFromStackObject("StackModelFit")
     1283 
     1284            self.logger.infoPair("populating ","StackApFlx")
     1285           
     1286            self.scratchDb.createIndex("StackApFlx", "objID")
     1287        #populate from dvo the (f)ippDetectID into StackApFlx
     1288            self.populateStackIPPDetectIDFromDvo("StackApFlx",0)
     1289        #index the ippDetectIDs for the next step
     1290            self.scratchDb.createIndex("StackApFlx", "gippDetectID")
     1291            self.scratchDb.createIndex("StackApFlx", "rippDetectID")
     1292            self.scratchDb.createIndex("StackApFlx", "iippDetectID")
     1293            self.scratchDb.createIndex("StackApFlx", "zippDetectID")
     1294            self.scratchDb.createIndex("StackApFlx", "yippDetectID")
     1295        #populate StackApFlx
     1296            self.deleteNULLippDetectIDs("StackApFlx")
    10391297            self.populateStackApFlx()
    1040         #self.logger.infoPair("populating","StackToImage")
     1298            self.copyRandomsAndSkyCellIDFromStackObject("StackApFlx")
     1299        #cull the entries that should not be (how?)
     1300       
     1301       
     1302        self.logger.infoPair("populating","StackToImage")
    10411303        self.populateStackToImage()
    1042         #self.logger.infoPair("populating","SkinnyObject")
    1043         self.populateSkinnyObject()
    1044         #self.logger.infoPair("populating","ObjectCalColor")
    1045         #self.populateObjectCalColor()
    1046         #self.logger.infoPair("populating","StackDetectionCalib")
    1047         self.populateStackDetectionCalib()
    1048 
    1049         self.setMinMaxObjID(["StackDetection"])
    1050        
    1051         if self.totalDetections < 1:
    1052 
    1053             self.logger.error("No detections to publish")
    1054             return False
    1055 
     1304       
     1305        self.setMinMaxObjID(["StackObject"])
     1306      #  self.updateStackTypeID("StackModelFit")
     1307
     1308        ##if self.totalDetections < 1:
     1309
     1310            ##self.logger.error("No detections to publish")
     1311            ##return False
     1312        self.tablesToExport.append("StackToImage")
     1313        self.tablesToExport.append("StackObject")
     1314        self.tablesToExport.append("StackModelFit")
     1315        self.tablesToExport.append("StackApFlx")
     1316
     1317        self.logger.infoPair("finishing","populatePspsTables");
    10561318        return True
    1057 
     1319    '''
     1320    overidding this method - use regex to trimoff letter before stack
     1321    '''
     1322    def exportPspsTablesToFits(self, regex="(.*)"):
     1323        return super(StackBatch, self).exportPspsTablesToFits("(Stack.*)")
Note: See TracChangeset for help on using the changeset viewer.