IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jul 17, 2014, 12:30:45 PM (12 years ago)
Author:
eugene
Message:

merge changes (from past YEAR) into trunk

Location:
branches/eam_branches/ipp-ops-20130712/ippToPsps
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-ops-20130712/ippToPsps

    • Property svn:mergeinfo deleted

  • branches/eam_branches/ipp-ops-20130712/ippToPsps/jython/stackbatch.py

    r35780 r37066  
    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 b.PSF_FWHM "+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         sql = "UPDATE StackModelFit AS a, SkyChip_xfit AS b SET \
    306         "+model+"Radius=b.EXT_WIDTH_MAJ,  \
    307         "+model+"Flux=POW(10, -0.4 * b.EXT_INST_MAG) / " + str(self.expTime) + " ,  \
    308         "+model+"FluxErr=ABS(b.EXT_INST_MAG_SIG) * POW(10, -0.4 * b.EXT_INST_MAG) / " + str(self.expTime) + " / 1.085736, \
    309         "+model+"Ab=b.EXT_WIDTH_MAJ/b.EXT_WIDTH_MIN, \
    310         "+model+"Phi=b.EXT_THETA,  \
    311         "+modelLong+"Covar11=b.EXT_COVAR_00_00,  \
    312         "+modelLong+"Covar12=b.EXT_COVAR_00_01,  \
    313         "+modelLong+"Covar13=b.EXT_COVAR_00_02,  \
    314         "+modelLong+"Covar14=b.EXT_COVAR_00_03,  \
    315         "+modelLong+"Covar15=b.EXT_COVAR_00_04,  \
    316         "+modelLong+"Covar16=b.EXT_COVAR_00_05,  \
    317         "+modelLong+"Covar17=b.EXT_COVAR_00_06,  \
    318         "+modelLong+"Covar22=b.EXT_COVAR_01_01,  \
    319         "+modelLong+"Covar23=b.EXT_COVAR_01_02,  \
    320         "+modelLong+"Covar24=b.EXT_COVAR_01_03,  \
    321         "+modelLong+"Covar25=b.EXT_COVAR_01_04,  \
    322         "+modelLong+"Covar26=b.EXT_COVAR_01_05,  \
    323         "+modelLong+"Covar27=b.EXT_COVAR_01_06,  \
    324         "+modelLong+"Covar33=b.EXT_COVAR_02_02,  \
    325         "+modelLong+"Covar34=b.EXT_COVAR_02_03,  \
    326         "+modelLong+"Covar35=b.EXT_COVAR_02_04,  \
    327         "+modelLong+"Covar36=b.EXT_COVAR_02_05,  \
    328         "+modelLong+"Covar37=b.EXT_COVAR_02_06,  \
    329         "+modelLong+"Covar44=b.EXT_COVAR_03_03,  \
    330         "+modelLong+"Covar45=b.EXT_COVAR_03_04,  \
    331         "+modelLong+"Covar46=b.EXT_COVAR_03_05,  \
    332         "+modelLong+"Covar47=b.EXT_COVAR_03_06,  \
    333         "+modelLong+"Covar55=b.EXT_COVAR_04_04,  \
    334         "+modelLong+"Covar56=b.EXT_COVAR_04_05,  \
    335         "+modelLong+"Covar57=b.EXT_COVAR_04_06,  \
    336         "+modelLong+"Covar66=b.EXT_COVAR_05_05,  \
    337         "+modelLong+"Covar67=b.EXT_COVAR_05_06,  \
    338         "+modelLong+"Covar77=b.EXT_COVAR_06_06   \
    339         WHERE a.ippDetectID=b.IPP_IDET AND b.MODEL_TYPE = '"+ippModelType+"'"
    340 
    341         self.scratchDb.execute(sql)
     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_%'"
     410        rs = self.scratchDb.executeQuery(sql)
     411        rs.first()
     412        hasResult = rs.next()
     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+"'"
     424
     425        print sql
     426        self.scratchDb.execute(sql)
     427
     428
    342429
    343430        # sersic fit has an extra parameter
    344         if ippModelType == "PS_MODEL_SERSIC":
    345             sql = "UPDATE StackModelFit AS a, SkyChip_xfit AS b SET \
    346             "+modelLong+"Covar18=b.EXT_COVAR_00_07,  \
    347             "+modelLong+"Covar28=b.EXT_COVAR_01_07,  \
    348             "+modelLong+"Covar38=b.EXT_COVAR_02_07,  \
    349             "+modelLong+"Covar48=b.EXT_COVAR_03_07,  \
    350             "+modelLong+"Covar58=b.EXT_COVAR_04_07,  \
    351             "+modelLong+"Covar68=b.EXT_COVAR_05_07,  \
    352             "+modelLong+"Covar78=b.EXT_COVAR_06_07,  \
    353             "+modelLong+"Covar88=b.EXT_COVAR_07_07,   \
    354             "+"serNu=b.EXT_PAR_07,   \
    355             "+"serNuErr=SQRT(EXT_COVAR_07_07)  \
    356             WHERE a.ippDetectID=b.IPP_IDET AND b.MODEL_TYPE = '"+ippModelType+"'"
    357 
     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)
    358441            self.scratchDb.execute(sql)
    359442
    … …  
    362445    Populates the StackMeta table, mainly from dictionary values found in IPP FITS header
    363446    '''
    364     def populateStackMeta(self):
     447    def populateStackMeta(self,filterName):
    365448
    366449        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
    367477
    368478        self.fwhm_maj    = self.safeDictionaryAccess(self.header, 'FWHM_MAJ')
    … …  
    376486        # print "psfmodel    = ", self.psfmodel
    377487
    378         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 + " (\
    379498        stackMetaID \
    380         ,skycellID \
     499        ,filterID \
     500        ,skyCellID \
    381501        ,photoCalID \
    382502        ,photoZero \
    … …  
    398518        ,pc002002 \
    399519         ) VALUES ( \
    400         " + str(self.id) + " \
     520        " + str(stackmetaid) + " \
     521        , " + str(filterid) + "  \
    401522        ," + self.skycell + " \
    402523        ," + str(self.scratchDb.getPhotoCalID(self.header['IMAGEID'])) + " \
    403524        ," + self.header['FPA.ZP'] + " \
    404         ," + self.expTime + " \
     525        ," + self.header['EXPTIME'] + " \
    405526        ,'" + self.psfmodel   + "' \
    406527        ," + str(self.fwhm_maj)    + " \
    … …  
    420541        )"
    421542        self.scratchDb.execute(sql)
    422         self.scratchDb.updateAllRows("StackMeta", "batchID", str(self.batchID))
    423         self.scratchDb.updateAllRows("StackMeta", "surveyID", str(self.surveyID))
    424         self.scratchDb.updateFilterID("StackMeta", self.filter)
    425         self.scratchDb.updateAllRows("StackMeta", "dataRelease", str(self.skychunk.dataRelease))
    426         self.updateStackTypeID("StackMeta")
    427 
    428     '''
    429     Populates the StackDetection table
    430     '''
    431     def populateStackDetection(self):
    432 
    433         self.logger.infoPair("Procesing table", "StackDetection")
    434 
    435         # insert all the detections
    436         sql = "INSERT INTO StackDetection (\
    437                ippDetectID \
    438                ,skyCellID \
    439                ,projectionCellID \
    440                ,xPos \
    441                ,yPos \
    442                ,xPosErr \
    443                ,yPosErr \
    444                ,psfFlux \
    445                ,psfFluxErr \
    446                ,peakFlux \
    447                ,sky \
    448                ,skyErr \
    449                ,sgSep \
    450                ,psfWidMajor \
    451                ,psfWidMinor \
    452                ,psfTheta \
    453                ,psfLikelihood \
    454                ,infoFlag \
    455                ,psfQf \
    456                ,psfQfPerfect \
    457                ,psfChiSq \
    458                ,momentXX \
    459                ,momentXY \
    460                ,momentYY \
    461                ,momentM3C \
    462                ,momentM3S \
    463                ,momentM4C \
    464                ,momentM4S \
    465                ,momentR1 \
    466                ,momentRH \
    467                ,apFlux \
    468                ,apFluxErr \
    469                ,kronFlux \
    470                ,kronFluxErr \
    471                ,kronRad \
    472                ,nFrames \
    473                ,assocDate \
    474                ,historyModNum \
    475                ) \
    476                SELECT \
    477                IPP_IDET \
    478                ," + self.skycell + " \
    479                ," + self.projectioncell + " \
    480                ,X_PSF \
    481                ,Y_PSF \
    482                ,X_PSF_SIG \
    483                ,Y_PSF_SIG \
    484                ,PSF_INST_FLUX / " + str(self.expTime) + " \
    485                ,PSF_INST_FLUX_SIG / " + str(self.expTime) + " \
    486                ,POW(10.0, (-0.4*PEAK_FLUX_AS_MAG)) / " + str(self.expTime) + " \
    487                ,SKY / " + str(self.expTime) + " \
    488                ,SKY_SIGMA / " + str(self.expTime) + " \
    489                ,EXT_NSIGMA \
    490                ,PSF_MAJOR \
    491                ,PSF_MINOR \
    492                ,PSF_THETA \
    493                ,psfLikelihood(EXT_NSIGMA) \
    494                , FLAGS2 << 32 | FLAGS \
    495                ,PSF_QF \
    496                ,PSF_QF_PERFECT \
    497                ,PSF_CHISQ / PSF_NDOF \
    498                ,MOMENTS_XX \
    499                ,MOMENTS_XY \
    500                ,MOMENTS_YY \
    501                ,MOMENTS_M3C \
    502                ,MOMENTS_M3S \
    503                ,MOMENTS_M4C \
    504                ,MOMENTS_M4S \
    505                ,MOMENTS_R1 \
    506                ,MOMENTS_RH \
    507                ,POW(10.0, -0.4*AP_MAG) / " + str(self.expTime) + " \
    508                ,NULL \
    509                ,KRON_FLUX / " + str(self.expTime) + " \
    510                ,KRON_FLUX_ERR / " + str(self.expTime) + " \
    511                ,MOMENTS_R1 * 2.5 \
    512                ,N_FRAMES \
    513                , '" + self.dateStr + "' \
    514                ," + self.historyModNum + " \
    515                FROM SkyChip_psf"
    516 
    517 # these were used above (left over from before PSF_INST_FLUX, PSF_INST_FLUX_SIG were available?
    518 #               ,POW(10.0, (-0.4*PSF_INST_MAG)) / " + str(self.expTime) + "
    519 #               ,ABS((PSF_INST_MAG_SIG*(POW(10.0, (-0.4*PSF_INST_MAG)) / " + str(self.expTime) + ")) / 1.085736)
    520 #               ,POW(10.0, -0.4*AP_MAG) / " + str(self.expTime) + "
    521 
    522 # I need a way to choose the sql above based on the cmf version: V3 (LAP.PV1) does not have AP_FLUX
    523 #               ,AP_FLUX / " + str(self.expTime) + "
    524 
    525         # print "sql: ", sql
    526         # response = raw_input("ready to insert stack det ")
    527 
    528         self.scratchDb.execute(sql)
    529 
    530         #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
    531671        #we drop those...
    532         sql="DELETE FROM StackDetection where objID = 0"
    533         self.scratchDb.execute(sql)
    534         self.logger.infoPair("Deleting", "entries with StackDetection.objID = 0")
    535        
    536         # XXX EAM : this seems quite inefficient : these commands use updates to set
    537         # fields which are constant across all rows.  Why not just include these in
    538         # the original insert above?
    539 
    540         self.scratchDb.updateAllRows("StackDetection", "surveyID", str(self.surveyID))
    541        
    542         self.scratchDb.updateFilterID("StackDetection", self.filter)
    543        
    544         self.scratchDb.updateAllRows("StackDetection", "dataRelease", str(self.skychunk.dataRelease))
    545         #set primary F to 0
    546         self.scratchDb.updateAllRows("StackDetection", "primaryF", "0")
    547        
    548         self.scratchDb.updateAllRows("StackDetection", "activeFlag", "0")
    549        
    550         self.updateStackMetaID("StackDetection")
    551        
    552         self.updateStackTypeID("StackDetection")
    553        
    554         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")
    555697        #this now updates primary F as well
    556698        # response = raw_input("updated dvo ")
    … …  
    565707            self.scratchDb.execute("set session old_alter_table=1")
    566708
    567         sql = "ALTER IGNORE TABLE StackDetection ADD PRIMARY KEY (objID)"
     709        sql = "ALTER IGNORE TABLE StackObject ADD PRIMARY KEY (objID)"
    568710       
    569711        if self.scratchDb.version > 5.1:
    … …  
    575717        ### XXX this should not be a DEEP_STACK only case...
    576718        if False and self.stackType == "DEEP_STACK":
    577 
     719            ## need to do for all filters?
    578720            #if deep stack and instFlux = null and err not null
    579             sql = "UPDATE StackDetection AS a, SkyChip_psf AS b \
     721            sql = "UPDATE StackObject AS a, SkyChip_psf AS b \
    580722                   SET psfFlux = 2*b.PSF_INST_FLUX_SIG / " + str(self.expTime) + " \
    581723                   WHERE psfFlux IS NULL \
    … …  
    585727            self.scratchDb.execute(sql)
    586728            # response = raw_input("add psf flux ")
    587            
     729         
     730        #filter dependent
    588731        # NOTE : Flux limits : in the current PSPS schema, negative fluxes
    589732        # cause problems for sql queries which work in mags as SQL cannot do
    590733        # something like (f < 0.0) ? -999 : -2.5*log10(f)
    591734        # as a result, the negative fluxes here result in floating point errors
    592         sql = "UPDATE StackDetection SET psfFlux = 1e20 WHERE psfFlux <= 0.0"
    593         self.scratchDb.execute(sql)
    594        
    595         sql = "UPDATE StackDetection SET apFlux = 1e20 WHERE apFlux <= 0.0"
    596         self.scratchDb.execute(sql)
    597 
    598         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"
    599774        self.scratchDb.execute(sql)
    600775
    601776        #leave null instflux in
    602         #self.scratchDb.reportAndDeleteRowsWithNULLS("StackDetection", "instFlux")
    603        
    604         self.scratchDb.reportAndDeleteRowsWithNULLS("StackDetection", "objID")
     777        #self.scratchDb.reportAndDeleteRowsWithNULLS("StackObject", "instFlux")
     778       
     779        self.scratchDb.reportAndDeleteRowsWithNULLS("StackObject", "objID")
    605780        # response = raw_input("delete nulls ")
    606781       
    607         sql="DELETE FROM StackDetection where objID = 0"
    608        
    609         self.scratchDb.execute(sql)
    610         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")
    611786        # response = raw_input("deleted objID is 0 ")
    612787       
    … …  
    616791    '''
    617792    def populateStackApFlx(self):
    618         self.logger.infoPair("getting","imageID")
    619         imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    620         self.logger.infoPair("obtained","imageID")
    621 
    622         self.logger.infoPair("Procesing", "StackApFlx")
    623  
    624         sql = "INSERT INTO StackApFlx \
    625                (ippDetectID ) \
    626                SELECT \
    627                DISTINCT IPP_IDET \
    628                FROM SkyChip_xrad"
    629 
    630         try:
    631             self.scratchDb.execute(sql)
    632         except: return
    633 
    634         # TODO temporarily loading 1st convolved fluxes into unconvolved fields
    635         self.logger.infoPair("Adding fluxes", "un-convolved")
    636         self.updateApFlxs("", "IS NULL")
    637         self.logger.infoPair("Adding fluxes", "1st convolved")
    638         self.updateApFlxs("c1", "< 7.0")
    639         self.logger.infoPair("Adding fluxes", "2nd convolved")
    640         self.updateApFlxs("c2", "> 7.0")
    641 
    642         self.logger.infoPair("Adding", "petrosians for extended sources")
    643         sql = "UPDATE StackApFlx AS a, SkyChip_xsrc AS b SET \
    644         petRadius=b.PETRO_RADIUS \
    645         ,petRadiusErr=b.PETRO_RADIUS_ERR \
    646         ,petFlux=POW(10.0, -0.4 * b.PETRO_MAG) /" + str(self.expTime) + " \
    647         ,petFluxErr=ABS(b.PETRO_MAG_ERR) * POW(10.0, (-0.4*b.PETRO_MAG)) / " + str(self.expTime) + " / 1.085736  \
    648         ,petR50=b.PETRO_RADIUS_50 \
    649         ,petR50Err=b.PETRO_RADIUS_50_ERR \
    650         ,petR90=b.PETRO_RADIUS_90 \
    651         ,petR90Err=b.PETRO_RADIUS_90_ERR \
    652         ,petCf=b.PETRO_FILL \
    653         WHERE a.ippDetectID=b.IPP_IDET"
    654         self.scratchDb.execute(sql)
    655 
    656         self.logger.infoPair("adding"," PrimaryF to stackApFlx")
    657         sql = "UPDATE StackApFlx AS a, " + self.scratchDb.dvoDetectionTable + " AS b SET \
    658                a.primaryF = ((b.flags & 0x10000) >> 16 ) \
    659                WHERE a.ippDetectID = b.ippDetectID \
    660                AND b.imageID = " + str(imageID)
    661 
    662         print "update dvo sql: ", sql
    663         # response = raw_input("update dvo...")
    664         self.scratchDb.execute(sql)
    665 
    666        
    667 
    668         self.scratchDb.updateAllRows("StackApFlx", "surveyID", str(self.surveyID))
    669         self.scratchDb.updateFilterID("StackApFlx", self.filter)
    670         self.scratchDb.updateAllRows("StackApFlx", "dataRelease", str(self.skychunk.dataRelease))
    671         self.scratchDb.updateAllRows("StackApFlx", "activeFlag", "0")
    672         self.updateStackMetaID("StackApFlx")
    673         self.updateStackTypeID("StackApFlx")
    674         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
    675833        self.scratchDb.reportAndDeleteRowsWithNULLS("StackApFlx", "objID")
    676         self.deleteDetectionsNotInStackDetection("StackApFlx")
     834       
    677835
    678836
    … …  
    680838    Populates the StackModelFit table
    681839    '''
    682     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
    683859        self.logger.infoPair("getting","imageID")
    684860        imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    … …  
    688864
    689865        # insert all the detections
    690         sql = "INSERT INTO StackModelFit (ippDetectID) SELECT DISTINCT IPP_IDET from SkyChip_xfit"
    691         try:
    692             self.scratchDb.execute(sql)
    693         except:
    694             return
    695866
    696867        # populate model parameters
    697868        self.logger.infoPair("Adding model fit", "deVaucouleurs")
    698         self.updateModelFit("deV", "PS_MODEL_DEV")
     869        self.updateModelFit("deV", "PS_MODEL_DEV", filter, self.header['EXPTIME'])
    699870        self.logger.infoPair("Adding model fit", "exponential")
    700         self.updateModelFit("exp", "PS_MODEL_EXP")
     871        self.updateModelFit("deV", "PS_MODEL_EXP", filter, self.header['EXPTIME'])
    701872        self.logger.infoPair("Adding model fit", "sersic")
    702         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
    703908
    704909        self.scratchDb.updateAllRows("StackModelFit", "surveyID", str(self.surveyID))
    705         self.scratchDb.updateFilterID("StackModelFit", self.filter)
    706910        self.scratchDb.updateAllRows("StackModelFit", "dataRelease", str(self.skychunk.dataRelease))
    707911
    708         self.logger.infoPair("adding"," PrimaryF to stackApFlx")
     912        self.logger.infoPair("not adding"," PrimaryF to stackApFlx")
    709913        sql = "UPDATE StackModelFit AS a, " + self.scratchDb.dvoDetectionTable + " AS b SET \
    710914               a.primaryF = ((b.flags & 0x10000) >> 16 ) \
    … …  
    712916               AND b.imageID = " + str(imageID)
    713917
    714         print "update dvo sql: ", sql
    715         # response = raw_input("update dvo...")
    716         try:
    717             self.scratchDb.execute(sql)
    718         except:
    719             return
    720 
    721         self.scratchDb.updateAllRows("StackModelFit", "activeFlag", "0")
    722         self.updateStackMetaID("StackModelFit")
    723         self.updateStackTypeID("StackModelFit")
    724         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       
    725927        self.scratchDb.reportAndDeleteRowsWithNULLS("StackModelFit", "objID")
    726         self.deleteDetectionsNotInStackDetection("StackModelFit")
    727 
    728     '''
    729     Reports and deletes detections in this table that are not in StackDetection
    730     '''
    731     def deleteDetectionsNotInStackDetection(self, table):
    732 
    733         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)"
    734937        rs = self.scratchDb.executeQuery(sql)
    735938        rs.first()
    … …  
    738941        if nMissing < 1: return
    739942       
    740         sql = "DELETE FROM " + table + " WHERE ippDetectID NOT IN (SELECT ippDetectID FROM StackDetection)"
    741         self.scratchDb.execute(sql)
    742         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))
    743946       
    744947
    … …  
    749952
    750953        self.logger.infoPair("Procesing table", "StackToImage")
    751 
    752         imageIDs = self.gpc1Db.getImageIDsForThisStackID(self.id)
    753 
    754         for imageID in imageIDs:
    755             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) \
    756973                   VALUES (\
    757                    " + 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:
    758991            self.scratchDb.execute(sql)
    759 
    760         # now update StackMeta with correct number of inputs
    761         sql = "UPDATE StackMeta SET nP2Images = (SELECT COUNT(distinct(floor(imageID/100))) FROM StackToImage)"
    762         self.scratchDb.execute(sql)
    763 
    764     '''
    765     Populates the SkinnyObject table
    766     '''
    767     def populateSkinnyObject(self):
    768 
    769         self.logger.infoPair("Procesing table", "SkinnyObject")
    770 
    771         sql = "INSERT INTO SkinnyObject (\
    772                objID \
    773                ,ippObjID \
    774                ,projectionCellID \
    775                ) \
    776                SELECT \
    777                DISTINCT objID \
    778                ,ippObjID \
    779                ,projectionCellID \
    780                FROM StackDetection"
    781         self.scratchDb.execute(sql)
    782 
    783         self.scratchDb.updateAllRows("SkinnyObject", "surveyID", str(self.surveyID))
    784         self.scratchDb.updateAllRows("SkinnyObject", "dataRelease", str(self.skychunk.dataRelease))
    785 
    786     '''   
    787     Populates the StackDetectionCalib table
    788     XXX this can probably get a big speed increase by using 'SELECT () INTO OUTFILE '/tmp/name' and then
    789     calling the load data infile '/tmp/name' into table;
    790     '''
    791     def populateStackDetectionCalibInsertUpdate(self):
    792         self.logger.infoPair("Processing table", "StackDetectionCalib")
    793         tableName = "StackDetectionCalib"
    794         # insert all detections into table
    795         sql = "INSERT INTO " + tableName + " ( \
    796                objID \
    797                ,stackDetectID \
    798                ,ippObjID \
    799                ,ippDetectID \
    800                ,filterID \
    801                ,surveyID \
    802                ) \
    803                SELECT \
    804                objID \
    805                ,stackDetectID \
    806                ,ippObjID \
    807                ,ippDetectID \
    808                ,filterID \
    809                ,surveyID \
    810                FROM StackDetection"
    811         self.scratchDb.execute(sql)
    812 
    813         imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    814         self.logger.infoPair("obtained","imageID")
    815 
    816         # insert calibration information from dvoDetections into the Table
    817         sql = "UPDATE " + tableName + " AS a, "  + self.scratchDb.dvoDetectionTable + " AS b \
    818             SET a.ra = b.ra, \
    819             a.dec = b.dec_, \
    820             a.raErr = b.raErr, \
    821             a.decErr = b.decErr, \
    822             a.zp = b.zp, \
    823             a.zpErr = b.zpErr, \
    824             a.expTime = b.expTime, \
    825             a.airMass = b.airMass   \
    826             WHERE a.stackDetectID = b.detectID \
    827             AND b.imageID = " + str(imageID)
    828         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       
    8291078        self.scratchDb.updateAllRows(tableName, "dataRelease", str(self.skychunk.dataRelease))
    830        
    831     def populateStackDetectionCalib(self):
    832 
    833         tableName = "StackDetectionCalib"
    834         self.logger.infoPair("Processing table", tableName)
    835 
    836         imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    837         self.logger.infoPair("obtained","imageID")
    838 
    839         # check for & create output directory first
    840         datadumpDir = "/tmp/datadump"
    841         try:
    842             statinfo = os.stat(datadumpDir)
    843             # check on the stat results?
    844         except:
    845             print "making the data dump directory ", datadumpDir
    846             os.mkdir(datadumpDir)
    847             os.chmod(datadumpDir, 0777)
    848             statinfo = os.stat(datadumpDir)
    849 
    850         dumpFile = datadumpDir + "/genetest.xx.dat"
    851         files = glob.glob(dumpFile)
    852         if len(files) > 0:
    853             os.unlink(dumpFile)
    854 
    855         # insert all detections into table
    856         sql = "SELECT \
    857           a.objID,    \
    858           a.stackDetectID, \
    859           a.ippObjID,      \
    860           a.ippDetectID,   \
    861           a.filterID,      \
    862           a.surveyID,      \
    863           b.ra,            \
    864           b.dec_,          \
    865           b.raErr,         \
    866           b.decErr,        \
    867           b.zp,            \
    868           b.zpErr,         \
    869           b.expTime,       \
    870           b.airMass,       \
    871           " + str(self.skychunk.dataRelease) + " \
    872          FROM              \
    873            StackDetection as a \
    874          JOIN " + self.scratchDb.dvoDetectionTable + " as b \
    875          ON (a.stackDetectID = b.detectID) where b.imageID = " + str(imageID) + \
    876          " INTO OUTFILE '" + dumpFile + "'"
    877 
    878         try: self.scratchDb.execute(sql)
    879         except:
    880             self.logger.info("failed to select data for stackDetectionCalib")
    881             self.logger.infoPair("sql: ", sql)
    882             raise
    883 
    884         sql = "LOAD DATA INFILE '" + dumpFile + "' INTO TABLE " + tableName
    885         try: self.scratchDb.execute(sql)
    886         except:
    887             self.logger.info("failed to load data from infile for stackDetectionCalib")
    888             self.logger.infoPair("sql: ", sql)
    889             raise
    890 
    891         ## XXX write this with the select/insert
    892         # self.scratchDb.updateAllRows(tableName, "dataRelease", str(self.skychunk.dataRelease))
    893 
    894     '''
    895     Populates the ObjectCalColor table
    896     '''
    897     def populateObjectCalColor(self):
    898 
    899         self.logger.infoPair("Procesing table", "ObjectCalColor table")
    900 
    901         sql = "INSERT INTO ObjectCalColor (\
    902                objID \
    903                ,ippObjID \
    904                ) \
    905                SELECT \
    906                DISTINCT objID \
    907                ,ippObjID \
    908                FROM StackDetection"
    909         self.scratchDb.execute(sql)
    910 
    911         self.scratchDb.updateFilterID("ObjectCalColor", self.filter)
    912         self.scratchDb.updateAllRows("ObjectCalColor", "dataRelease", str(self.skychunk.dataRelease))
    913 
     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)
    9141092
    9151093    '''
    … …  
    9201098        self.logger.debug("Altering PSPS tables")
    9211099        # heather uncommented the unique line -- well that no worky
    922         #self.scratchDb.makeColumnUnique("StackDetection", "objID")
    923         self.scratchDb.createIndex("StackDetection", "ippDetectID")
    924         self.scratchDb.createIndex("StackDetection", "stackDetectID")
     1100        #self.scratchDb.makeColumnUnique("StackObject", "objID")
     1101        self.scratchDb.createIndex("StackObject", "ippDetectID")
     1102        self.scratchDb.createIndex("StackObject", "stackDetectID")
    9251103        self.scratchDb.createIndex("StackApFlx", "ippDetectID")
    9261104        self.scratchDb.createIndex("StackModelFit", "ippDetectID")
    927 
    928         # dec is reserved in MySQL, so STILTS replaces if with dec_, which is not the name of
    929         # the column in PSPS
    930         self.scratchDb.execute("ALTER TABLE StackDetectionCalib CHANGE dec_ `dec` double")
    9311105
    9321106        return True
    … …  
    9441118
    9451119        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
    9461147
    9471148    '''
    9481149    Updates provided table with DVO IDs from DVO table
    9491150    '''
    950     def updateDvoIDs(self, table):
    951         self.logger.infoPair("getting","imageID")
     1151    def updateDvoIDs(self, table, filterName):
     1152        self.logger.infoPair("getting imageID for ","filter")
    9521153        imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    9531154        self.logger.infoPair("obtained","imageID")
    … …  
    9791180
    9801181        print "update dvo sql: ", sql
    981         # response = raw_input("update dvo...")
    9821182        self.scratchDb.execute(sql)
    9831183   
    … …  
    9871187    '''
    9881188    def populatePspsTables(self):
    989 
     1189        self.logger.infoPair("starting","populatePspsTables");
    9901190        self.skipBatch = False
    991 
    9921191        if not self.useFullTables:
    993             if not self.getIDsFromDVO():
     1192             if not self.getIDsFromDVO():
    9941193                return False
    995         #self.logger.infoPair("populating","StackMeta")   
    996         self.populateStackMeta()
    997         #self.logger.infoPair("populating","StackDetection")
    998         self.populateStackDetection()
    999        
    1000         if self.stackType != "NIGHTLY_STACK":
    1001             #self.logger.infoPair("populating","StackModelFit")
    1002             self.populateStackModelFit()
    1003             #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")
    10041297            self.populateStackApFlx()
    1005         #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")
    10061303        self.populateStackToImage()
    1007         #self.logger.infoPair("populating","SkinnyObject")
    1008         self.populateSkinnyObject()
    1009         #self.logger.infoPair("populating","ObjectCalColor")
    1010         #self.populateObjectCalColor()
    1011         #self.logger.infoPair("populating","StackDetectionCalib")
    1012         self.populateStackDetectionCalib()
    1013 
    1014         self.setMinMaxObjID(["StackDetection"])
    1015        
    1016         if self.totalDetections < 1:
    1017 
    1018             self.logger.error("No detections to publish")
    1019             return False
    1020 
     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");
    10211318        return True
    1022 
     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.