IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 36706 for trunk/ippToPsps


Ignore:
Timestamp:
Apr 30, 2014, 11:43:09 AM (12 years ago)
Author:
heather
Message:

working detectionbatch, needs lot of work on stack

Location:
trunk/ippToPsps
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippToPsps/config/README

    r36697 r36706  
    1111tables.FW.vot          : forced warp measurement table
    1212tables.FO.vot          : forced mean object table
     13
     14
     15Heather's Vague Instructions:
     16
     17to create a new batch db:
     18
     19create database ipptopsps2
     20cut and paste the sql file - should be no problems, I tried to reorganize them so no foriegn key constraint fails.
     21
     22to make a scratch db:
     23 check settings.xml if necessary and recompile
     24 mysql -h localhost -u dvo -pdvo -e "create database ipptopsps2_scratch"
     25 ippjython setupScratchDb.py
     26
     27should be good to go!   

  • trunk/ippToPsps/config/ippToPspsDbSchema.sql

    r36699 r36706  
    5353SET character_set_client = @saved_cs_client;
    5454
    55 --
    56 -- Table structure for table `box`
    57 --
    58 
    59 DROP TABLE IF EXISTS `box`;
    60 SET @saved_cs_client     = @@character_set_client;
    61 SET character_set_client = utf8;
    62 CREATE TABLE `box` (
    63   `timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP,
    64   `id` bigint(20) unsigned NOT NULL auto_increment,
    65   `skychunk` varchar(30) default NULL,
    66   `ra_center` float default NULL,
    67   `dec_center` float default NULL,
    68   `box_side` float default NULL,
    69   `ingested` varchar(64) default 'none',
    70   PRIMARY KEY  (`id`),
    71   KEY `fk_skychunk` (`skychunk`),
    72   CONSTRAINT `fk_skychunk` FOREIGN KEY (`skychunk`) REFERENCES `skychunk` (`name`) ON DELETE CASCADE
    73 ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;
    74 SET character_set_client = @saved_cs_client;
    7555
    7656--
    … …  
    142122
    143123--
     124-- Table structure for table `box` needs to be after skychunk or get err:150
     125--
     126
     127DROP TABLE IF EXISTS `box`;
     128SET @saved_cs_client     = @@character_set_client;
     129SET character_set_client = utf8;
     130CREATE TABLE `box` (
     131  `timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP,
     132  `id` bigint(20) unsigned NOT NULL auto_increment,
     133  `skychunk` varchar(30) default NULL,
     134  `ra_center` float default NULL,
     135  `dec_center` float default NULL,
     136  `box_side` float default NULL,
     137  `ingested` varchar(64) default 'none',
     138  PRIMARY KEY  (`id`),
     139  KEY `fk_skychunk` (`skychunk`),
     140  CONSTRAINT `fk_skychunk` FOREIGN KEY (`skychunk`) REFERENCES `skychunk` (`name`) ON DELETE CASCADE
     141) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;
     142SET character_set_client = @saved_cs_client;
     143
     144--
    144145-- Table structure for table `detection`
    145146--
    … …  
    169170  `filter` varchar(1) default NULL,
    170171  KEY `batch_id` (`batch_id`),
    171   CONSTRAINT `detection_ibfk_1` FOREIGN KEY (`batch_id`) REFERENCES `batch` (`batch_id`)
     172  CONSTRAINT `forcedwarpd_ibfk_1` FOREIGN KEY (`batch_id`) REFERENCES `batch` (`batch_id`)
    172173) ENGINE=InnoDB DEFAULT CHARSET=latin1;
    173174SET character_set_client = @saved_cs_client;
    … …  
    198199  `region` varchar(50) default NULL,
    199200  KEY `batch_id` (`batch_id`),
    200   CONSTRAINT `object_fk_1` FOREIGN KEY (`batch_id`) REFERENCES `batch` (`batch_id`)
     201  CONSTRAINT `diffobject_fk_1` FOREIGN KEY (`batch_id`) REFERENCES `batch` (`batch_id`)
    201202) ENGINE=InnoDB DEFAULT CHARSET=latin1;
    202203SET character_set_client = @saved_cs_client;
    … …  
    247248  `diff_type` varchar(20) default NULL,
    248249  KEY `batch_id` (`batch_id`),
    249   CONSTRAINT `stack_ibfk_1` FOREIGN KEY (`batch_id`) REFERENCES `batch` (`batch_id`)
     250  CONSTRAINT `diff_ibfk_1` FOREIGN KEY (`batch_id`) REFERENCES `batch` (`batch_id`)
    250251) ENGINE=InnoDB DEFAULT CHARSET=latin1;
    251252SET character_set_client = @saved_cs_client;

  • trunk/ippToPsps/config/parse_vot.pl

    r36697 r36706  
    33# this thing will just parse the votables and print out in 'ken schema style'
    44
    5 $wiki=1;
    6 
     5#$wiki=1;
     6$csv = 1;
    77$infield = 0;
    88$intable = 0;
    … …  
    3333        if($datatype eq "long") {$datatype1 = "BIGINT 8";}
    3434
    35        
     35        if ($csv) {
     36            $datatype1 =~ s/ .//;
     37
     38        }
    3639
    3740        if ($_ =~ /.*default=\"/) {
    … …  
    4952        if ($wiki) {
    5053        printf("||%-17s||   %-15s||   %-15s ||   %-5s||",$name, $unit, $datatype1, $default);
    51         } else {
    52         printf("%-17s   %-15s   %-15s    %-5s",$name, $unit, $datatype1, $default);
     54        } elsif ($csv) {
     55            printf("%s,%s,%s,%s,\"",$name, $unit, $datatype1, $default);
    5356        }
    54 
     57       
    5558
    5659        $infield = 1;
    … …  
    6871            if ($_ =~ /\<\/FIELD/) {
    6972                if ($wiki) { print "||";}
     73                if ($csv) {print "\"";}
    7074                print "\n";
    7175                $infield = 0;
    7276            }
    73 
     77           
    7478        } else {
    7579            #not in field something new
    … …  
    8084                $name =~ s/\".*//g;
    8185                $intable = 1;
    82                 print "---------------------------\n";
    83                 printf ("%-16s   ", $name);
     86                if ($csv) {
     87                    print "$name\n";
     88                } else {
     89                    print "---------------------------\n";
     90                    printf ("%-16s   ", $name);
     91                }
    8492            } else {
    8593                if ($intable) {
    86                             if ($_ =~ /\<\/DESCRIPTION/) {
    87                 $t = $_;
    88                 chomp $t;
    89                 $t =~ s/\s+\<DESCRIPTION\>//;
    90                 $t =~ s/\<\/DESCRIPTION\>//;
    91                 print "$t\n";
    92                 print "---------------------------\n";
    93                 $intable = 1;
     94                    if ($_ =~ /\<\/DESCRIPTION/) {
     95                        $t = $_;
     96                        chomp $t;
     97                        $t =~ s/\s+\<DESCRIPTION\>//;
     98                        $t =~ s/\<\/DESCRIPTION\>//;
     99                        if ($csv) {
     100                            $dostuff = 1;
     101                        } else {
     102                            print "$t\n";
     103                            print "---------------------------\n";
     104                        }
     105                        $intable = 1;
     106                       
     107                    }
     108                   
     109                }
     110            }
     111            if ($_ =~ /\<\/TABLE\>/) {
     112                $intable = 0;
    94113            }
    95114
    96                 }
    97                 if ($_ =~ /\<\/TABLE\>/) {
    98                     $intable = 0;
    99                 }
    100             }
    101 
     115           
    102116        }
    103117    }

  • trunk/ippToPsps/jython/detectionbatch.py

    r35994 r36706  
    257257               ,psfWidMinor \
    258258               ,psfTheta \
    259                ,momentFwhm \
    260                ,momentWidMajor \
    261                ,momentWidMinor \
     259               ,momentXX \
     260               ,momentXY \
     261               ,momentYY \
     262               ,momentM3C \
     263               ,momentM3S \
     264               ,momentM4C \
     265               ,momentM4S \
     266               ,momentR1 \
     267               ,momentRH \
    262268               ,apResid \
    263269               ,dapResid \
    … …  
    319325               ," + self.safeDictionaryAccess(header, 'FWHM_MIN') + " \
    320326               ," + self.safeDictionaryAccess(header, 'ANGLE') + " \
    321                , ( " + self.safeDictionaryAccess(header, 'IQ_FW1') + " + " + self.safeDictionaryAccess(header, 'IQ_FW2') + " ) / 2.0  \
    322                ," + self.safeDictionaryAccess(header, 'IQ_FW1') + " \
    323                ," + self.safeDictionaryAccess(header, 'IQ_FW2') + " \
     327               ,-999 \
     328               ,-999 \
     329               ,-999 \
     330               ,-999 \
     331               ,-999 \
     332               ,-999 \
     333               ,-999 \
     334               ,-999 \
     335               ,-999 \
    324336               ," + self.safeDictionaryAccess(header, 'APMIFIT') + " \
    325337               ," + self.safeDictionaryAccess(header, 'DAPMIFIT') + " \
    … …  
    407419               ,psfFlux \
    408420               ,psfFluxErr \
    409                ,peakADU \
    410                ,psfWidMajor \
    411                ,psfWidMinor \
     421               ,psfMajorFWHM \
     422               ,psfMinorFWHM \
    412423               ,psfTheta \
     424               ,psfCore \
    413425               ,psfLikelihood \
    414426               ,psfQf \
    … …  
    416428               ,momentXY \
    417429               ,momentYY \
     430               ,momentR1 \
     431               ,momentRH \
     432               ,momentM3C \
     433               ,momentM3S \
     434               ,momentM4C \
     435               ,momentM4S \
    418436               ,apFlux \
    419437               ,kronFlux \
    … …  
    424442               ,sky \
    425443               ,skyErr \
    426                ,sgSep \
    427                ,activeFlag \
    428                ,assocDate \
    429                ,historyModNum \
    430444               ,dataRelease \
    431445               ) \
    … …  
    441455               ,PSF_INST_FLUX / " + self.header['EXPTIME'] + " \
    442456               ,PSF_INST_FLUX_SIG / " + self.header['EXPTIME'] + " \
    443                ,POW(10.0, (-0.4*PEAK_FLUX_AS_MAG)) / " + self.header['EXPTIME'] + " \
    444457               ,PSF_MAJOR \
    445458               ,PSF_MINOR \
    446459               ,PSF_THETA \
     460               ,-999 \
    447461               ,psfLikelihood(EXT_NSIGMA) \
    448462               ,PSF_QF \
    … …  
    450464               ,MOMENTS_XY \
    451465               ,MOMENTS_YY \
     466               ,-999 \
     467               ,-999 \
     468               ,-999 \
     469               ,-999 \
     470               ,-999 \
     471               ,-999 \
    452472               ,POW(10.0, -0.4 *AP_MAG) / " + self.header['EXPTIME'] + " \
    453473               ,KRON_FLUX / " + self.header['EXPTIME'] + " \
    … …  
    458478               ,SKY  / " + self.header['EXPTIME'] + " \
    459479               ,SKY_SIGMA  / " + self.header['EXPTIME'] + " \
    460                ,EXT_NSIGMA \
    461                , 0 \
    462                , '" + self.dateStr + "' \
    463                , 0 \
    464480               , " + str(self.skychunk.dataRelease) + "\
    465481               FROM " + ippTableName
    … …  
    496512        # we don't delete these anymore
    497513        results['NULLINSTFLUX'] = 0;
    498         results['NULLPEAKADU'] = 0;
     514       
    499515
    500516    '''
    … …  
    531547    def populateDetectionCalibTableUpdateInsert(self, ota):
    532548
    533         tableName = "DetectionCalib_" + ota
     549        tableName = "Detection_" + ota
    534550        # drop then re-create table
    535         self.scratchDb.dropTable(tableName)
    536         sql = "CREATE TABLE " + tableName + " LIKE DetectionCalib"
    537         try: self.scratchDb.execute(sql)
    538         except: pass
     551        #self.scratchDb.dropTable(tableName)
     552        #sql = "CREATE TABLE " + tableName + " LIKE DetectionCalib"
     553        #try: self.scratchDb.execute(sql)
     554        #except: pass
    539555
    540556        # insert all detections into table
    … …  
    555571               ,surveyID \
    556572               FROM Detection_" + ota
    557         self.scratchDb.execute(sql)
     573#        self.scratchDb.execute(sql)
    558574
    559575        # insert calibration information from dvoDetections into the Table
    … …  
    564580            a.decErr = b.decErr, \
    565581            a.zp = b.zp, \
    566             a.zpErr = b.zpErr, \
    567582            a.expTime = b.expTime, \
    568583            a.airMass = b.airMass   \
    … …  
    577592
    578593        # target table name:
    579         tableName = "DetectionCalib_" + ota
     594        tableName = "Detection_" + ota
    580595        # drop then re-create table
    581         self.scratchDb.dropTable(tableName)
    582         sql = "CREATE TABLE " + tableName + " LIKE DetectionCalib"
    583         try: self.scratchDb.execute(sql)
    584         except: pass
     596        #self.scratchDb.dropTable(tableName)
     597        #sql = "CREATE TABLE " + tableName + " LIKE Detection"
     598        #try: self.scratchDb.execute(sql)
     599        #except: pass
    585600
    586601        externID = self.imageIDs[ota]
    587602
    588603        imageID = self.scratchDb.getImageIDFromExternID(externID)
    589         self.logger.infoPair("obtained","imageID")
    590 
    591         # check for & create output directory first
    592         datadumpDir = "/tmp/datadump"
    593         try:
    594             statinfo = os.stat(datadumpDir)
    595             # check on the stat results?
    596         except:
    597             print "making the data dump directory ", datadumpDir
    598             os.mkdir(datadumpDir)
    599             os.chmod(datadumpDir, 0777)
    600             statinfo = os.stat(datadumpDir)
    601 
    602         dumpFile = datadumpDir + "/genetest.xx.dat"
    603         files = glob.glob(dumpFile)
    604         if len(files) > 0:
    605             os.unlink(dumpFile)
     604        self.logger.infoPair("obtained imageID",imageID)
     605        self.logger.infoPair("obtained externID",externID)
    606606
    607607        # insert all detections into table
    608         sql = "SELECT \
    609           a.objID,    \
    610           a.detectID, \
    611           a.ippObjID,      \
    612           a.ippDetectID,   \
    613           a.filterID,      \
    614           a.surveyID,      \
    615           b.ra,            \
    616           b.dec_,          \
    617           b.raErr,         \
    618           b.decErr,        \
    619           b.zp,            \
    620           b.zpErr,         \
    621           b.expTime,       \
    622           b.airMass,       \
    623           " + str(self.skychunk.dataRelease) + " \
    624          FROM              \
    625            Detection_" + ota + " as a \
    626          JOIN " + self.scratchDb.dvoDetectionTable + " as b \
    627          ON (a.objID = b.objID AND a.detectID = b.detectID) \
    628          WHERE b.imageID = " + str(imageID) + \
    629          " INTO OUTFILE '" + dumpFile + "'"
     608        sql = "Update Detection_" + ota + " AS a, "+ self.scratchDb.dvoDetectionTable + " as b \
     609          set a.ra=b.ra,            \
     610          a.dec = b.dec_,          \
     611          a.raErr = b.raErr,         \
     612          a.decErr = b.decErr,        \
     613          a.zp = b.zp,            \
     614          a.expTime = b.expTime,       \
     615          a.airMass = b.airMass       \
     616          WHERE (a.objID = b.objID AND a.detectID = b.detectID) \
     617          AND b.imageID = " + str(imageID)  \
     618 
    630619
    631620        try: self.scratchDb.execute(sql)
    632621        except:
    633             self.logger.info("failed to select data for detectionCalib")
    634             self.logger.infoPair("sql: ", sql)
    635             raise
    636 
    637         sql = "LOAD DATA INFILE '" + dumpFile + "' INTO TABLE " + tableName
    638         try: self.scratchDb.execute(sql)
    639         except:
    640             self.logger.info("failed to load data from infile for detectionCalib")
     622            self.logger.info("failed to update data for detectionCalib")
    641623            self.logger.infoPair("sql: ", sql)
    642624            raise
    … …  
    751733        # dec is reserved in MySQL, so STILTS replaces if with dec_, which is not the name of
    752734        # the column in PSPS
    753         self.scratchDb.execute("ALTER TABLE DetectionCalib CHANGE dec_ `dec` double")
     735        self.scratchDb.execute("ALTER TABLE Detection CHANGE dec_ `dec` double")
    754736
    755737        return True
    … …  
    818800            return False
    819801
    820         self.logger.info("populate stuff ");
     802        #self.logger.info("populate stuff ");
    821803        # populate remainder of tables
    822804        self.populateDetectionTable(chipname, results)
    823         self.logger.info("successful populate ");
     805        #self.logger.info("successful populate ");
    824806        # now add DVO IDs
    825807        self.updateDvoIDs("Detection_" + chipname, self.imageIDs[chipname])
    826         self.logger.info("updated dvoids")
     808        #self.logger.info("updated dvoids")
    827809        results['NULLOBJID'] = self.scratchDb.reportAndDeleteRowsWithNULLS("Detection_" + chipname, "objID")
    828810        #self.logger.info("deleted nulls")
    829811        self.updateImageID("Detection_" + chipname, x, y)
    830         self.logger.info("updateImageId")
     812        #self.logger.info("updateImageId")
    831813        rowCount = self.scratchDb.getRowCount("Detection_" + chipname)
    832         self.logger.info("got row count")
    833         self.logger.info("| %5s | %13d | %13d | %13d | %13d | %13d | %13d |",
     814        #self.logger.info("got row count")
     815        self.logger.info("| %5s | %13d | %13d | %13d | %13d | %13d |",
    834816                chipname,
    835817                results['ORIGINALTOTAL'],
    836818                results['SATDET'],
    837819                results['NULLINSTFLUX'],
    838                 results['NULLPEAKADU'],
    839820                results['NULLOBJID'],
    840821                rowCount)
    … …  
    842823        self.totalSatDet       = self.totalSatDet + results['SATDET']
    843824        self.totalNulIInstFlux = self.totalNulIInstFlux + results['NULLINSTFLUX']
    844         self.totalNullPeakFlux = self.totalNullPeakFlux + results['NULLPEAKADU']
    845825        self.totalNullObjID    = self.totalNullObjID + results['NULLOBJID']
    846826        self.totalDetections   = self.totalDetections + rowCount
    … …  
    867847        self.scratchDb.execute(sql)
    868848       
    869         self.logger.info("updated imagedata")
    870         self.populateSkinnyObjectTable(chipname)
    871         self.logger.info("updated skinnyobject")
    872         #self.populateObjectCalColorTable(chipname)
    873         #self.logger.info("updated objectcalcolor")
     849        #self.logger.info("updated imagedata")
     850       
    874851        self.populateDetectionCalibTable(chipname)
    875         self.logger.info("updated detectioncalibtable")
     852        #self.logger.info("updated detectioncalibtable")
    876853       
    877854        # add these to list of tables to export later
    … …  
    882859        self.logger.info("export Detection")
    883860
    884         self.tablesToExport.append("SkinnyObject_" + chipname)
    885         self.logger.info("export Skinny")
    886 
    887         #self.tablesToExport.append("ObjectCalColor_" + chipname)
    888         self.tablesToExport.append("DetectionCalib_" + chipname)
    889         self.logger.info("export DetectionCalib")
    890 
     861       
    891862        tables.append("Detection_" + chipname)
    892863        self.logger.info("updated detectioncalibtable")
    … …  
    910881        results = {}
    911882        self.totalOriginal = self.totalSatDet = self.totalNulIInstFlux = self.totalNullPeakFlux = self.totalNullObjID = self.totalDetections = 0
    912         self.logger.info("+-------+---------------+---------------+---------------+---------------+---------------+---------------+")
    913         self.logger.info("|  OTA  | Initial total |   Sat Det     | NULL instFlux | NULL peak ADU | NULL obj ID   |  Remainder    |")
    914         self.logger.info("+-------+---------------+---------------+---------------+---------------+---------------+---------------+")
     883        self.logger.info("+-------+---------------+---------------+---------------+---------------+---------------+")
     884        self.logger.info("|  OTA  | Initial total |   Sat Det     | NULL instFlux | NULL obj ID   |  Remainder    |")
     885        self.logger.info("+-------+---------------+---------------+---------------+---------------+---------------+")
    915886        for x in range(self.startX, self.endX):
    916887            for y in range(self.startY, self.endY):
    … …  
    937908
    938909        # print totals
    939         self.logger.info("+-------+---------------+---------------+---------------+---------------+---------------+---------------+")
     910        self.logger.info("+-------+---------------+---------------+---------------+---------------+---------------+")
    940911        self.logger.info("| Total | %13d | %13d | %13d | %13d | %13d | %13d |",
    941912                self.totalOriginal,
    … …  
    945916                self.totalNullObjID,
    946917                self.totalDetections)
    947         self.logger.info("+-------+---------------+---------------+---------------+---------------+---------------+---------------+")
     918        self.logger.info("+-------+---------------+---------------+---------------+---------------+---------------+")
    948919
    949920        # if we only have one table export, i.e. FrameMeta, then get out of here (skip batch, but do not abort)

  • trunk/ippToPsps/jython/stackbatch.py

    r36447 r36706  
    9898       # delete PSPS tables
    9999       self.scratchDb.dropTable("StackMeta")
    100        self.scratchDb.dropTable("StackDetection")
     100       self.scratchDb.dropTable("StackObject")
    101101       self.scratchDb.dropTable("StackModelFit")
    102102       self.scratchDb.dropTable("StackApFlx")
    103103       self.scratchDb.dropTable("StackToImage")
    104        self.scratchDb.dropTable("SkinnyObject")
    105        #self.scratchDb.dropTable("ObjectCalColor")
    106        self.scratchDb.dropTable("StackDetectionCalib")
    107 
    108        # self.testprint()
     104             # self.testprint()
    109105
    110106       # delete IPP tables
    … …  
    447443
    448444    '''
    449     Populates the StackDetection table
    450     '''
    451     def populateStackDetection(self):
    452 
    453         self.logger.infoPair("Procesing table", "StackDetection")
     445    Populates the StackObject table
     446    '''
     447    def populateStackObject(self):
     448
     449        self.logger.infoPair("Procesing table", "StackObject")
    454450
    455451        # insert all the detections
    456         sql = "INSERT INTO StackDetection (\
     452        sql = "INSERT INTO StackObject(\
    457453               ippDetectID \
    458454               ,skyCellID \
    … …  
    550546        #it is possible to drop some detections from dvo (that are present in the cmf). when that happens we get a 0 for objid
    551547        #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")
     548        sql="DELETE FROM StackObject where objID = 0"
     549        self.scratchDb.execute(sql)
     550        self.logger.infoPair("Deleting", "entries with StackObject.objID = 0")
    555551       
    556552        # XXX EAM : this seems quite inefficient : these commands use updates to set
    … …  
    558554        # the original insert above?
    559555
    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))
     556        self.scratchDb.updateAllRows("StackObject", "surveyID", str(self.surveyID))
     557       
     558        self.scratchDb.updateFilterID("StackObject", self.filter)
     559       
     560        self.scratchDb.updateAllRows("StackObject", "dataRelease", str(self.skychunk.dataRelease))
    565561        #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")
     562        self.scratchDb.updateAllRows("StackObject", "primaryF", "0")
     563       
     564        self.scratchDb.updateAllRows("StackObject", "activeFlag", "0")
     565       
     566        self.updateStackMetaID("StackObject")
     567       
     568        self.updateStackTypeID("StackObject")
     569       
     570        self.updateDvoIDsAndFlags("StackObject")
    575571        #this now updates primary F as well
    576572        # response = raw_input("updated dvo ")
    … …  
    585581            self.scratchDb.execute("set session old_alter_table=1")
    586582
    587         sql = "ALTER IGNORE TABLE StackDetection ADD PRIMARY KEY (objID)"
     583        sql = "ALTER IGNORE TABLE StackObject ADD PRIMARY KEY (objID)"
    588584       
    589585        if self.scratchDb.version > 5.1:
    … …  
    597593
    598594            #if deep stack and instFlux = null and err not null
    599             sql = "UPDATE StackDetection AS a, SkyChip_psf AS b \
     595            sql = "UPDATE StackObject AS a, SkyChip_psf AS b \
    600596                   SET psfFlux = 2*b.PSF_INST_FLUX_SIG / " + str(self.expTime) + " \
    601597                   WHERE psfFlux IS NULL \
    … …  
    610606        # something like (f < 0.0) ? -999 : -2.5*log10(f)
    611607        # 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"
     608        sql = "UPDATE StackObject SET psfFlux = 1e20 WHERE psfFlux <= 0.0"
     609        self.scratchDb.execute(sql)
     610       
     611        sql = "UPDATE StackObject SET apFlux = 1e20 WHERE apFlux <= 0.0"
     612        self.scratchDb.execute(sql)
     613
     614        sql = "UPDATE StackObject SET kronFlux = 1e20 WHERE kronFlux <= 0.0"
    619615        self.scratchDb.execute(sql)
    620616
    621617        #leave null instflux in
    622         #self.scratchDb.reportAndDeleteRowsWithNULLS("StackDetection", "instFlux")
    623        
    624         self.scratchDb.reportAndDeleteRowsWithNULLS("StackDetection", "objID")
     618        #self.scratchDb.reportAndDeleteRowsWithNULLS("StackObject", "instFlux")
     619       
     620        self.scratchDb.reportAndDeleteRowsWithNULLS("StackObject", "objID")
    625621        # response = raw_input("delete nulls ")
    626622       
    627         sql="DELETE FROM StackDetection where objID = 0"
    628        
    629         self.scratchDb.execute(sql)
    630         self.logger.infoPair("Deleting", "entries with StackDetection.objID = 0")
     623        sql="DELETE FROM StackObject where objID = 0"
     624       
     625        self.scratchDb.execute(sql)
     626        self.logger.infoPair("Deleting", "entries with StackObject.objID = 0")
    631627        # response = raw_input("deleted objID is 0 ")
    632628       
    … …  
    709705        self.updateDvoIDs("StackApFlx")
    710706        self.scratchDb.reportAndDeleteRowsWithNULLS("StackApFlx", "objID")
    711         self.deleteDetectionsNotInStackDetection("StackApFlx")
     707        self.deleteDetectionsNotInStackObject("StackApFlx")
    712708
    713709
    … …  
    759755        self.updateDvoIDs("StackModelFit")
    760756        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)"
     757        self.deleteDetectionsNotInStackObject("StackModelFit")
     758
     759    '''
     760    Reports and deletes detections in this table that are not in StackObject
     761    '''
     762    def deleteDetectionsNotInStackObject(self, table):
     763
     764        sql = "SELECT COUNT(*) FROM " + table + " WHERE ippDetectID NOT IN (SELECT ippDetectID FROM StackObject)"
    769765        rs = self.scratchDb.executeQuery(sql)
    770766        rs.first()
    … …  
    773769        if nMissing < 1: return
    774770       
    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))
     771        sql = "DELETE FROM " + table + " WHERE ippDetectID NOT IN (SELECT ippDetectID FROM StackObject)"
     772        self.scratchDb.execute(sql)
     773        self.logger.infoPair("Detections not in StackObject", "%d deleted from %s" % (nMissing, table))
    778774       
    779775
    … …  
    797793        self.scratchDb.execute(sql)
    798794
    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))
    820795
    821796    '''   
    822     Populates the StackDetectionCalib table
     797    Populates the StackObjectCalib table
    823798    XXX this can probably get a big speed increase by using 'SELECT () INTO OUTFILE '/tmp/name' and then
    824799    calling the load data infile '/tmp/name' into table;
    825800    '''
    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)
     801    def populateStackObjectCalibInsertUpdate(self):
     802        self.logger.infoPair("Processing table", "StackObject")
     803        tableName = "StackObject"
    847804
    848805        imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    … …  
    856813            a.decErr = b.decErr, \
    857814            a.zp = b.zp, \
    858             a.zpErr = b.zpErr, \
    859815            a.expTime = b.expTime, \
    860816            a.airMass = b.airMass   \
    … …  
    864820        self.scratchDb.updateAllRows(tableName, "dataRelease", str(self.skychunk.dataRelease))
    865821       
    866     def populateStackDetectionCalib(self):
    867 
    868         tableName = "StackDetectionCalib"
     822    def populateStackObjectCalib(self):
     823
     824        tableName = "StackObject"
    869825        self.logger.infoPair("Processing table", tableName)
    870826
    871827        imageID = self.scratchDb.getImageIDFromExternID(self.header['IMAGEID'])
    872828        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
     829        sql = "UPDATE " + tableName + " AS a, "  + self.scratchDb.dvoDetectionTable + " AS b \
     830            SET a.ra = b.ra, \
     831            a.dec = b.dec_, \
     832            a.raErr = b.raErr, \
     833            a.decErr = b.decErr, \
     834            a.zp = b.zp, \
     835            a.expTime = b.expTime, \
     836            a.airMass = b.airMass   \
     837            WHERE a.stackDetectID = b.detectID \
     838            AND b.imageID = " + str(imageID)
     839        self.scratchDb.execute(sql)
     840        self.scratchDb.updateAllRows(tableName, "dataRelease", str(self.skychunk.dataRelease))
    925841
    926842        ## XXX write this with the select/insert
    … …  
    928844
    929845    '''
    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 
    949 
    950     '''
    951846    Applies indexes to the PSPS tables
    952847    '''
    … …  
    955850        self.logger.debug("Altering PSPS tables")
    956851        # 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")
     852        #self.scratchDb.makeColumnUnique("StackObject", "objID")
     853        self.scratchDb.createIndex("StackObject", "ippDetectID")
     854        self.scratchDb.createIndex("StackObject", "stackDetectID")
    960855        self.scratchDb.createIndex("StackApFlx", "ippDetectID")
    961856        self.scratchDb.createIndex("StackModelFit", "ippDetectID")
    … …  
    963858        # dec is reserved in MySQL, so STILTS replaces if with dec_, which is not the name of
    964859        # the column in PSPS
    965         self.scratchDb.execute("ALTER TABLE StackDetectionCalib CHANGE dec_ `dec` double")
     860        self.scratchDb.execute("ALTER TABLE StackObject CHANGE dec_ `dec` double")
    966861
    967862        return True
    … …  
    1030925        #self.logger.infoPair("populating","StackMeta")   
    1031926        self.populateStackMeta()
    1032         #self.logger.infoPair("populating","StackDetection")
    1033         self.populateStackDetection()
     927        #self.logger.infoPair("populating","StackObject")
     928        self.populateStackObject()
    1034929       
    1035930        if self.stackType != "NIGHTLY_STACK":
    … …  
    1040935        #self.logger.infoPair("populating","StackToImage")
    1041936        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"])
     937        #self.logger.infoPair("populating","StackObjectCalib")
     938        self.populateStackObjectCalib()
     939
     940        self.setMinMaxObjID(["StackObject"])
    1050941       
    1051942        if self.totalDetections < 1:
Note: See TracChangeset for help on using the changeset viewer.