IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 34260


Ignore:
Timestamp:
Jul 31, 2012, 4:02:00 PM (14 years ago)
Author:
eugene
Message:

add PS1_V4 schema; add set mean fluxes based on stacks; define the primary image ID (based on distance from center or boundary tree) and set mean flux from stacks based on that info; fix (uniquify) psps ID for stack detections; mean fluxes are in Jy; detection fluxes are instrumental counts per second

Location:
trunk/Ohana/src
Files:
71 edited
17 copied

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/addstar/Makefile

    r34088 r34260  
    1717FULL_LDFLAGS  = -lkapa -ldvo -lFITS -lohana $(BASE_LDFLAGS)
    1818
    19 addstar     : $(BIN)/addstar.$(ARCH)
    20 addstard    : $(BIN)/addstard.$(ARCH)
    21 addstart    : $(BIN)/addstart.$(ARCH)
    22 addstarc    : $(BIN)/addstarc.$(ARCH)
    23 mkacc-2mass : $(BIN)/mkacc-2mass.$(ARCH)
    24 sedstar     : $(BIN)/sedstar.$(ARCH)
    25 load2mass   : $(BIN)/load2mass.$(ARCH)
    26 loadwise    : $(BIN)/loadwise.$(ARCH)
    27 loadsupercos: $(BIN)/loadsupercos.$(ARCH)
    28 gztest      : $(BIN)/gztest.$(ARCH)
    29 mkcmf       : $(BIN)/mkcmf.$(ARCH)
     19addstar      : $(BIN)/addstar.$(ARCH)
     20addstard     : $(BIN)/addstard.$(ARCH)
     21addstart     : $(BIN)/addstart.$(ARCH)
     22addstarc     : $(BIN)/addstarc.$(ARCH)
     23mkacc-2mass  : $(BIN)/mkacc-2mass.$(ARCH)
     24sedstar      : $(BIN)/sedstar.$(ARCH)
     25load2mass    : $(BIN)/load2mass.$(ARCH)
     26loadwise     : $(BIN)/loadwise.$(ARCH)
     27dumpskycells : $(BIN)/dumpskycells.$(ARCH)
     28findskycell  : $(BIN)/findskycell.$(ARCH)
     29loadsupercos : $(BIN)/loadsupercos.$(ARCH)
     30gztest       : $(BIN)/gztest.$(ARCH)
     31mkcmf        : $(BIN)/mkcmf.$(ARCH)
    3032
    3133all: addstar addstar_client sedstar load2mass skycells mkcmf loadwise loadsupercos dumpskycells
    3234
    33 INSTALL = addstar addstar_client sedstar load2mass skycells mkcmf loadwise loadsupercos dumpskycells
     35INSTALL = addstar addstar_client sedstar load2mass skycells mkcmf loadwise loadsupercos dumpskycells findskycell
    3436
    3537# I need to fix the client/server version of addstar now that I have dropped Stars
    … …  
    299301$(SRC)/SetSignals.$(ARCH).o \
    300302
     303FINDSKYCELL = \
     304$(SRC)/findskycell.$(ARCH).o \
     305$(SRC)/Shutdown.$(ARCH).o
     306
    301307$(ADDSTARC)       : $(INC)/addstar.h
    302308$(ADDSTARD)       : $(INC)/addstar.h
    … …  
    306312$(SKYCELLS)       : $(INC)/addstar.h
    307313$(DUMPSKYCELLS)   : $(INC)/addstar.h
     314$(FINDSKYCELL)    : $(INC)/addstar.h
    308315$(LOAD-2MASS)     : $(INC)/addstar.h $(INC)/2mass.h
    309316$(LOAD-WISE)      : $(INC)/addstar.h $(INC)/WISE.h
    … …  
    322329$(BIN)/skycells.$(ARCH)       : $(SKYCELLS)
    323330$(BIN)/dumpskycells.$(ARCH)   : $(DUMPSKYCELLS)
     331$(BIN)/findskycell.$(ARCH)    : $(FINDSKYCELL)
    324332$(BIN)/mkcmf.$(ARCH)          : $(MKCMF)
    325333

  • trunk/Ohana/src/addstar/include/addstar.h

    r33963 r34260  
    297297uint64_t CreatePSPSDetectionID(double tobs, int ccdid, int detID);
    298298uint64_t CreatePSPSObjectID(double ra, double dec);
     299uint64_t CreatePSPSStackDetectionID(int sourceID, int imageID, int detID);
    299300
    300301int altaz (double *alt, double *az, double ha, double dec, double latitude);

  • trunk/Ohana/src/addstar/include/skycells.h

    r33719 r34260  
    1212# include <glob.h>
    1313
    14 enum {SQUARES, TRIANGLES, LOCAL, RINGS};
     14enum {SQUARES, TRIANGLES, LOCAL, RINGS, TAMAS};
    1515enum {TETRAHEDRON, CUBE, OCTOHEDRON, DODECAHEDRON, ICOSAHEDRON};
    1616
    … …  
    9595int          sky_tessellation_squares       PROTO((FITS_DB *db, int level, int Nmax));
    9696int          sky_tessellation_rings         PROTO((FITS_DB *db, int level, int Nmax));
     97int          sky_tessellation_tamas         PROTO((FITS_DB *db, int level, int Nmax));
    9798
    9899int          sky_triangle_to_image          PROTO((Image *image, SkyTriangle *triangle));
    … …  
    104105
    105106SkyRectangle *sky_rectangle_ring            PROTO((float dec, float dDEC, int *nring, char *format));
     107SkyRectangle *sky_rectangle_tamas           PROTO((double *Dec, double dm, double halfa, double halftheta, int *nring, char *format));
    106108
    107109SkyTriangle *sky_divide_triangles           PROTO((SkyTriangle *in, int *ntriangles));

  • trunk/Ohana/src/addstar/src/FilterStars.c

    r29001 r34260  
    8484      stars[N].measure.Map += MTIME - dMs;
    8585    }
     86    if (!isnan(stars[N].measure.Mkron)) {
     87      stars[N].measure.Mkron += MTIME - dMs;
     88    }
     89    if (!isnan(stars[N].measure.FluxPSF)) {
     90      stars[N].measure.FluxPSF /= image[0].exptime;
     91    }
     92    if (!isnan(stars[N].measure.dFluxPSF)) {
     93      stars[N].measure.dFluxPSF /= image[0].exptime;
     94    }
     95    if (!isnan(stars[N].measure.FluxKron)) {
     96      stars[N].measure.FluxKron /= image[0].exptime;
     97    }
     98    if (!isnan(stars[N].measure.dFluxKron)) {
     99      stars[N].measure.dFluxKron /= image[0].exptime;
     100    }
    86101   
    87102    // the external ID is supplied, but do we trust it?
    … …  
    93108      double mjd;
    94109      mjd = ohana_sec_to_mjd (image[0].tzero);
    95       stars[N].measure.extID = CreatePSPSDetectionID(mjd, image[0].ccdnum, stars[N].measure.detID);
     110      int isStack = ((image[0].photcode >= 11000) && (image[0].photcode <= 11400));
     111
     112      if (isStack) {
     113        stars[N].measure.extID = CreatePSPSStackDetectionID(image[0].sourceID, image[0].externID, stars[N].measure.detID);
     114      } else {
     115        stars[N].measure.extID = CreatePSPSDetectionID(mjd, image[0].ccdnum, stars[N].measure.detID);
     116      }
    96117    } else {
    97118      stars[N].measure.extID = 0;

  • trunk/Ohana/src/addstar/src/ReadStarsFITS.c

    r31160 r34260  
    1010  Header theader;
    1111  FTable table;
    12   Stars *stars;
     12  Stars *stars; // Stars contains Average and Measure
    1313 
    1414  if (in_theader == NULL) {
    … …  
    8989    InitStar (&stars[i]);
    9090
    91     stars[i].measure.Xccd      = smpdata[i].X;
    92     stars[i].measure.Yccd      = smpdata[i].Y;
     91    stars[i].measure.Xccd       = smpdata[i].X;
     92    stars[i].measure.Yccd       = smpdata[i].Y;
     93    stars[i].measure.dXccd      = NAN_S_SHORT; // not provided by SMPDATA:
     94    stars[i].measure.dYccd      = NAN_S_SHORT; // not provided by SMPDATA:
     95   
     96    stars[i].measure.posangle   = NAN_S_SHORT; // not provided by SMPDATA:
     97    stars[i].measure.pltscale   = NAN;         // not provided by SMPDATA:
    9398
    9499    if ((smpdata[i].M >= ZeroPt) || isnan(smpdata[i].M)) {
    95       stars[i].measure.M       = NAN;
    96       stars[i].measure.Map     = NAN;
    97     } else {
    98       stars[i].measure.M       = smpdata[i].M;
    99       stars[i].measure.Map     = smpdata[i].M;
    100     }
    101 
    102     stars[i].measure.dM        = smpdata[i].dM*0.001;
    103 
     100      stars[i].measure.M        = NAN;
     101      stars[i].measure.Map      = NAN;
     102      stars[i].measure.FluxPSF  = NAN;
     103      stars[i].measure.dFluxPSF = NAN;
     104    } else {
     105      stars[i].measure.M        = smpdata[i].M;
     106      stars[i].measure.Map      = smpdata[i].M;
     107      stars[i].measure.FluxPSF  = pow(10.0, -0.4*smpdata[i].M);
     108      stars[i].measure.dFluxPSF = stars[i].measure.FluxPSF * smpdata[i].dM;
     109    }
     110    stars[i].measure.dM         = smpdata[i].dM*0.001;
     111    stars[i].measure.dMcal      = NAN; // not provided by SMPDATA:
     112
     113    stars[i].measure.Mkron      = NAN; // not provided by SMPDATA:
     114    stars[i].measure.dMkron     = NAN; // not provided by SMPDATA:
     115    stars[i].measure.FluxKron   = NAN; // not provided by SMPDATA:
     116    stars[i].measure.dFluxKron  = NAN; // not provided by SMPDATA:
     117
     118    stars[i].measure.Sky        = NAN; // not provided by SMPDATA:
     119    stars[i].measure.dSky       = NAN; // not provided by SMPDATA:
     120
     121    stars[i].measure.psfChisq   = NAN;       // not provided by SMPDATA:
     122    stars[i].measure.psfQual    = NAN;       // not provided by SMPDATA:
     123    stars[i].measure.psfNdof    = NAN_S_INT; // not provided by SMPDATA:
     124    stars[i].measure.psfNpix    = NAN_S_INT; // not provided by SMPDATA:
     125    stars[i].measure.crNsigma   = NAN;       // not provided by SMPDATA:
     126    stars[i].measure.extNsigma  = NAN;       // not provided by SMPDATA:
     127
     128    stars[i].measure.FWx        = ToShortPixels (smpdata[i].fx);
     129    stars[i].measure.FWy        = ToShortPixels (smpdata[i].fy);
     130    stars[i].measure.theta      = ToShortDegrees (smpdata[i].df);
     131
     132    stars[i].measure.Mxx        = NAN_S_SHORT; // not provided by SMPDATA:
     133    stars[i].measure.Mxy        = NAN_S_SHORT; // not provided by SMPDATA:
     134    stars[i].measure.Myy        = NAN_S_SHORT; // not provided by SMPDATA:
     135                       
    104136    // the dophot type information gets pushed into the upper 2 bytes of photFlags
    105     stars[i].measure.photFlags = (smpdata[i].dophot << 16);
    106 
    107     stars[i].measure.FWx       = ToShortPixels (smpdata[i].fx);
    108     stars[i].measure.FWy       = ToShortPixels (smpdata[i].fy);
    109     stars[i].measure.theta     = ToShortDegrees (smpdata[i].df);
     137    stars[i].measure.photFlags  = (smpdata[i].dophot << 16);
    110138  }   
    111139  *nstars = Nstars;
    … …  
    131159  for (i = 0; i < Nstars; i++) {
    132160    InitStar (&stars[i]);
    133     stars[i].measure.Xccd     = ps1data[i].X;
    134     stars[i].measure.Yccd     = ps1data[i].Y;
    135 
    136     stars[i].measure.dXccd    = ToShortPixels(ps1data[i].dX);
    137     stars[i].measure.dYccd    = ToShortPixels(ps1data[i].dY);
     161    stars[i].measure.Xccd       = ps1data[i].X;
     162    stars[i].measure.Yccd       = ps1data[i].Y;
     163    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
     164    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
    138165   
     166    stars[i].measure.posangle   = NAN_S_SHORT; // not provided by PS1_DEV_0:
     167    stars[i].measure.pltscale   = NAN;         // not provided by PS1_DEV_0:
     168
    139169    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
    140       stars[i].measure.M      = NAN;
    141     } else {
    142       stars[i].measure.M      = ps1data[i].M + ZeroPt;
    143     }
    144     stars[i].measure.Map      = NAN;
    145     stars[i].measure.dM       = ps1data[i].dM;
    146     stars[i].measure.Sky      = ps1data[i].sky;
    147     stars[i].measure.dSky     = ps1data[i].dSky;
    148 
    149     stars[i].measure.FWx      = ToShortPixels(ps1data[i].fx);
    150     stars[i].measure.FWy      = ToShortPixels(ps1data[i].fy);
    151     stars[i].measure.theta    = ToShortDegrees(ps1data[i].df);
    152 
    153     stars[i].measure.psfChisq = ps1data[i].psfChisq;
    154     stars[i].measure.psfQual  = ps1data[i].psfQual;
    155 
    156     stars[i].measure.detID    = ps1data[i].detID;
     170      stars[i].measure.M        = NAN;
     171      stars[i].measure.FluxPSF  = NAN;
     172      stars[i].measure.dFluxPSF = NAN;
     173    } else {
     174      stars[i].measure.M        = ps1data[i].M + ZeroPt;
     175      stars[i].measure.FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
     176      stars[i].measure.dFluxPSF = stars[i].measure.FluxPSF * ps1data[i].dM;
     177    }
     178    stars[i].measure.dM         = ps1data[i].dM;
     179    stars[i].measure.dMcal      = NAN; // not provided by PS1_DEV_0:
     180    stars[i].measure.Map        = NAN; // not provided by PS1_DEV_0:
     181
     182    stars[i].measure.Mkron      = NAN; // not provided by PS1_DEV_0:
     183    stars[i].measure.dMkron     = NAN; // not provided by PS1_DEV_0:
     184    stars[i].measure.FluxKron   = NAN; // not provided by PS1_DEV_0:
     185    stars[i].measure.dFluxKron  = NAN; // not provided by PS1_DEV_0:
     186
     187    stars[i].measure.Sky        = ps1data[i].sky;
     188    stars[i].measure.dSky       = ps1data[i].dSky;
     189
     190    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
     191    stars[i].measure.psfQual    = ps1data[i].psfQual;
     192    stars[i].measure.psfNdof    = NAN_S_INT; // not provided by PS1_DEV_0:
     193    stars[i].measure.psfNpix    = NAN_S_INT; // not provided by PS1_DEV_0:
     194    stars[i].measure.crNsigma   = NAN;       // not provided by PS1_DEV_0:
     195    stars[i].measure.extNsigma  = NAN;        // not provided by PS1_DEV_0:
     196
     197    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
     198    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
     199    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
     200
     201    stars[i].measure.Mxx        = NAN_S_SHORT; // not provided by PS1_DEV_0:
     202    stars[i].measure.Mxy        = NAN_S_SHORT; // not provided by PS1_DEV_0:
     203    stars[i].measure.Myy        = NAN_S_SHORT; // not provided by PS1_DEV_0:
     204                       
     205    stars[i].measure.photFlags  = 0; // not provided by PS1_DEV_0:
     206
     207    stars[i].measure.detID      = ps1data[i].detID;
    157208  }   
    158209  *nstars = Nstars;
    … …  
    182233    stars[i].measure.Xccd       = ps1data[i].X;
    183234    stars[i].measure.Yccd       = ps1data[i].Y;
    184 
    185235    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
    186236    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
    187237
     238    stars[i].measure.posangle   = NAN_S_SHORT; // not provided by PS1_DEV_1:
     239    stars[i].measure.pltscale   = NAN;         // not provided by PS1_DEV_1:
     240
    188241    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
    189         stars[i].measure.M      = NAN;
    190     } else {
    191         stars[i].measure.M      = ps1data[i].M + ZeroPt;
    192     }
    193     stars[i].measure.Map        = NAN;
     242      stars[i].measure.M      = NAN;
     243      stars[i].measure.FluxPSF  = NAN;
     244      stars[i].measure.dFluxPSF = NAN;
     245    } else {
     246      stars[i].measure.M      = ps1data[i].M + ZeroPt;
     247      stars[i].measure.FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
     248      stars[i].measure.dFluxPSF = stars[i].measure.FluxPSF * ps1data[i].dM;
     249    }
    194250    stars[i].measure.dM         = ps1data[i].dM;
     251    stars[i].measure.dMcal      = NAN; // not provided by PS1_DEV_1:
     252    stars[i].measure.Map        = NAN; // not provided by PS1_DEV_1:
     253
     254    stars[i].measure.Mkron      = NAN; // not provided by PS1_DEV_1:
     255    stars[i].measure.dMkron     = NAN; // not provided by PS1_DEV_1:
     256    stars[i].measure.FluxKron   = NAN; // not provided by PS1_DEV_1:
     257    stars[i].measure.dFluxKron  = NAN; // not provided by PS1_DEV_1:
     258
    195259    stars[i].measure.Sky        = ps1data[i].sky;
    196260    stars[i].measure.dSky       = ps1data[i].dSky;
     261
     262    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
     263    stars[i].measure.psfQual    = ps1data[i].psfQual;
     264    stars[i].measure.psfNdof    = NAN_S_INT; // not provided by PS1_DEV_1:
     265    stars[i].measure.psfNpix    = NAN_S_INT; // not provided by PS1_DEV_1:
     266    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     267    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
    197268
    198269    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
    … …  
    200271    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
    201272
    202     stars[i].measure.psfChisq   = ps1data[i].psfChisq;
    203     stars[i].measure.psfQual    = ps1data[i].psfQual;
    204     stars[i].measure.crNsigma   = ps1data[i].crNsigma;
    205     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
    206 
    207     stars[i].measure.detID      = ps1data[i].detID;
     273    stars[i].measure.Mxx        = NAN_S_SHORT; // not provided by PS1_DEV_1:
     274    stars[i].measure.Mxy        = NAN_S_SHORT; // not provided by PS1_DEV_1:
     275    stars[i].measure.Myy        = NAN_S_SHORT; // not provided by PS1_DEV_1:
     276                       
    208277    stars[i].measure.photFlags  = ps1data[i].flags;
     278
     279    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
     280    stars[i].measure.detID      = ps1data[i].detID;
    209281  }   
    210282  *nstars = Nstars;
    … …  
    229301
    230302  if (table[0].header[0].Naxis[0] == 136) {
    231       stars = Convert_PS1_V1_Alt (table, nstars);
    232       return (stars);
     303    stars = Convert_PS1_V1_Alt (table, nstars);
     304    return (stars);
    233305  }
    234306
    … …  
    252324
    253325    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
    254         stars[i].measure.M      = NAN;
    255     } else {
    256         stars[i].measure.M      = ps1data[i].M + ZeroPt;
     326      stars[i].measure.M      = NAN;
     327      stars[i].measure.FluxPSF  = NAN;
     328      stars[i].measure.dFluxPSF = NAN;
     329    } else {
     330      stars[i].measure.M      = ps1data[i].M + ZeroPt;
     331      stars[i].measure.FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
     332      stars[i].measure.dFluxPSF = stars[i].measure.FluxPSF * ps1data[i].dM;
    257333    }
    258334    stars[i].measure.dM         = ps1data[i].dM;
    259335    stars[i].measure.dMcal      = ps1data[i].dMcal;
    260336    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
    261                        
     337                       
     338    stars[i].measure.Mkron      = NAN; // not provided by PS1_V1:
     339    stars[i].measure.dMkron     = NAN; // not provided by PS1_V1:
     340    stars[i].measure.FluxKron   = NAN; // not provided by PS1_V1:
     341    stars[i].measure.dFluxKron  = NAN; // not provided by PS1_V1:
     342
    262343    stars[i].measure.Sky        = ps1data[i].sky;
    263344    stars[i].measure.dSky       = ps1data[i].dSky;
    264                        
     345                       
    265346    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
    266347    stars[i].measure.psfQual    = ps1data[i].psfQual;
    … …  
    277358    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
    278359    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
    279                        
     360                       
    280361    stars[i].measure.photFlags  = ps1data[i].flags;
    281362
    … …  
    328409
    329410    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
    330         stars[i].measure.M      = NAN;
    331     } else {
    332         stars[i].measure.M      = ps1data[i].M + ZeroPt;
     411      stars[i].measure.M      = NAN;
     412      stars[i].measure.FluxPSF  = NAN;
     413      stars[i].measure.dFluxPSF = NAN;
     414    } else {
     415      stars[i].measure.M        = ps1data[i].M + ZeroPt;
     416      stars[i].measure.FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
     417      stars[i].measure.dFluxPSF = stars[i].measure.FluxPSF * ps1data[i].dM;
    333418    }
    334419    stars[i].measure.dM         = ps1data[i].dM;
    335420    stars[i].measure.dMcal      = ps1data[i].dMcal;
    336421    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
    337                        
     422                       
     423    stars[i].measure.Mkron      = NAN; // not provided by PS1_V1_Alt:
     424    stars[i].measure.dMkron     = NAN; // not provided by PS1_V1_Alt:
     425    stars[i].measure.FluxKron   = NAN; // not provided by PS1_V1_Alt:
     426    stars[i].measure.dFluxKron  = NAN; // not provided by PS1_V1_Alt:
     427
    338428    stars[i].measure.Sky        = ps1data[i].sky;
    339429    stars[i].measure.dSky       = ps1data[i].dSky;
    340                        
     430                       
    341431    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
    342432    stars[i].measure.psfQual    = ps1data[i].psfQual;
    … …  
    353443    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
    354444    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
    355                        
     445                       
    356446    stars[i].measure.photFlags  = ps1data[i].flags;
    357447
    … …  
    396486
    397487    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
    398         stars[i].measure.M      = NAN;
    399     } else {
    400         stars[i].measure.M      = ps1data[i].M + ZeroPt;
     488      stars[i].measure.M        = NAN;
     489      stars[i].measure.FluxPSF  = NAN;
     490      stars[i].measure.dFluxPSF = NAN;
     491    } else {
     492      stars[i].measure.M      = ps1data[i].M + ZeroPt;
     493      stars[i].measure.FluxPSF  = pow(10.0, -0.4*ps1data[i].M);
     494      stars[i].measure.dFluxPSF = stars[i].measure.FluxPSF * ps1data[i].dM;
    401495    }
    402496    stars[i].measure.dM         = ps1data[i].dM;
    403497    stars[i].measure.dMcal      = ps1data[i].dMcal;
    404498    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
    405                        
     499                       
     500    stars[i].measure.Mkron      = NAN; // not provided by PS1_V2:
     501    stars[i].measure.dMkron     = NAN; // not provided by PS1_V2:
     502    stars[i].measure.FluxKron   = NAN; // not provided by PS1_V2:
     503    stars[i].measure.dFluxKron  = NAN; // not provided by PS1_V2:
     504
    406505    stars[i].measure.Sky        = ps1data[i].sky;
    407506    stars[i].measure.dSky       = ps1data[i].dSky;
    408                        
     507                       
    409508    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
    410509    stars[i].measure.psfQual    = ps1data[i].psfQual;
    … …  
    421520    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
    422521    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
    423                        
     522                       
    424523    stars[i].measure.photFlags  = ps1data[i].flags;
    425524
    … …  
    464563
    465564    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
    466         stars[i].measure.M      = NAN;
    467     } else {
    468         stars[i].measure.M      = ps1data[i].M + ZeroPt;
     565      stars[i].measure.M      = NAN;
     566    } else {
     567      stars[i].measure.M      = ps1data[i].M + ZeroPt;
    469568    }
    470569    stars[i].measure.dM         = ps1data[i].dM;
    471570    stars[i].measure.dMcal      = ps1data[i].dMcal;
    472571    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
    473                        
     572                       
     573    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
     574    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
     575                       
     576    // these fluxes are converted from counts to counts/sec in FilterStars.c
     577    stars[i].measure.FluxPSF    = ps1data[i].Flux;
     578    stars[i].measure.dFluxPSF   = ps1data[i].dFlux;
     579    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
     580    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
     581
    474582    stars[i].measure.Sky        = ps1data[i].sky;
    475583    stars[i].measure.dSky       = ps1data[i].dSky;
    476                        
     584                       
    477585    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
    478586    stars[i].measure.psfQual    = ps1data[i].psfQual;
    … …  
    489597    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
    490598    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
    491                        
     599                       
    492600    stars[i].measure.photFlags  = ps1data[i].flags;
    493601
    … …  
    496604
    497605    // the Average fields and the following Measure fields are set in FilterStars after
    498     // the image metadata is in hand:  dR, dD, Mcal, dt, airmass, az, t, imageID, extID,
    499     // averef is set in find_matches, dbFlags is zero on ingest.
     606    // the image metadata is in hand:  dR, dD, Mcal, dt, airmass, az, t, imageID, extID.
     607
     608    // averef is set in find_matches
     609
     610    // dbFlags is zero on ingest.
    500611
    501612    // the following fields are currently not being set anywhere: t_msec
    … …  
    514625
    515626  if (table[0].header[0].Naxis[0] == 196) {
    516       stars = Convert_PS1_SV1_Alt (table, nstars);
    517       return (stars);
     627    stars = Convert_PS1_SV1_Alt (table, nstars);
     628    return (stars);
    518629  }
    519630
    … …  
    537648
    538649    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
    539         stars[i].measure.M      = NAN;
    540     } else {
    541         stars[i].measure.M      = ps1data[i].M + ZeroPt;
     650      stars[i].measure.M      = NAN;
     651    } else {
     652      stars[i].measure.M      = ps1data[i].M + ZeroPt;
    542653    }
    543654    stars[i].measure.dM         = ps1data[i].dM;
    544655    stars[i].measure.dMcal      = ps1data[i].dMcal;
    545656    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
    546                        
     657                       
     658    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
     659    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
     660
     661    // these fluxes are converted from counts to counts/sec in FilterStars.c
     662    stars[i].measure.FluxPSF    = ps1data[i].Flux;
     663    stars[i].measure.dFluxPSF   = ps1data[i].dFlux;
     664    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
     665    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
     666
    547667    stars[i].measure.Sky        = ps1data[i].sky;
    548668    stars[i].measure.dSky       = ps1data[i].dSky;
    549                        
     669                       
    550670    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
    551671    stars[i].measure.psfQual    = ps1data[i].psfQual;
    … …  
    562682    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
    563683    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
    564                        
     684                       
    565685    stars[i].measure.photFlags  = ps1data[i].flags;
    566686
    … …  
    607727
    608728    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
    609         stars[i].measure.M      = NAN;
    610     } else {
    611         stars[i].measure.M      = ps1data[i].M + ZeroPt;
     729      stars[i].measure.M      = NAN;
     730    } else {
     731      stars[i].measure.M      = ps1data[i].M + ZeroPt;
    612732    }
    613733    stars[i].measure.dM         = ps1data[i].dM;
    614734    stars[i].measure.dMcal      = ps1data[i].dMcal;
    615735    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
    616                        
     736                       
     737    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
     738    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
     739
     740    // these fluxes are converted from counts to counts/sec in FilterStars.c
     741    stars[i].measure.FluxPSF    = ps1data[i].Flux;
     742    stars[i].measure.dFluxPSF   = ps1data[i].dFlux;
     743    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
     744    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
     745
    617746    stars[i].measure.Sky        = ps1data[i].sky;
    618747    stars[i].measure.dSky       = ps1data[i].dSky;
    619                        
     748                       
    620749    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
    621750    stars[i].measure.psfQual    = ps1data[i].psfQual;
    … …  
    632761    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
    633762    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
    634                        
     763                       
    635764    stars[i].measure.photFlags  = ps1data[i].flags;
    636765

  • trunk/Ohana/src/addstar/src/StarOps.c

    r30613 r34260  
    33int InitStar (Stars *star) {
    44
    5     memset (&star[0].average, 0, sizeof(Average));
    6     memset (&star[0].measure, 0, sizeof(Measure));
     5
     6    dvo_measure_init (&star[0].measure);
     7    dvo_average_init (&star[0].average);
    78    star[0].found = -1; // found == -1 -> not yet found (use enums?)
    89

  • trunk/Ohana/src/addstar/src/args_skycells.c

    r31239 r34260  
    3737    if (!strcasecmp (argv[N], "rings")) {
    3838      MODE = RINGS;
     39    }
     40    if (!strcasecmp (argv[N], "tamas")) {
     41      MODE = TAMAS;
    3942    }
    4043    remove_argument (N, &argc, argv);
    … …  
    179182    } 
    180183    remove_argument (N, &argc, argv);
     184  }
     185  if (MODE == TAMAS) {
     186    CELLSIZE = 3.955;
     187    if ((N = get_argument (argc, argv, "-cellsize"))) {
     188      remove_argument (N, &argc, argv);
     189      CELLSIZE = strtod (argv[N], &ptr);
     190      if ((*ptr != 0) || (CELLSIZE < 0.0)) {
     191        fprintf (stderr, "-cellsize requires a floating-point argument\n");
     192        help ();
     193      } 
     194      remove_argument (N, &argc, argv);
     195    }
    181196  }
    182197

  • trunk/Ohana/src/addstar/src/find_matches.c

    r33963 r34260  
    250250    if (!IN_REGION (stars[i].average.R, stars[i].average.D)) continue;
    251251
     252    dvo_average_init (&catalog[0].average[Nave]);
    252253    catalog[0].average[Nave].R             = stars[i].average.R;
    253254    catalog[0].average[Nave].D             = stars[i].average.D;
    254     catalog[0].average[Nave].dR            = 0;
    255     catalog[0].average[Nave].dD            = 0;
    256255
    257256    catalog[0].average[Nave].Nmeasure      = NSTAR_GROUP;
    258     catalog[0].average[Nave].Nmissing      = 0;
    259     catalog[0].average[Nave].Nextend       = 0;
    260 
    261257    catalog[0].average[Nave].measureOffset = Nmeas;
    262     catalog[0].average[Nave].missingOffset = -1;
    263     catalog[0].average[Nave].extendOffset  = -1;
    264 
    265     catalog[0].average[Nave].uR            = 0;
    266     catalog[0].average[Nave].uD            = 0;
    267     catalog[0].average[Nave].duR           = 0;
    268     catalog[0].average[Nave].duD           = 0;
    269     catalog[0].average[Nave].P             = 0;
    270     catalog[0].average[Nave].dP            = 0;
    271 
    272     catalog[0].average[Nave].Xp            = 0;
    273     catalog[0].average[Nave].ChiSqAve      = 0.0;
    274     catalog[0].average[Nave].ChiSqPM       = 0.0;
    275     catalog[0].average[Nave].ChiSqPar      = 0.0;
    276     catalog[0].average[Nave].Tmean         = 0;
    277     catalog[0].average[Nave].Trange        = 0;
    278     catalog[0].average[Nave].Npos          = 0;
    279 
    280258    catalog[0].average[Nave].objID         = objID;
    281259    catalog[0].average[Nave].catID         = catID;
    282     catalog[0].average[Nave].flags         = 0;
     260
    283261    if (PSPS_ID) {
    284         catalog[0].average[Nave].extID = CreatePSPSObjectID(catalog[0].average[Nave].R,
    285                                                             catalog[0].average[Nave].D);
    286     } else {
    287         catalog[0].average[Nave].extID         = 0;
     262        catalog[0].average[Nave].extID = CreatePSPSObjectID(catalog[0].average[Nave].R, catalog[0].average[Nave].D);
    288263    }
    289264
    … …  
    291266
    292267    for (j = 0; j < Nsecfilt; j++) {
    293       catalog[0].secfilt[Nave*Nsecfilt+j].M           = NAN;
    294       catalog[0].secfilt[Nave*Nsecfilt+j].Map         = NAN;
    295       catalog[0].secfilt[Nave*Nsecfilt+j].dM          = NAN;
    296       catalog[0].secfilt[Nave*Nsecfilt+j].Mstdev      = NAN_S_SHORT;
    297       catalog[0].secfilt[Nave*Nsecfilt+j].Xm          = NAN_S_SHORT;
    298       catalog[0].secfilt[Nave*Nsecfilt+j].M_20        = NAN_S_SHORT;
    299       catalog[0].secfilt[Nave*Nsecfilt+j].M_80        = NAN_S_SHORT;
    300       catalog[0].secfilt[Nave*Nsecfilt+j].Ncode       = 0;
    301       catalog[0].secfilt[Nave*Nsecfilt+j].Nused       = 0;
    302       catalog[0].secfilt[Nave*Nsecfilt+j].ubercalDist = 1000;
    303       catalog[0].secfilt[Nave*Nsecfilt+j].flags       = 0;
     268      dvo_secfilt_init (&catalog[0].secfilt[Nave*Nsecfilt+j]);
    304269    }
    305270

  • trunk/Ohana/src/addstar/src/find_matches_closest.c

    r33963 r34260  
    252252    if (!IN_REGION (stars[i].average.R, stars[i].average.D)) continue;
    253253
     254    dvo_average_init (&catalog[0].average[Nave]);
    254255    catalog[0].average[Nave].R             = stars[i].average.R;
    255256    catalog[0].average[Nave].D             = stars[i].average.D;
    256     catalog[0].average[Nave].dR            = 0;
    257     catalog[0].average[Nave].dD            = 0;
    258257
    259258    catalog[0].average[Nave].Nmeasure      = NSTAR_GROUP;
    260     catalog[0].average[Nave].Nmissing      = 0;
    261     catalog[0].average[Nave].Nextend       = 0;
    262 
    263259    catalog[0].average[Nave].measureOffset = Nmeas;
    264     catalog[0].average[Nave].missingOffset = -1;
    265     catalog[0].average[Nave].extendOffset  = -1;
    266 
    267     catalog[0].average[Nave].uR            = 0;
    268     catalog[0].average[Nave].uD            = 0;
    269     catalog[0].average[Nave].duR           = 0;
    270     catalog[0].average[Nave].duD           = 0;
    271     catalog[0].average[Nave].P             = 0;
    272     catalog[0].average[Nave].dP            = 0;
    273 
    274     catalog[0].average[Nave].Xp            = 0;
    275     catalog[0].average[Nave].ChiSqAve      = 0.0;
    276     catalog[0].average[Nave].ChiSqPM       = 0.0;
    277     catalog[0].average[Nave].ChiSqPar      = 0.0;
    278     catalog[0].average[Nave].Tmean         = 0;
    279     catalog[0].average[Nave].Trange        = 0;
    280     catalog[0].average[Nave].Npos          = 0;
    281 
    282260    catalog[0].average[Nave].objID         = objID;
    283261    catalog[0].average[Nave].catID         = catID;
    284     catalog[0].average[Nave].flags         = 0;
     262
    285263    if (PSPS_ID) {
    286264        catalog[0].average[Nave].extID = CreatePSPSObjectID(catalog[0].average[Nave].R, catalog[0].average[Nave].D);
    287     } else {
    288         catalog[0].average[Nave].extID = 0;
    289265    }
    290266
    … …  
    292268
    293269    for (j = 0; j < Nsecfilt; j++) {
    294       catalog[0].secfilt[Nave*Nsecfilt+j].M           = NAN;
    295       catalog[0].secfilt[Nave*Nsecfilt+j].Map         = NAN;
    296       catalog[0].secfilt[Nave*Nsecfilt+j].dM          = NAN;
    297       catalog[0].secfilt[Nave*Nsecfilt+j].Mstdev      = NAN_S_SHORT;
    298       catalog[0].secfilt[Nave*Nsecfilt+j].Xm          = NAN_S_SHORT;
    299       catalog[0].secfilt[Nave*Nsecfilt+j].M_20        = NAN_S_SHORT;
    300       catalog[0].secfilt[Nave*Nsecfilt+j].M_80        = NAN_S_SHORT;
    301       catalog[0].secfilt[Nave*Nsecfilt+j].Ncode       = 0;
    302       catalog[0].secfilt[Nave*Nsecfilt+j].Nused       = 0;
    303       catalog[0].secfilt[Nave*Nsecfilt+j].ubercalDist = 1000;
    304       catalog[0].secfilt[Nave*Nsecfilt+j].flags       = 0;
     270      dvo_secfilt_init (&catalog[0].secfilt[Nave*Nsecfilt+j]);
    305271    }
    306272

  • trunk/Ohana/src/addstar/src/find_matches_closest_refstars.c

    r28241 r34260  
    255255    if (!IN_REGION (stars[N][0].average.R, stars[N][0].average.D)) continue;
    256256
     257    dvo_average_init (&catalog[0].average[Nave]);
    257258    catalog[0].average[Nave].R             = stars[N][0].average.R;
    258259    catalog[0].average[Nave].D             = stars[N][0].average.D;
    259260
    260261    catalog[0].average[Nave].Nmeasure      = NREFSTAR_GROUP;
    261     catalog[0].average[Nave].Nmissing      = 0;
    262     catalog[0].average[Nave].Nextend       = 0;
    263 
    264262    catalog[0].average[Nave].measureOffset = Nmeas;
    265     catalog[0].average[Nave].missingOffset = -1;
    266     catalog[0].average[Nave].extendOffset  = -1;
     263    catalog[0].average[Nave].objID         = objID;
     264    catalog[0].average[Nave].catID         = catID;
     265
     266    if (PSPS_ID) {
     267        catalog[0].average[Nave].extID = CreatePSPSObjectID(catalog[0].average[Nave].R, catalog[0].average[Nave].D);
     268    }
    267269
    268270    if (ACCEPT_MOTION) {
    … …  
    275277      catalog[0].average[Nave].P           = stars[N][0].average.P;
    276278      catalog[0].average[Nave].dP          = stars[N][0].average.dP;
    277     } else {
    278       catalog[0].average[Nave].dR          = 0;
    279       catalog[0].average[Nave].dD          = 0;
    280       catalog[0].average[Nave].uR          = 0;
    281       catalog[0].average[Nave].uD          = 0;
    282       catalog[0].average[Nave].duR         = 0;
    283       catalog[0].average[Nave].duD         = 0;
    284       catalog[0].average[Nave].P           = 0;
    285       catalog[0].average[Nave].dP          = 0;
    286       catalog[0].average[Nave].Xp          = 0;
    287     }
    288 
    289     catalog[0].average[Nave].Xp            = 0;
    290     catalog[0].average[Nave].ChiSqAve      = 0.0;
    291     catalog[0].average[Nave].ChiSqPM       = 0.0;
    292     catalog[0].average[Nave].ChiSqPar      = 0.0;
    293     catalog[0].average[Nave].Tmean         = 0;
    294     catalog[0].average[Nave].Trange        = 0;
    295     catalog[0].average[Nave].Npos          = 0;
    296 
    297     catalog[0].average[Nave].objID         = objID;
    298     catalog[0].average[Nave].catID         = catID;
    299     catalog[0].average[Nave].flags         = 0;
    300     if (PSPS_ID) {
    301         catalog[0].average[Nave].extID = CreatePSPSObjectID(catalog[0].average[Nave].R,
    302                                                             catalog[0].average[Nave].D);
    303     } else {
    304         catalog[0].average[Nave].extID         = 0;
    305279    }
    306280
    … …  
    308282
    309283    for (j = 0; j < Nsecfilt; j++) {
    310       catalog[0].secfilt[Nave*Nsecfilt+j].M     = NAN;
    311       catalog[0].secfilt[Nave*Nsecfilt+j].dM    = NAN;
    312       catalog[0].secfilt[Nave*Nsecfilt+j].Xm    = NAN_S_SHORT;
    313       catalog[0].secfilt[Nave*Nsecfilt+j].M_20  = NAN_S_SHORT;
    314       catalog[0].secfilt[Nave*Nsecfilt+j].M_80  = NAN_S_SHORT;
    315       catalog[0].secfilt[Nave*Nsecfilt+j].Ncode = 0;
    316       catalog[0].secfilt[Nave*Nsecfilt+j].Nused = 0;
     284      dvo_secfilt_init (&catalog[0].secfilt[Nave*Nsecfilt+j]);
    317285    }
    318286

  • trunk/Ohana/src/addstar/src/find_matches_refstars.c

    r33653 r34260  
    227227    if (!IN_REGION (stars[N][0].average.R, stars[N][0].average.D)) continue;
    228228
     229    dvo_average_init (&catalog[0].average[Nave]);
    229230    catalog[0].average[Nave].R             = stars[N][0].average.R;
    230231    catalog[0].average[Nave].D             = stars[N][0].average.D;
    231232
    232233    catalog[0].average[Nave].Nmeasure      = NREFSTAR_GROUP;
    233     catalog[0].average[Nave].Nmissing      = 0;
    234     catalog[0].average[Nave].Nextend       = 0;
    235 
    236234    catalog[0].average[Nave].measureOffset = Nmeas;
    237     catalog[0].average[Nave].missingOffset = -1;
    238     catalog[0].average[Nave].extendOffset  = -1;
     235    catalog[0].average[Nave].objID         = objID;
     236    catalog[0].average[Nave].catID         = catID;
     237
     238    if (PSPS_ID) {
     239        catalog[0].average[Nave].extID = CreatePSPSObjectID(catalog[0].average[Nave].R, catalog[0].average[Nave].D);
     240    }
    239241
    240242    if (ACCEPT_MOTION) {
    … …  
    247249      catalog[0].average[Nave].P           = stars[N][0].average.P;
    248250      catalog[0].average[Nave].dP          = stars[N][0].average.dP;
    249     } else {
    250       catalog[0].average[Nave].dR          = 0;
    251       catalog[0].average[Nave].dD          = 0;
    252       catalog[0].average[Nave].uR          = 0;
    253       catalog[0].average[Nave].uD          = 0;
    254       catalog[0].average[Nave].duR         = 0;
    255       catalog[0].average[Nave].duD         = 0;
    256       catalog[0].average[Nave].P           = 0;
    257       catalog[0].average[Nave].dP          = 0;
    258       catalog[0].average[Nave].Xp          = 0;
    259     }
    260 
    261     catalog[0].average[Nave].Xp            = 0;
    262     catalog[0].average[Nave].ChiSqAve      = 0.0;
    263     catalog[0].average[Nave].ChiSqPM       = 0.0;
    264     catalog[0].average[Nave].ChiSqPar      = 0.0;
    265     catalog[0].average[Nave].Tmean         = 0;
    266     catalog[0].average[Nave].Trange        = 0;
    267     catalog[0].average[Nave].Npos          = 0;
    268 
    269     catalog[0].average[Nave].objID         = objID;
    270     catalog[0].average[Nave].catID         = catID;
    271     catalog[0].average[Nave].flags         = 0;
    272     if (PSPS_ID) {
    273         catalog[0].average[Nave].extID = CreatePSPSObjectID(catalog[0].average[Nave].R,
    274                                                             catalog[0].average[Nave].D);
    275     } else {
    276         catalog[0].average[Nave].extID         = 0;
    277     }
    278 
     251    }
    279252
    280253    objID ++;
    281254
    282255    for (j = 0; j < Nsecfilt; j++) {
    283       catalog[0].secfilt[Nave*Nsecfilt+j].M     = NAN;
    284       catalog[0].secfilt[Nave*Nsecfilt+j].dM    = NAN;
    285       catalog[0].secfilt[Nave*Nsecfilt+j].Xm    = NAN_S_SHORT;
    286       catalog[0].secfilt[Nave*Nsecfilt+j].M_20  = NAN_S_SHORT;
    287       catalog[0].secfilt[Nave*Nsecfilt+j].M_80  = NAN_S_SHORT;
    288       catalog[0].secfilt[Nave*Nsecfilt+j].Ncode = 0;
    289       catalog[0].secfilt[Nave*Nsecfilt+j].Nused = 0;
     256      dvo_secfilt_init (&catalog[0].secfilt[Nave*Nsecfilt+j]);
    290257    }
    291258

  • trunk/Ohana/src/addstar/src/mkcmf.c

    r33653 r34260  
    1414void gauss_init (int Nbin);
    1515double rnd_gauss (double mean, double sigma);
     16void writeStars_PS1_V3 (FTable *ftable, double *X, double *Y, double *M, unsigned int *Flag, int Nstars);
    1617void writeStars_PS1_V2 (FTable *ftable, double *X, double *Y, double *M, unsigned int *Flag, int Nstars);
    1718void writeStars_PS1_V1 (FTable *ftable, double *X, double *Y, double *M, int Nstars);
    … …  
    276277  if (!strcmp(type, "PS1_V2")) {
    277278    writeStars_PS1_V2 (&ftable, X, Y, M, Flag, Nstars);
     279    found = TRUE;
     280  }
     281  if (!strcmp(type, "PS1_V3")) {
     282    writeStars_PS1_V3 (&ftable, X, Y, M, Flag, Nstars);
    278283    found = TRUE;
    279284  }
    … …  
    572577}
    573578
     579void writeStars_PS1_V3 (FTable *ftable, double *X, double *Y, double *M, unsigned int *Flag, int Nstars) {
     580
     581  int i;
     582  CMF_PS1_V3 *stars;
     583  float flux, fSN;
     584
     585  // XXX add gaussian-distributed noise based on counts
     586  // this needs to make different output 'stars' entries depending on the desired type
     587  ALLOCATE (stars, CMF_PS1_V3, Nstars);
     588  gauss_init (2048);
     589  for (i = 0; i < Nstars; i++) {
     590    stars[i].detID = i;
     591
     592    flux = pow (10.0, -0.4*M[i]);
     593    fSN = 1.0 / sqrt(flux);
     594
     595    stars[i].X = X[i];
     596    stars[i].Y = Y[i];
     597    stars[i].M = M[i];
     598    stars[i].Map = M[i] - 0.05;
     599
     600    if (ADDNOISE) {
     601      stars[i].X += FX * fSN * rnd_gauss(0.0, 1.0);
     602      stars[i].Y += FY * fSN * rnd_gauss(0.0, 1.0);
     603      stars[i].M += fSN*rnd_gauss(0.0, 1.0);
     604    }
     605
     606    // randomly give poor PSFQF values
     607    if ((BAD_PSFQF_FRAC > 0.0) && (drand48() < BAD_PSFQF_FRAC)) {
     608      stars[i].psfQual   = 0.25;
     609    } else {
     610      stars[i].psfQual   = PSFQUAL;
     611    }
     612   
     613    stars[i].dX = FX * fSN;
     614    stars[i].dY = FY * fSN;
     615    stars[i].dM = fSN;
     616
     617    stars[i].Mpeak     = M[i] + 1.0;
     618    stars[i].sky       = SKY;
     619    stars[i].dSky      = DSKY;
     620    stars[i].psfChisq  = PSFCHI;
     621    stars[i].crNsigma  = CRN;
     622    stars[i].extNsigma = EXTN;
     623    stars[i].fx        = FX;
     624    stars[i].fy        = FY;
     625    stars[i].df        = DF;
     626    stars[i].nFrames   = 1;
     627    stars[i].flags     = Flag[i];
     628
     629    stars[i].kronFlux  = flux * 1.25;
     630    stars[i].kronFluxErr = fSN * flux * 1.25;
     631  }
     632
     633  gfits_table_set_CMF_PS1_V3 (ftable, stars, Nstars);
     634  gfits_modify (ftable->header, "EXTTYPE",   "%s", 1, "PS1_V3");
     635}
     636

  • trunk/Ohana/src/addstar/src/psps_ids.c

    r27527 r34260  
    1919   
    2020uint64_t
     21CreatePSPSStackDetectionID(int sourceID, int imageID, int detID)
     22{
     23  // sourceID : ID of database + table that tracked the image (< 0x100 = 256)
     24  // imageID : external ID of the image which provided the detections (< 0x1000.0000 ~ 2.7e8)
     25  // detID : detection sequence in image (< 0x1000.0000 ~ 2.7e8)
     26
     27  assert (detID    < 0x10000000);
     28  assert (imageID  < 0x10000000);
     29  assert (sourceID < 0x100);
     30 
     31  uint64_t detectid = ((uint64_t)sourceID << 56) + ((uint64_t)imageID << 28) + (uint64_t)detID;
     32  return detectid;
     33}
     34   
     35uint64_t
    2136CreatePSPSObjectID(double ra, double dec)
    2237{

  • trunk/Ohana/src/addstar/src/sky_tessalation.c

    r34088 r34260  
    2323      sky_tessellation_rings (db, level, Nmax);
    2424      return TRUE;
     25    case TAMAS:
     26      sky_tessellation_tamas (db, level, Nmax);
     27      return TRUE;
    2528    default:
    2629      break;
    … …  
    284287    free (ring);
    285288    free (image);
     289  }   
     290  return (TRUE);
     291}
     292
     293// the RINGS tessellation uses the declination zones proposed by Tamas Budavari,
     294// based on code supplied by Tamas 2012.07.23
     295int sky_tessellation_tamas (FITS_DB *db, int level, int Nmax) {
     296
     297  int j, nDEC, Nimage, Nring, Ntotal, Ndigit;
     298  double dec, dDEC;
     299  SkyRectangle *ring;
     300  Image *image;
     301  char format[16];
     302
     303  // The tessellation has one input parameter: the approximate cell size.  Starting with
     304  // the cell size, determine the optimal projection cell height (dDEC) that results in an
     305  // integer number of dec zones between -90 and +90
     306
     307  // in fact, we place a single image on each pole, so the real range of dec is 180.0 - CELLSIZE:
     308
     309  nDEC = (180.0 - CELLSIZE) / CELLSIZE;
     310  dDEC = (180.0 - CELLSIZE) / nDEC;
     311  nDEC += 2;
     312
     313  // how many total projection cells for this realization?  divide sky area by cell area:
     314  // this is used to set the number of digits, so it does not need to be very accurate...
     315  Ntotal = 41254.2 / (dDEC*dDEC);
     316  Ndigit = (int)(log10(Ntotal)) + 1 ;
     317  snprintf (format, 16, "skycell.%%0%dd", Ndigit);
     318
     319  double d2r = M_PI / 180; // is RAD_DEG
     320
     321  // parameter 'a' is the cell size in degrees
     322  double adeg = 3.955;
     323
     324  // half of 'a' in radians and its atan
     325  double halfa = adeg / 2 * d2r;
     326  double halftheta = atan(halfa);
     327
     328  // loop init
     329  dec = 0; // starting Decl. - could change this...
     330 
     331  while (dec < M_PI / 2 - halftheta) {
     332        double dm = dec - halftheta; // eq.5
     333        if (dec == 0) dm = 0; // initial
     334
     335        // dec is modified by the call below
     336        ring = sky_rectangle_tamas (&dec, dm, halfa, halftheta, &Nring, format);
     337        if (!ring) continue;
     338
     339        // subdivide each image (Nx x Ny subcells)
     340        Nimage = NX_SUB*NY_SUB*Nring;
     341        ALLOCATE (image, Image, Nimage);
     342        for (j = 0; j < Nring; j++) {
     343          // convert the SkyRectangles to Images for output
     344          sky_subdivide_image (&image[j*NX_SUB*NY_SUB], &ring[j], NX_SUB, NY_SUB);
     345          // printf("%s %8.2f %8.2f\n", ring[j].name, ring[j].coords.crval1, ring[j].coords.crval2);
     346        }
     347
     348        /* add the new images and save */
     349        dvo_image_addrows (db, image, Nimage);
     350        SetProtect (TRUE);
     351        dvo_image_update (db, VERBOSE);
     352        SetProtect (FALSE);
     353        dvo_image_clear_vtable (db);
     354   
     355        free (ring);
     356        free (image);
    286357  }   
    287358  return (TRUE);
    … …  
    666737}
    667738
     739// define the parameters of a projection centers for this ring
     740// dec : ~ center of ring in Dec
     741// dDEC : approximate height
     742// nring : number of cells generated for this ring
     743// format : guide to generate the filenames (c-type string format)
     744SkyRectangle *sky_rectangle_tamas (double *Dec, double dm, double halfa, double halftheta, int *nring, char *format) {
     745
     746  static int Nname = 0;
     747  int i, j, NX, NY;
     748  SkyRectangle *ring;
     749
     750  double d2r = M_PI / 180; // is RAD_DEG
     751  double dec = *Dec;
     752
     753  int nRA = (int)ceil(M_PI * cos(dm) / halftheta);  // eq.6       
     754  double dRA = 2 * M_PI / nRA; // eq.7
     755  double dp = atan(tan(dec + halftheta) * cos(dRA / 2)); // eq.9
     756
     757  if (dec == 0.0) {
     758    ALLOCATE (ring, SkyRectangle, nRA);
     759  } else {
     760    ALLOCATE (ring, SkyRectangle, 2*nRA);
     761  }
     762
     763  for (i = 0; i < nRA; i++) {
     764    // R.A. can use different phase per ring
     765    double ra = i * dRA; // + phase (watch wraparound)
     766
     767    int npass = (dec == 0.0) ? 1 : 2;
     768    for (j = 0; j < npass; j++) {
     769
     770      int N = j*nRA + i;
     771
     772      memset (&ring[N], 0, sizeof(SkyRectangle));
     773      memset (&ring[N].coords, 0, sizeof(Coords));
     774
     775      ring[N].coords.crval1 = ra / d2r;
     776      ring[N].coords.crval2 = (j == 0) ? dec / d2r : -dec / d2r;
     777
     778      printf(" \t %d   %25.20f   %25.20f\n", i, ring[N].coords.crval2, ring[N].coords.crval1);
     779
     780      ring[N].coords.pc1_1 = +1.0 * X_PARITY;
     781      ring[N].coords.pc1_2 = +0.0;
     782      ring[N].coords.pc2_1 = -0.0;
     783      ring[N].coords.pc2_2 = +1.0;
     784 
     785      // range values are in projected degrees
     786      NX = cos(dec - halftheta) * dRA   * 3600.0 / SCALE / d2r;
     787      NY =    2 * halftheta * 3600.0 / SCALE / d2r;
     788
     789      // crpix1,crpix2 is the projection center
     790      ring[N].coords.crpix1 = 0.5*NX;
     791      ring[N].coords.crpix2 = 0.5*NY;
     792
     793      ring[N].coords.cdelt1 = SCALE / 3600.0;
     794      ring[N].coords.cdelt2 = SCALE / 3600.0;
     795
     796      strcpy (ring[N].coords.ctype, "DEC--TAN");
     797
     798      ring[N].NX = NX*(1.0 + PADDING);
     799      ring[N].NY = NY*(1.0 + PADDING);
     800      ring[N].photcode = 1; // this needs to be set more sensibly
     801
     802      snprintf (ring[N].name, DVO_IMAGE_NAME_LEN, format, Nname);
     803      Nname++;
     804    }
     805  }
     806
     807  // advance to next ring
     808  *Dec = halftheta + dp;
     809
     810  *nring = (dec == 0.0) ? nRA : 2*nRA;
     811  return ring;
     812}
     813
    668814// an allocated image set is supplied, we fill in the values
    669815int sky_subdivide_image (Image *output, SkyRectangle *input, int Nx, int Ny) {
    … …  
    682828  }
    683829
    684   Ndigit = (int)(log10(Nx*Ny)) + 1 ;
    685   snprintf (format, 24, "%s.%%0%dd", input[0].name, Ndigit);
     830  if (Nx * Ny > 1) {
     831    Ndigit = (int)(log10(Nx*Ny)) + 1 ;
     832    snprintf (format, 24, "%s.%%0%dd", input[0].name, Ndigit);
     833  } else {
     834    snprintf (format, 24, "%s", input[0].name);
     835  }
    686836
    687837  // if requested extend, the skycell boundaries so that skycells overlap
    … …  
    696846      memcpy (&output[N].coords, &input[0].coords, sizeof(Coords));
    697847
    698       snprintf (output[N].name, DVO_IMAGE_NAME_LEN, format, N);
     848      if (Nx + Ny > 1) {
     849        snprintf (output[N].name, DVO_IMAGE_NAME_LEN, format, N);
     850      } else {
     851        snprintf (output[N].name, DVO_IMAGE_NAME_LEN, "%s", format);
     852      }
     853
    699854      output[N].NX = NX + 2 * pad_x;
    700855      output[N].NY = NY + 2 * pad_y;

  • trunk/Ohana/src/addstar/test/simple.dvo

    r33653 r34260  
    2121  test.fields PS1_V2    PS1_V3
    2222  test.fields PS1_V3    PS1_V3
     23
     24  test.fields PS1_DEV_0 PS1_V4
     25  test.fields PS1_DEV_1 PS1_V4
     26  test.fields PS1_V1    PS1_V4
     27  test.fields PS1_V2    PS1_V4
     28  test.fields PS1_V3    PS1_V4
    2329end 
    2430
    … …  
    8389    sort id1 v1
    8490    sort id2 v2
     91
     92    # some fields require arithmetic manipulations
     93    if ("$name:0" == "KRON_FLUX")
     94     set v1 = -2.5*log(v1)
     95    end
     96    if ("$name:0" == "KRON_FLUX_ERR")
     97     set v1 = KRON_FLUX_ERR / KRON_FLUX
     98    end
     99
    85100    set d = v1 - v2
    86101    vstat -q d
    … …  
    88103    #echo tapOK fabs($MEAN)  < 0.001 "$name:0 vs $name:2 (MEAN)"
    89104    #echo tapOK fabs($SIGMA) < 0.001 "$name:0 vs $name:2 (SIGMA)"
     105
     106    # THETA is stored to only (360/65536) deg accuracy
     107    if ("$name:0" == "PSF_THETA")
     108      echo $MEAN
     109      tapOK {abs($MEAN)  < 0.006} "$name:0 vs $name:2 (MEAN)"
     110      tapOK {abs($SIGMA) < 0.001} "$name:0 vs $name:2 (SIGMA)"
     111      continue
     112    end
    90113
    91114    tapOK {abs($MEAN)  < 0.001} "$name:0 vs $name:2 (MEAN)"
    … …  
    111134  output stdout
    112135end
     136
     137# the following lists define fields in the cmf files which can be compared to their equivalents in DVO
     138# the left column is the cmf field name, the right column is the dvo field name
    113139
    114140# list of cmf fields to test matched to mextract fields
    … …  
    122148  PSF_INST_MAG      : mag:inst
    123149  PSF_INST_MAG_SIG  : mag:err
    124   PEAK_FLUX_AS_MAG  : SKIP
     150  PEAK_FLUX_AS_MAG  : SKIP # not ingested into DVO
    125151  SKY               : sky
    126152  SKY_SIG           : sky_err
    … …  
    130156  PSF_THETA         : THETA
    131157  PSF_QF            : PSF_QF
    132   N_FRAMES          : SKIP
     158  N_FRAMES          : SKIP # not ingested into DVO
    133159end
    134160
    … …  
    143169  PSF_INST_MAG      : mag:inst
    144170  PSF_INST_MAG_SIG  : mag:err
    145   PEAK_FLUX_AS_MAG  : SKIP
     171  PEAK_FLUX_AS_MAG  : SKIP # not ingested into DVO
    146172  SKY               : sky
    147173  SKY_SIG           : sky_err
    … …  
    153179  PSF_THETA         : THETA
    154180  PSF_QF            : PSF_QF
    155   N_FRAMES          : SKIP
     181  N_FRAMES          : SKIP # not ingested into DVO
    156182  FLAGS             : phot_flags
    157183end
    … …  
    236262  X_PSF_SIG         : xccd:err # FAIL
    237263  Y_PSF_SIG         : yccd:err # FAIL
    238   RA_PSF            : SKIP # astrometry is not calibrated in the cmf
    239   DEC_PSF           : SKIP # astrometry is not calibrated in the cmf
    240264  POSANGLE          : SKIP # astrometry is not calibrated in the cmf
    241265  PLTSCALE          : SKIP # astrometry is not calibrated in the cmf
    242266  PSF_INST_MAG      : mag:inst 
    243267  PSF_INST_MAG_SIG  : mag:err   
    244   AP_MAG_STANDARD   : mag:ap # FAIL
    245   AP_MAG_RADIUS     : SKIP # no accessor
    246   PEAK_FLUX_AS_MAG  : SKIP # no accessor
     268  PSF_INST_FLUX     : SKIP # not ingested into DVO
     269  PSF_INST_FLUX_SIG : SKIP # not ingested into DVO
     270  AP_MAG_STANDARD   : mag:aperinst # FAIL
     271  AP_MAG_RAW        : SKIP # not ingested into DVO
     272  AP_MAG_RADIUS     : SKIP # not ingested into DVO
    247273  CAL_PSF_MAG       : SKIP # photometry is not calibrated in the cmf
    248274  CAL_PSF_MAG_SIG   : SKIP # photometry is not calibrated in the cmf
     275  RA_PSF            : SKIP # astrometry is not calibrated in the cmf
     276  DEC_PSF           : SKIP # astrometry is not calibrated in the cmf
     277  PEAK_FLUX_AS_MAG  : SKIP # not ingested into DVO
    249278  SKY               : sky       
    250279  SKY_SIG           : sky_err   
    … …  
    256285  PSF_THETA         : THETA # FAIL
    257286  PSF_QF            : PSF_QF   
    258   PSF_NDOF          : SKIP # no accessor
    259   PSF_NPIX          : SKIP # no accessor
    260   MOMENTS_XX        : SKIP # no accessor
    261   MOMENTS_XY        : SKIP # no accessor
    262   MOMENTS_YY        : SKIP # no accessor
     287  PSF_QF_PERFECT    : SKIP # not ingested into DVO
     288  PSF_NDOF          : PSF_NDOF
     289  PSF_NPIX          : PSF_NPIX
     290  MOMENTS_XX        : MXX
     291  MOMENTS_XY        : MXY
     292  MOMENTS_YY        : MYY
     293  MOMENTS_M3C       : SKIP # not ingested into DVO
     294  MOMENTS_M3S       : SKIP # not ingested into DVO
     295  MOMENTS_M4C       : SKIP # not ingested into DVO
     296  MOMENTS_M4S       : SKIP # not ingested into DVO
     297  MOMENTS_R1        : SKIP # not ingested into DVO
     298  MOMENTS_RH        : SKIP # not ingested into DVO
     299  KRON_FLUX         : mag:kroninst
     300  KRON_FLUX_ERR     : mag:kronerr
     301  KRON_FLUX_INNER   : SKIP # not ingested into DVO
     302  KRON_FLUX_OUTER   : SKIP # not ingested into DVO
    263303  FLAGS             : phot_flags
    264   N_FRAMES          : SKIP # no accessor       
    265 end
     304  N_FRAMES          : SKIP # not ingested into DVO
     305end

  • trunk/Ohana/src/dvomerge/Makefile

    r33963 r34260  
    2020dvomerge_client : $(BIN)/dvomerge_client.$(ARCH)
    2121dvoconvert      : $(BIN)/dvoconvert.$(ARCH)
     22dvoverify       : $(BIN)/dvoverify.$(ARCH)
     23dvoverify_client : $(BIN)/dvoverify_client.$(ARCH)
    2224
    23 all: dvomerge dvomerge_client dvoconvert dvosecfilt
     25all: dvomerge dvomerge_client dvoconvert dvosecfilt dvoverify dvoverify_client
    2426
    2527#  $(SRC)/dvomergeContinue.$(ARCH).o
    … …  
    4951
    5052$(DVOMERGE)  : $(INC)/dvomerge.h
    51 
    5253$(BIN)/dvomerge.$(ARCH) : $(DVOMERGE)
    5354
    … …  
    7273
    7374$(DVOMERGE_CLIENT) : $(INC)/dvomerge.h
    74 
    7575$(BIN)/dvomerge_client.$(ARCH) : $(DVOMERGE_CLIENT)
    7676
    … …  
    8787
    8888$(DVOCONVERT)  : $(INC)/dvomerge.h
    89 
    9089$(BIN)/dvoconvert.$(ARCH) : $(DVOCONVERT)
    9190
    … …  
    9998
    10099$(DVOSECFILT)  : $(INC)/dvomerge.h
    101 
    102100$(BIN)/dvosecfilt.$(ARCH) : $(DVOSECFILT)
    103101
    … …  
    116114
    117115$(DVOREPAIR)  : $(INC)/dvomerge.h
    118 
    119116$(BIN)/dvorepair.$(ARCH) : $(DVOREPAIR)
    120117
    121118DVOVERIFY = \
    122 $(SRC)/dvoverify.$(ARCH).o
     119$(SRC)/dvoverify.$(ARCH).o \
     120$(SRC)/dvoverify_args.$(ARCH).o \
     121$(SRC)/dvoverify_catalogs.$(ARCH).o \
     122$(SRC)/dvoverify_utils.$(ARCH).o
    123123
    124 $(DVOVERIFY)  : $(INC)/dvomerge.h
    125 
     124$(DVOVERIFY)  : $(INC)/dvoverify.h
    126125$(BIN)/dvoverify.$(ARCH) : $(DVOVERIFY)
    127126
    128 INSTALL = dvomerge dvomerge_client dvoconvert dvosecfilt dvorepair dvoverify
     127DVOVERIFY_CLIENT = \
     128$(SRC)/dvoverify_client.$(ARCH).o \
     129$(SRC)/dvoverify_args.$(ARCH).o \
     130$(SRC)/dvoverify_catalogs.$(ARCH).o \
     131$(SRC)/dvoverify_utils.$(ARCH).o
     132
     133$(DVOVERIFY_CLIENT) : $(INC)/dvoverify.h
     134$(BIN)/dvoverify_client.$(ARCH) : $(DVOVERIFY_CLIENT)
     135
     136INSTALL = dvomerge dvomerge_client dvoconvert dvosecfilt dvorepair dvoverify dvoverify_client
    129137
    130138# dependancy rules for binary code #########################

  • trunk/Ohana/src/dvomerge/include/dvomerge.h

    r33963 r34260  
    1717# include <glob.h>
    1818
    19 # define DVO_MAX_PATH 1024
    20 
    2119int    PARALLEL;
    2220int    PARALLEL_MANUAL;
    … …  
    2523int    HOST_ID;
    2624char  *HOSTDIR;
    27 
    2825
    2926int    VERBOSE;

  • trunk/Ohana/src/dvomerge/src/args.c

    r33963 r34260  
    5050  }
    5151
    52   // XXX for the moment, make this selection manual.  it needs to be automatic
    53   // based on the state of the SkyTable
    5452  PARALLEL = FALSE;
    5553  if ((N = get_argument (*argc, argv, "-parallel"))) {

  • trunk/Ohana/src/dvomerge/src/dvomergeContinue.c

    r33657 r34260  
     1NOTE:
     2/// this is now not used; it has been merged with dvomergeUpdate
     3
    14# include "dvomerge.h"
    25

  • trunk/Ohana/src/dvomerge/src/dvomergeContinue_threaded.c

    r33657 r34260  
     1NOTE:
     2/// this is now not used; it has been merged with dvomergeUpdate
     3
    14# include "dvomerge.h"
    25# include <pthread.h>

  • trunk/Ohana/src/dvomerge/src/dvomergeUpdate_catalogs.c

    r33963 r34260  
    9494      fclose (fout);
    9595
    96       // update header of output catalog
     96      // XXX note that we are hardwired to v 2
     97      // check the header of output catalog for an existing merge
    9798      long long last_size;
    9899      char last_moddate[80];
    99       gfits_scan (&outheader, "LMRG_SZ", "%lld", 1, &last_size);     
    100       gfits_scan (&outheader, "LMRG_DT", "%s", 1, last_moddate);     
     100      gfits_scan (&outheader, "LMRG_SZ2", "%lld", 1, &last_size);     
     101      gfits_scan (&outheader, "LMRG_DT2", "%s", 1, last_moddate);     
    101102
    102103      time_t last_mod = ohana_date_to_sec (last_moddate);
    … …  
    150151      outcatalog.catflags = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF;
    151152
    152       // update header of output catalog
     153# if (0)
     154      // get the LMRG data from the previous pass
    153155      long long last_size;
    154156      char last_moddate[80];
    … …  
    156158      int status_date = gfits_scan (&outcatalog.header, "LMRG_DT", "%s", 1, last_moddate);     
    157159
    158       // save the previous size of merged entry
     160      // save the LMRG data from the previous pass
    159161      if (status_size && status_date) {
    160162        gfits_modify (&outcatalog.header, "LMRG_SZ1", "%lld", 1, (long long) last_size);     
    … …  
    165167      gfits_modify (&outcatalog.header, "LMRG_SZ", "%lld", 1, (long long) instats.st_size);     
    166168      gfits_modify (&outcatalog.header, "LMRG_DT", "%s", 1, moddate);     
     169# endif
     170
     171      // update header of output catalog
     172      // XXX note that we are hardwired to v 2
     173      gfits_modify (&outcatalog.header, "LMRG_SZ2", "%lld", 1, (long long) instats.st_size);     
     174      gfits_modify (&outcatalog.header, "LMRG_DT2", "%s", 1, moddate);     
    167175
    168176      if (!dvo_catalog_backup (&outcatalog, TRUE)) {

  • trunk/Ohana/src/dvomerge/src/dvoverify.c

    r33963 r34260  
    1 # include "dvomerge.h"
     1# include "dvoverify.h"
    22
    33/* things we can verify easily:
    … …  
    88*/
    99
    10 int VerifyTableFile (char *filename);
    11 int CheckCatalogIndexes (char *catdir, char *filename,  SkyRegion *region);
    12 
    13 # define DEBUG 0
    14 
    15 int VERBOSE = FALSE;
    16 int NNotSorted = 0;
    17 
    1810int main (int argc, char **argv) {
    1911
    20   char filename[1024];
     12  SkyTable *sky;
     13  SkyList *skylist;
    2114
    22   int N, Nbad;
    23   off_t i;
    24   SkyTable *insky;
    25   SkyList *inlist;
    26   SkyRegion UserPatch;
    27   // Catalog catalog;
     15  // check various options
     16  dvoverify_args (&argc, argv);
     17  CATDIR = argv[1];
    2818
    29   int CHECKSORTED;
    30 
    31   if ((N = get_argument (argc, argv, "-v"))) {
    32     VERBOSE = TRUE;
    33     remove_argument (N, &argc, argv);
    34   }
    35   if ((N = get_argument (argc, argv, "-verbose"))) {
    36     VERBOSE = TRUE;
    37     remove_argument (N, &argc, argv);
    38   }
    39   if ((N = get_argument (argc, argv, "-s"))) {
    40     CHECKSORTED = TRUE;
    41     remove_argument (N, &argc, argv);
    42   }
    43   if ((N = get_argument (argc, argv, "-sorted"))) {
    44     CHECKSORTED = TRUE;
    45     remove_argument (N, &argc, argv);
    46   }
    47 
    48   if ((N = get_argument (argc, argv, "-cpt"))) {
    49     remove_argument (N, &argc, argv);
    50     char *filename = strcreate (argv[N]);
    51     remove_argument (N, &argc, argv);
    52 
    53     int isBad = FALSE;
    54 
    55     if (!VerifyTableFile (filename)) {
    56       fprintf (stderr, "bad average table %s\n", filename);
    57       isBad = TRUE;
    58     }
    59 
    60     // change last 't' to 's':
    61     int Nlast;
    62     Nlast = strlen(filename) - 1;
    63     filename[Nlast] = 's';
    64     if (!VerifyTableFile (filename)) {
    65       fprintf (stderr, "bad secfilt table %s\n", filename);
    66       isBad = TRUE;
    67     }
    68 
    69     // change last 't' to 's':
    70     Nlast = strlen(filename) - 1;
    71     filename[Nlast] = 'm';
    72     if (!VerifyTableFile (filename)) {
    73       fprintf (stderr, "bad measure table %s\n", filename);
    74       isBad = TRUE;
    75     }
    76 
    77     if (isBad) exit (1);
    78     exit (0);
    79   }
    80 
    81   // restrict to a portion of the sky
    82   UserPatch.Rmin = 0;
    83   UserPatch.Rmax = 360;
    84   UserPatch.Dmin = -90;
    85   UserPatch.Dmax = +90;
    86   if ((N = get_argument (argc, argv, "-region"))) {
    87     remove_argument (N, &argc, argv);
    88     UserPatch.Rmin = atof (argv[N]);
    89     remove_argument (N, &argc, argv);
    90     UserPatch.Rmax = atof (argv[N]);
    91     remove_argument (N, &argc, argv);
    92     UserPatch.Dmin = atof (argv[N]);
    93     remove_argument (N, &argc, argv);
    94     UserPatch.Dmax = atof (argv[N]);
    95     remove_argument (N, &argc, argv);
    96   }
    97 
    98   if (argc != 2) {
    99     fprintf (stderr, "USAGE: dvoverify (catdir) [-region Rmin Rmax Dmin Dmax] [-v] [-s]\n\n");
    100     fprintf (stderr, "  -v : VERBOSE\n");
    101     fprintf (stderr, "  -s : checks if sorted, return error if not\n");
    102     fprintf (stderr, "  (catdir) : database of interest\n");
    103     exit (2);
    104   }
    105 
    106   char *catdir = argv[1];
    107 
    108   Nbad = 0;
     19  int Nbad = 0;
    10920
    11021  // XXX make this step optional
    111   if (1) {
     22  if (CHECK_TOPLEVEL) {
     23    char filename[DVO_MAX_PATH];
     24
    11225    // check the photcode table
    113     sprintf (filename, "%s/Photcodes.dat", catdir);
     26    sprintf (filename, "%s/Photcodes.dat", CATDIR);
    11427    if (!VerifyTableFile (filename)) {
    11528      Nbad ++;
    … …  
    11730
    11831    // check the skytable
    119     char *skyfile = SkyTableFilename (catdir);
     32    char *skyfile = SkyTableFilename (CATDIR);
    12033    if (!VerifyTableFile (skyfile)) {
    12134      Nbad ++;
    … …  
    12336
    12437    // check the image table
    125     sprintf (filename, "%s/Images.dat", catdir);
     38    sprintf (filename, "%s/Images.dat", CATDIR);
    12639    if (!VerifyTableFile (filename)) {
    12740      Nbad ++;
    … …  
    13043
    13144  // load the sky table for the existing database
    132   insky = SkyTableLoadOptimal (catdir, NULL, NULL, FALSE, SKY_DEPTH_HST, VERBOSE);
    133   myAssert(insky, "can't read SkyTable");
    134   SkyTableSetFilenames (insky, catdir, "cpt");
    135   inlist = SkyListByPatch (insky, -1, &UserPatch);
     45  sky = SkyTableLoadOptimal (CATDIR, NULL, NULL, FALSE, SKY_DEPTH_HST, VERBOSE);
     46  myAssert(sky, "can't read SkyTable");
     47  SkyTableSetFilenames (sky, CATDIR, "cpt");
     48  skylist = SkyListByPatch (sky, -1, &UserPatch);
    13649 
    137   // loop over all catalogs, save to output catalogs
    138   for (i = 0; i < inlist[0].Nregions; i++) {
    139     if (!inlist[0].regions[i][0].table) continue;
    140     if (i % 1000 == 0) fprintf (stderr, ".");
     50  dvoverify_catalogs (skylist, &Nbad);
    14151
    142     // sprintf (filename, "%s/%s.cpt", catdir, inlist[0].regions[i][0].name);
    143     if (!VerifyTableFile (inlist[0].filename[i])) {
    144       Nbad ++;
    145     }
     52  int i, Nfailures;
     53  char **failures = GetFailures (&Nfailures);
    14654
    147     sprintf (filename, "%s/%s.cps", catdir, inlist[0].regions[i][0].name);
    148     if (!VerifyTableFile (filename)) {
    149       Nbad ++;
    150     }
    151 
    152     sprintf (filename, "%s/%s.cpm", catdir, inlist[0].regions[i][0].name);
    153     if (!VerifyTableFile (filename)) {
    154       Nbad ++;
    155     }
    156 
    157     if (!CheckCatalogIndexes(catdir, inlist[0].filename[i], inlist[0].regions[i])){
    158       Nbad ++;
    159     }
    160 
    161     // exit immediately if any file are unsorted and we require sorted tables
    162     if (CHECKSORTED && NNotSorted) {
    163       fprintf (stderr, "ERROR: files are not sorted\n");
    164       exit (1);
    165     }
     55  fprintf (stderr, "---- files with errors ---- \n");
     56  for (i = 0; i < Nfailures; i++) {
     57    fprintf (stderr, "%s\n", failures[i]);
    16658  }
    16759
    … …  
    17870}
    17971
    180 // is this file a consistent FITS file?
    181 int VerifyTableFile (char *filename) {
    182 
    183   int status, Next;
    184   off_t Nbytes;
    185   Header header;
    186 
    187   struct stat fileStats;
    188   FILE *file;
    189 
    190   // does the file exist?
    191   status = stat (filename, &fileStats);
    192   if (status) {
    193     // some error accessing the file.  there is only one acceptable error: file not found
    194     switch (errno) {
    195       case ENOENT:
    196         if (DEBUG) fprintf (stderr, "file does not exist, skipping %s\n", filename);
    197         return TRUE;
    198       case ENOMEM:
    199         fprintf (stderr, "Out of memory: %s\n", filename);
    200         return TRUE;
    201       case EACCES:
    202         fprintf (stderr, "Permission error on %s\n", filename);
    203         return FALSE;
    204       case EFAULT:
    205         fprintf (stderr, "Bad address: %s\n", filename);
    206         return FALSE;
    207       case ELOOP:
    208         fprintf (stderr, "Too many symbolic links encountered while traversing the path: %s\n", filename);
    209         return FALSE;
    210       case ENAMETOOLONG:
    211         fprintf (stderr, "File name too long: %s\n", filename);
    212         return FALSE;
    213       case ENOTDIR:
    214         fprintf (stderr, "A component of the path is not a directory: %s\n", filename);
    215         return FALSE;
    216       case EOVERFLOW:
    217         fprintf (stderr, "file too large for program version: %s\n", filename);
    218         return FALSE;
    219       default:
    220         fprintf (stderr, "unknown error: %s\n", filename);
    221         return FALSE;
    222     }
    223   }
    224 
    225   // does it have any data?
    226   if (fileStats.st_size == 0) {
    227     fprintf (stderr, "file is empty: %s\n", filename);
    228     return FALSE;
    229   }
    230 
    231   // can we open it?
    232   file = fopen(filename, "r");
    233   if (!file) {
    234     fprintf (stderr, "unable to open valid file: %s\n", filename);
    235     return FALSE;
    236   }
    237 
    238   // scan all extentions
    239   Nbytes = 0;
    240   Next = -1;
    241   if (DEBUG) fprintf (stderr, "sizes: ("OFF_T_FMT" vs "OFF_T_FMT")\n", Nbytes, fileStats.st_size);
    242   while (Nbytes < fileStats.st_size) {
    243 
    244     // Check on the PHU
    245     if (!gfits_fread_header (file, &header)) {
    246       if (Next == -1) {
    247         fprintf (stderr, "unable to read PHU header for %s\n", filename);
    248       } else {
    249         fprintf (stderr, "unable to read header for %s, extension %d (or file has excess bytes)\n", filename, Next);
    250       }
    251       fclose(file);
    252       return (FALSE);
    253     }
    254 
    255     // move to TBL header
    256     Nbytes += header.datasize + gfits_data_size (&header);
    257     if (DEBUG) fprintf (stderr, "sizes: ("OFF_T_FMT" vs "OFF_T_FMT")\n", Nbytes, fileStats.st_size);
    258     if (Nbytes > fileStats.st_size) {
    259       fprintf (stderr, "file is short ("OFF_T_FMT" vs "OFF_T_FMT"): %s\n", Nbytes, fileStats.st_size, filename);
    260       gfits_free_header(&header);
    261       fclose (file);
    262       return FALSE;
    263     }
    264     gfits_free_header(&header);
    265 
    266     status = fseeko (file, Nbytes, SEEK_SET);
    267     if (status) {
    268       switch (errno) {
    269         case EBADF:
    270           fprintf (stderr, "something wrong with file handle: %s\n", filename);
    271           fclose (file);
    272           return FALSE;
    273         case EINVAL:
    274           fprintf (stderr, "invalid offset: %s\n", filename);
    275           fclose (file);
    276           return FALSE;
    277         default:
    278           fprintf (stderr, "other error in fseeko: %s\n", filename);
    279           fclose (file);
    280           return FALSE;
    281       }
    282     }
    283     Next ++;
    284   }
    285   if (DEBUG) fprintf (stderr, "file is good: %s\n", filename);
    286   fclose (file);
    287   return TRUE;
    288 }
    289 
    290 // CheckCatalogIndexes(catdir, inlist[0].regions[i][0].name);
    291 
    292 int CheckCatalogIndexes (char *catdir, char *filename,  SkyRegion *region) {
    293 
    294   Catalog catalog;
    295   int i, j, m, status;
    296 
    297   status = TRUE;
    298 
    299   // set the parameters which guide catalog open/load/create
    300   catalog.filename  = filename;
    301   catalog.catformat = dvo_catalog_catformat (CATFORMAT);  // set the default catformat from config data
    302   catalog.catmode   = dvo_catalog_catmode (CATMODE);      // set the default catmode from config data
    303   catalog.catflags  = LOAD_AVES | LOAD_MEAS;
    304   catalog.Nsecfilt  = 0;
    305  
    306   // an error exit status here is a significant error (disk I/O or file access)
    307   if (!dvo_catalog_open (&catalog, region, VERBOSE, "r")) {
    308     fprintf (stderr, "ERROR: failure to open catalog file %s\n", catalog.filename);
    309     return FALSE;
    310   }
    311 
    312   // Naves_disk == 0 implies an empty catalog file, skip empty catalogs
    313   if (catalog.Naves_disk == 0) {
    314     dvo_catalog_unlock (&catalog);
    315     dvo_catalog_free (&catalog);
    316     return TRUE;
    317   }
    318 
    319   // if the table is SORTED, then the following can be checked
    320   // check the following:
    321   // measure[j].averef -> average[averef]
    322   // measure[j].objID = average[averef].objID
    323   // measure[j].catID = average[averef].catID
    324   // measure[j].measureOffset < Nmeasure
    325   // \sum average[].Nmeasure = Nmeasure
    326 
    327   // if the table is NOT SORTED, we have a subset of checks we can make
    328   if (!catalog.sorted) {
    329     fprintf (stderr, "!");
    330     dvo_catalog_unlock (&catalog);
    331     dvo_catalog_free (&catalog);
    332     NNotSorted++;
    333     if (VERBOSE) fprintf (stderr, "file is not sorted: %s\n", filename);
    334     return TRUE;
    335   }
    336 
    337   int NmeasureTotal = 0;
    338   int measureOffsetOK = TRUE;
    339   for (i = 0; i < catalog.Naverage; i++) {
    340     NmeasureTotal += catalog.average[i].Nmeasure;
    341     if (VERBOSE && !(NmeasureTotal <= catalog.Nmeasure)) {
    342       fprintf (stderr, "NmeasureTotal > catalog.Nmeasure: %d %d %d\n", i, catalog.average[i].Nmeasure, (int) catalog.Nmeasure);
    343     }
    344     measureOffsetOK &= (catalog.average[i].measureOffset < catalog.Nmeasure);
    345     if (VERBOSE && !(catalog.average[i].measureOffset < catalog.Nmeasure)) {
    346       fprintf (stderr, "measureOffset >= catalog.Nmeasure: %d %d %d\n", i, catalog.average[i].measureOffset, (int) catalog.Nmeasure);
    347     }
    348     measureOffsetOK &= (catalog.average[i].measureOffset + catalog.average[i].Nmeasure <= catalog.Nmeasure);
    349     if (VERBOSE && !(catalog.average[i].measureOffset + catalog.average[i].Nmeasure <= catalog.Nmeasure)) {
    350       fprintf (stderr, "measureOffset + Nmeasure > catalog.Nmeasure : %d %d %d\n", i, catalog.average[i].Nmeasure, (int) catalog.Nmeasure);
    351     }
    352   }
    353 
    354   if (!measureOffsetOK) {
    355     fprintf (stderr, "ERROR: catalog %s has an invalid measureOffset\n", catalog.filename);
    356     status = FALSE;
    357   }
    358 
    359   if (NmeasureTotal != catalog.Nmeasure) {
    360     fprintf (stderr, "ERROR: catalog %s has an invalid Nmeasure\n", catalog.filename);
    361     status = FALSE;
    362   }
    363 
    364   if (!status) {
    365     dvo_catalog_unlock (&catalog);
    366     dvo_catalog_free (&catalog);
    367     return (status);
    368   }
    369 
    370   int objIDsOK = TRUE;
    371   int catIDsOK = TRUE;
    372   int averefOK = TRUE;
    373 
    374   for (i = 0; i < catalog.Naverage; i++) {
    375     m = catalog.average[i].measureOffset;
    376     for (j = 0; j < catalog.average[i].Nmeasure; j++) {
    377       objIDsOK &= (catalog.average[i].objID == catalog.measure[m+j].objID);
    378       catIDsOK &= (catalog.average[i].catID == catalog.measure[m+j].catID);
    379       averefOK &= (catalog.measure[m+j].averef == i);
    380     }
    381   }
    382    
    383   if (!objIDsOK) {
    384     fprintf (stderr, "ERROR: catalog %s has invalid obj IDs\n", catalog.filename);
    385     status = FALSE;
    386   }
    387   if (!catIDsOK) {
    388     fprintf (stderr, "ERROR: catalog %s has invalid cat IDs\n", catalog.filename);
    389     status = FALSE;
    390   }
    391   if (!averefOK) {
    392     fprintf (stderr, "ERROR: catalog %s has invalid averef values\n", catalog.filename);
    393     status = FALSE;
    394   }
    395 
    396 //  for (i = 0; i < catalog.Naverage; i++) {
    397 //    m = catalog.average[i].measureOffset;
    398 //    for (j = 0; i < catalog.Nmeasure; i++) {
    399 //      objIDsOK &= (catalog.average[i].objID == catalog.measure[m+j].objID);
    400 //      catIDsOK &= (catalog.average[i].catID == catalog.measure[m+j].catID);
    401 //      averefOK &= (catalog.measure[m+j].averef = i);
    402 //    }
    403 //  }
    404 
    405   dvo_catalog_unlock (&catalog);
    406   dvo_catalog_free (&catalog);
    407 
    408   return status;
    409 }
    410 
    411 // gfits_scan(&cpmHeaderTBL, "NAXIS1", "%d", 1, &NbytesPerRow);
    412 // gfits_scan(&cpmHeaderTBL, "NAXIS2", "%d", 1, &Nrows);
    413    
    414  

  • trunk/Ohana/src/dvomerge/test

    • Property svn:ignore

      •  

        old new  
        11catdir.test
         2catdir.merge
         3catdir.merge.p1
         4catdir.merge.p2
         5catdir.merge.p3

  • trunk/Ohana/src/libautocode/Makefile.Targets

    r33647 r34260  
    1111$(ASRC)/average-ps1-v2.$(ARCH).o \
    1212$(ASRC)/average-ps1-v3.$(ARCH).o \
     13$(ASRC)/average-ps1-v4.$(ARCH).o \
    1314$(ASRC)/average-ps1-ref.$(ARCH).o \
    1415$(ASRC)/secfilt.$(ARCH).o \
    … …  
    2223$(ASRC)/secfilt-ps1-v2.$(ARCH).o \
    2324$(ASRC)/secfilt-ps1-v3.$(ARCH).o \
     25$(ASRC)/secfilt-ps1-v4.$(ARCH).o \
    2426$(ASRC)/secfilt-ps1-ref.$(ARCH).o \
    2527$(ASRC)/measure.$(ARCH).o \
    … …  
    3335$(ASRC)/measure-ps1-v2.$(ARCH).o \
    3436$(ASRC)/measure-ps1-v3.$(ARCH).o \
     37$(ASRC)/measure-ps1-v4.$(ARCH).o \
    3538$(ASRC)/measure-ps1-ref.$(ARCH).o \
    3639$(ASRC)/missing.$(ARCH).o \
    … …  
    4346$(ASRC)/photcode-ps1-v2.$(ARCH).o \
    4447$(ASRC)/photcode-ps1-v3.$(ARCH).o \
     48$(ASRC)/photcode-ps1-v4.$(ARCH).o \
    4549$(ASRC)/photcode-ps1-ref.$(ARCH).o \
    4650$(ASRC)/image.$(ARCH).o \
    … …  
    5559$(ASRC)/image-ps1-v2.$(ARCH).o \
    5660$(ASRC)/image-ps1-v3.$(ARCH).o \
     61$(ASRC)/image-ps1-v4.$(ARCH).o \
    5762$(ASRC)/image-ps1-ref.$(ARCH).o \
    5863$(ASRC)/regimage.$(ARCH).o \
    … …  
    9095$(AINC)/average-ps1-v2.h \
    9196$(AINC)/average-ps1-v3.h \
     97$(AINC)/average-ps1-v4.h \
    9298$(AINC)/average-ps1-ref.h \
    9399$(AINC)/secfilt.h \
    … …  
    101107$(AINC)/secfilt-ps1-v2.h \
    102108$(AINC)/secfilt-ps1-v3.h \
     109$(AINC)/secfilt-ps1-v4.h \
    103110$(AINC)/secfilt-ps1-ref.h \
    104111$(AINC)/measure.h \
    … …  
    112119$(AINC)/measure-ps1-v2.h \
    113120$(AINC)/measure-ps1-v3.h \
     121$(AINC)/measure-ps1-v4.h \
    114122$(AINC)/measure-ps1-ref.h \
    115123$(AINC)/missing.h \
    … …  
    122130$(AINC)/photcode-ps1-v2.h \
    123131$(AINC)/photcode-ps1-v3.h \
     132$(AINC)/photcode-ps1-v4.h \
    124133$(AINC)/photcode-ps1-ref.h \
    125134$(AINC)/image.h \
    … …  
    134143$(AINC)/image-ps1-v2.h \
    135144$(AINC)/image-ps1-v3.h \
     145$(AINC)/image-ps1-v4.h \
    136146$(AINC)/image-ps1-ref.h \
    137147$(AINC)/regimage.h \

  • trunk/Ohana/src/libautocode/def/cmf-ps1-sv1.d

    r31160 r34260  
    44TYPE    BINTABLE
    55SIZE    200
     6
     7## note that this definition is inconsistent with the definition in
     8## pmModules/src/objects/pmSourceIO_CMF.c.in.  The version in
     9## pmSourceIO*.c creates a table with data not properly aligned with
     10## the 8-byte boundaries. The structure defined by libautocode does
     11## this, but has a different order of elements (and adds padding2 to
     12## fix things). We have generated may files with PS1_SV1 as is, so
     13## I'll leave it. But in future a PS1_SV2 should be forced to match
     14## libautocode. Note that addstar knows to detect the alternate
     15## version of PS1_SV1 and correctly interpret its fields.
    616
    717# elements of data structure / FITS table

  • trunk/Ohana/src/libautocode/def/cmf-ps1-v1.d

    r24400 r34260  
    4444# model shape parameters: F_major, F_minor, F_theta
    4545# centroid errors: sigma_X, sigma_Y, sigma_XY
    46 
    47 # IPP_IDET         1J  IPP_IDET,           unsigned i
    48 # X_PSF          1E  X_PSF,        float,       
    49 # Y_PSF          1E  Y_PSF,        float,       
    50 # X_PSF_SIG      1E  X_PSF_SIG,            float,       
    51 # Y_PSF_SIG      1E  Y_PSF_SIG,            float,       
    52 # RA_PSF         1E  RA_PSF,               float,       
    53 # DEC_PSF        1E  DEC_PSF,              float,       
    54 # POSANGLE       1E  POSANGLE,             float,       
    55 # PLTSCALE       1E  PLTSCALE,             float,       
    56 # PSF_INST_MAG   1E  PSF_INST_MAG,     float,         
    57 # PSF_INST_MAG_SIG 1E  PSF_INST_MAG_SIG, float,       
    58 # AP_MAG_STANDARD  1E  AP_MAG_STANDARD,  float,       
    59 # AP_MAG_RADIUS    1E     
    60 # PEAK_FLUX_AS_MAG 1E  PEAK_FLUX_AS_MAG, float,       
    61 # CAL_PSF_MAG      1E  CAL_PSF_MAG,      float,       
    62 # CAL_PSF_MAG_SIG  1E  CAL_PSF_MAG_SIG,  float,       
    63 # SKY              1E  SKY,              float,       
    64 # SKY_SIGMA        1E  SKY_SIG,          float,       
    65 # PSF_CHISQ        1E  PSF_CHISQ,        float,       
    66 # CR_NSIGMA        1E  CR_NSIGMA,        float,       
    67 # EXT_NSIGMA       1E  EXT_NSIGMA,       float,       
    68 # PSF_MAJOR        1E  PSF_MAJOR,        float,       
    69 # PSF_MINOR        1E  PSF_MINOR,        float,       
    70 # PSF_THETA        1E  PSF_THETA,        float,       
    71 # PSF_QF           1E  PSF_QF,           float,       
    72 # PSF_NDOF         1J  PSF_NDOF,         int,         
    73 # PSF_NPIX         1J  PSF_NPIX,         int,         
    74 # MOMENTS_XX       1E  MOMENTS_XX,       float,       
    75 # MOMENTS_XY       1E  MOMENTS_XY,       float,       
    76 # MOMENTS_YY       1E  MOMENTS_YY,       float,       
    77 # N_FRAMES         1I  N_FRAMES,         short,       
    78 # FLAGS            1J  FLAGS,            int,         

  • trunk/Ohana/src/libautocode/def/cmf-ps1-v2.d

    r24400 r34260  
    4040FIELD padding,   PADDING,          short,    padding for 8byte records
    4141
    42 # for an object in an image, we have three triplets that tell us about the shape:
    43 # second moments: Mxx, Mxy, Myy
    44 # model shape parameters: F_major, F_minor, F_theta
    45 # centroid errors: sigma_X, sigma_Y, sigma_XY
    46 
    47 # IPP_IDET         1J  IPP_IDET,           unsigned i
    48 # X_PSF          1E  X_PSF,        float,       
    49 # Y_PSF          1E  Y_PSF,        float,       
    50 # X_PSF_SIG      1E  X_PSF_SIG,            float,       
    51 # Y_PSF_SIG      1E  Y_PSF_SIG,            float,       
    52 # RA_PSF         1E  RA_PSF,               float,       
    53 # DEC_PSF        1E  DEC_PSF,              float,       
    54 # POSANGLE       1E  POSANGLE,             float,       
    55 # PLTSCALE       1E  PLTSCALE,             float,       
    56 # PSF_INST_MAG   1E  PSF_INST_MAG,     float,         
    57 # PSF_INST_MAG_SIG 1E  PSF_INST_MAG_SIG, float,       
    58 # AP_MAG_STANDARD  1E  AP_MAG_STANDARD,  float,       
    59 # AP_MAG_RADIUS    1E     
    60 # PEAK_FLUX_AS_MAG 1E  PEAK_FLUX_AS_MAG, float,       
    61 # CAL_PSF_MAG      1E  CAL_PSF_MAG,      float,       
    62 # CAL_PSF_MAG_SIG  1E  CAL_PSF_MAG_SIG,  float,       
    63 # SKY              1E  SKY,              float,       
    64 # SKY_SIGMA        1E  SKY_SIG,          float,       
    65 # PSF_CHISQ        1E  PSF_CHISQ,        float,       
    66 # CR_NSIGMA        1E  CR_NSIGMA,        float,       
    67 # EXT_NSIGMA       1E  EXT_NSIGMA,       float,       
    68 # PSF_MAJOR        1E  PSF_MAJOR,        float,       
    69 # PSF_MINOR        1E  PSF_MINOR,        float,       
    70 # PSF_THETA        1E  PSF_THETA,        float,       
    71 # PSF_QF           1E  PSF_QF,           float,       
    72 # PSF_NDOF         1J  PSF_NDOF,         int,         
    73 # PSF_NPIX         1J  PSF_NPIX,         int,         
    74 # MOMENTS_XX       1E  MOMENTS_XX,       float,       
    75 # MOMENTS_XY       1E  MOMENTS_XY,       float,       
    76 # MOMENTS_YY       1E  MOMENTS_YY,       float,       
    77 # N_FRAMES         1I  N_FRAMES,         short,       
    78 # FLAGS            1J  FLAGS,            int,         
     42# fields added since PS1_V1:
     43# RA & DEC promoted to double

  • trunk/Ohana/src/libautocode/def/cmf-ps1-v3.d

    r29537 r34260  
    6464# centroid errors: sigma_X, sigma_Y, sigma_XY
    6565
    66 # # elements of data structure / FITS table
    67 # FIELD detID,          IPP_IDET,          IPP_IDET           1J      unsigned int, detection ID                     
    68 # FIELD X,              X_PSF,             X_PSF              1E      float,    x coord,               pixels
    69 # FIELD Y,              Y_PSF,             Y_PSF              1E      float,    y coord,               pixels
    70 # FIELD dX,             X_PSF_SIG,         X_PSF_SIG          1E      float,    x coord error,         pixels
    71 # FIELD dY,             Y_PSF_SIG,         Y_PSF_SIG          1E      float,    y coord error,         pixels
    72 # FIELD posangle,       POSANGLE,          POSANGLE           1E      float,    Posangle at source,    degrees
    73 # FIELD pltscale,       PLTSCALE,          PLTSCALE           1E      float,    Plate Scale at source, arcsec/pixel
    74 # FIELD M,              PSF_INST_MAG,      PSF_INST_MAG       1E      float,    inst mags,             mags
    75 # FIELD dM,             PSF_INST_MAG_SIG,  PSF_INST_MAG_SIG   1E      float,    inst mag error,        mags
    76 # FIELD flux,           PSF_INST_FLUX,     PSF_INST_FLUX      1E      float,    psf flux,              counts
    77 # FIELD flux,           PSF_INST_FLUX_SIG, PSF_INST_FLUX_SIG  1E      float,    psf flux error,        counts     
    78 # FIELD Map,            AP_MAG_STANDARD,   AP_MAG             1E      float,    standard aperture mag, mags
    79 # FIELD Map,            AP_MAG_RAW,        AP_MAG_RAW         1E      float,    raw aperture mag,      mags
    80 # FIELD apRadius,       AP_MAG_RADIUS,     AP_MAG_RADIUS      1E      float,    radius used for fit,   pixels
    81 # FIELD Mpeak,          PEAK_FLUX_AS_MAG,  PEAK_FLUX_AS_MAG   1E      float,    peak flux as a mag,    mags
    82 # FIELD Mcalib,         CAL_PSF_MAG,       CAL_PSF_MAG        1E      float,    calibrated psf mag,    mags
    83 # FIELD dMcal,          CAL_PSF_MAG_SIG,   CAL_PSF_MAG_SIG    1E      float,    zero point scatter,    mags
    84 # FIELD RA,             RA_PSF,            RA_PSF             1D      double,   PSF RA coord,          degrees
    85 # FIELD DEC,            DEC_PSF,           DEC_PSF            1D      double,   PSF DEC coord,         degrees
    86 # FIELD sky,            SKY,               SKY                1E      float,    sky flux,              cnts/sec
    87 # FIELD dSky,           SKY_SIG,           SKY_SIGMA          1E      float,    sky flux error,        cnts/sec
    88 # FIELD psfChisq,       PSF_CHISQ,         PSF_CHISQ          1E      float,    psf fit chisq
    89 # FIELD crNsigma,       CR_NSIGMA,         CR_NSIGMA          1E      float,    Nsigma deviations from PSF to CF
    90 # FIELD extNsigma,      EXT_NSIGMA,        EXT_NSIGMA         1E      float,    Nsigma deviations from PSF to EXT
    91 # FIELD fx,             PSF_MAJOR,         PSF_MAJOR          1E      float,    psf fit major axis,    pixels
    92 # FIELD fy,             PSF_MINOR,         PSF_MINOR          1E      float,    psf fit minor axis,    pixels
    93 # FIELD df,             PSF_THETA,         PSF_THETA          1E      float,    ellipse angle,         degrees
    94 # FIELD psfQual,        PSF_QF,            PSF_QF             1E      float,    quality factor
    95 # FIELD psfQualPerfect, PSF_QF_PERFECT,    PSF_QF_PERFECT     1E      float,    quality factor perfect
    96 # FIELD psfNdof,        PSF_NDOF,          PSF_NDOF           1J      int,      psf degrees of freedom
    97 # FIELD psfNpix,        PSF_NPIX,          PSF_NPIX           1J      int,      psf number of pixels
    98 # FIELD Mxx,            MOMENTS_XX,        MOMENTS_XX         1E      float,    second moment X,       pixels^2
    99 # FIELD Mxy,            MOMENTS_XY,        MOMENTS_XY         1E      float,    second moment Y,       pixels^2
    100 # FIELD Myy,            MOMENTS_YY,        MOMENTS_YY         1E      float,    second moment XY,      pixels^2
    101 # FIELD M3c,            MOMENTS_M3C,       MOMENTS_M3C        1E      float,    third moment cos(t),   pixels^3
    102 # FIELD M3s,            MOMENTS_M3S,       MOMENTS_M3S        1E      float,    third moment sin(t),   pixels^3
    103 # FIELD M4c,            MOMENTS_M4C,       MOMENTS_M4C        1E      float,    fourth moment cos(t),  pixels^4
    104 # FIELD M4s,            MOMENTS_M4S,       MOMENTS_M4S        1E      float,    fourth moment sin(t),  pixels^4
    105 # FIELD Mr1,            MOMENTS_R1,        MOMENTS_R1         1E      float,    first radial moment,   pixels
    106 # FIELD Mrh,            MOMENTS_RH,        MOMENTS_RH         1E      float,    half radial moment,    pixels^1/2
    107 # FIELD kronFlux,       KRON_FLUX,         KRON_FLUX          1E      float,    kron flux,             counts
    108 # FIELD kronFluxErr,    KRON_FLUX_ERR,     KRON_FLUX_ERR      1E      float,    kron flux error,       counts
    109 # FIELD kronInner,      KRON_FLUX_INNER,   KRON_FLUX_INNER    1E      float,    kron flux 1<R<2.5,     counts
    110 # FIELD kronOuter,      KRON_FLUX_OUTER,   KRON_FLUX_OUTER    1E      float,    kron flux 2.5<R<4,     counts
    111 # FIELD flags,          FLAGS,             FLAGS              1J      int,      analysis flags
    112 # FIELD flags2,         FLAGS,             FLAGS2             1J      int,      analysis flags (2)
    113 # FIELD nFrames,        N_FRAMES,          N_FRAMES           1I      short,    images overlapping peak
    114 # FIELD padding,        PADDING,           PADDING            1I      short,    padding for 8byte records
    115 
    116      
    117 
     66# fields added since PS1_V2:
     67# FIELD Flux,           PSF_INST_FLUX,     float,    psf flux,         counts
     68# FIELD dFlux,          PSF_INST_FLUX_SIG, float,    psf flux error,        counts     
     69# FIELD MapRaw,         AP_MAG_RAW,        float,    raw aperture mag,      mags
     70# FIELD psfQualPerfect, PSF_QF_PERFECT,    float,    quality factor perfect
     71# FIELD M3c,            MOMENTS_M3C,       float,    third moment cos(t),   pixels^3
     72# FIELD M3s,            MOMENTS_M3S,       float,    third moment sin(t),   pixels^3
     73# FIELD M4c,            MOMENTS_M4C,       float,    fourth moment cos(t),  pixels^4
     74# FIELD M4s,            MOMENTS_M4S,       float,    fourth moment sin(t),  pixels^4
     75# FIELD Mr1,            MOMENTS_R1,        float,    first radial moment,   pixels
     76# FIELD Mrh,            MOMENTS_RH,        float,    half radial moment,    pixels^1/2
     77# FIELD kronFlux,       KRON_FLUX,         float,    kron flux,             counts
     78# FIELD kronFluxErr,    KRON_FLUX_ERR,     float,    kron flux error,       counts
     79# FIELD kronInner,      KRON_FLUX_INNER,   float,    kron flux 1<R<2.5,     counts
     80# FIELD kronOuter,      KRON_FLUX_OUTER,   float,    kron flux 2.5<R<4,     counts
     81# FIELD flags2,         FLAGS,             int,      analysis flags (2)

  • trunk/Ohana/src/libautocode/def/measure-ps1-v3.d

    r33647 r34260  
    55DESCRIPTION  DVO Detection Measurement Table
    66
    7 FIELD dR,             D_RA,         float,          RA offset,                    arcsec
    8 FIELD dD,             D_DEC,        float,          DEC offset,                   arcsec
    9 FIELD M,              MAG,          float,          catalog mag,                  mag
    10 FIELD Mcal,           M_CAL,        float,          image cal mag,                mag
    11 FIELD Map,            M_APER,       float,          aperture mag,                 mag
     7FIELD dR,             D_RA,         float,          RA offset,                    arcsec
     8FIELD dD,             D_DEC,        float,          DEC offset,                   arcsec
     9FIELD M,              MAG,          float,          catalog mag,                  mag
     10FIELD Mcal,           M_CAL,        float,          image cal mag,                mag
     11FIELD Map,            M_APER,       float,          aperture mag,                 mag
    1212FIELD dM,             MAG_ERR,      float,          mag error,                    mag
    1313FIELD dMcal,          MAG_CAL_ERR,  float,          systematic calibration error, mag
    … …  
    1515
    1616# note that with airmass = 1.0 / cos(90 - alt), we have full alt/az representation
    17 FIELD airmass,        AIRMASS,      float,          (airmass - 1),                airmass
     17FIELD airmass,        AIRMASS,      float,          (airmass - 1),                airmass
    1818FIELD az,             AZ,           float,          telescope azimuth
    1919
    … …  
    2626FIELD dSky,           SKY_FLUX_ERR, float,          local estimate of sky flux,    counts/sec
    2727
    28 FIELD t,              TIME,         int,            time in seconds (UNIX)
     28FIELD t,              TIME,         int,            time in seconds (UNIX)
    2929FIELD averef,         AVE_REF,      unsigned int,   reference to average entry     
    3030

  • trunk/Ohana/src/libautocode/def/measure.d

    r30604 r34260  
    22EXTNAME      DVO_MEASURE
    33TYPE         BINTABLE
    4 SIZE         148
     4SIZE         172
    55DESCRIPTION  DVO Detection Measurement Table
    66
    7 FIELD dR,             D_RA,         float,          RA offset,                      arcsec
    8 FIELD dD,             D_DEC,        float,          DEC offset,                     arcsec
    9 FIELD M,              MAG,          float,          catalog mag,                    mag
    10 FIELD Mcal,           M_CAL,        float,          image cal mag,                  mag
    11 FIELD Map,            M_APER,       float,          aperture mag,                   mag
     7FIELD dR,             D_RA,         float,          RA offset,                      arcsec
     8FIELD dD,             D_DEC,        float,          DEC offset,                     arcsec
     9FIELD M,              MAG,          float,          catalog mag,                    mag
     10FIELD Mcal,           M_CAL,        float,          image cal mag,                  mag
     11FIELD Map,            M_APER,       float,          aperture mag,                   mag
     12FIELD Mkron,          M_KRON,       float,          kron magnitude,                 mag
     13FIELD dMkron,         M_KRON_ERR,   float,          kron magnitude error,           mag
    1214FIELD dM,             MAG_ERR,      float,          mag error,                      mag
    1315FIELD dMcal,          MAG_CAL_ERR,  float,          systematic calibration error,   mag
    1416FIELD dt,             M_TIME,       float,          exposure time,                  2.5*log(exptime)
    1517
     18# for stacks only?
     19FIELD FluxPSF,        FLUX_PSF,     float,          flux from psf fit,              counts/sec?
     20FIELD dFluxPSF,       FLUX_PSF_ERR, float,          error on psf flux,              counts/sec?
     21FIELD FluxKron,       FLUX_KRON,     float,         flux from kron ap,              counts/sec?
     22FIELD dFluxKron,      FLUX_KRON_ERR, float,         error on kron flux,             counts/sec?
     23
    1624# note that with airmass = 1.0 / cos(90 - alt), we have full alt/az representation
    17 FIELD airmass,        AIRMASS,      float,          (airmass - 1),                  airmass
     25FIELD airmass,        AIRMASS,      float,          (airmass - 1),                  airmass
    1826FIELD az,             AZ,           float,          telescope azimuth
    1927
    … …  
    2634FIELD dSky,           SKY_FLUX_ERR, float,          local estimate of sky flux,     counts/sec
    2735
    28 FIELD t,              TIME,         int,            time in seconds (UNIX)
     36FIELD t,              TIME,         int,            time in seconds (UNIX)
    2937FIELD t_msec,         TIME_MSEC,    unsigned short, time fraction of second,        milliseconds
    3038FIELD averef,         AVE_REF,      unsigned int,   reference to average entry     

  • trunk/Ohana/src/libautocode/def/secfilt.d

    r33963 r34260  
    22EXTNAME      DVO_SECFILT
    33TYPE         BINTABLE
    4 SIZE         32
     4SIZE         64
    55DESCRIPTION  DVO SecFilt : Secondary Filter Data
    66
    77# elements of data structure / FITS table
    8 FIELD  M,           MAG,          float,      average mag in this band,              mags
    9 FIELD  Map,         MAG,          float,      average mag in this band,              mags
    10 FIELD  dM,          MAG_ERR,      float,      formal error on average mag,           mags
    11 FIELD  Xm,          MAG_CHI,      float,      chisq on average mag,                  [100*log(value)]
    12 FIELD  flags,       FLAGS,        uint32_t,   photometry flags
    13 FIELD  Ncode,       NCODE,        short,      number of detections in band
    14 FIELD  Nused,       NUSED,        short,      number of detections used in average
    15 FIELD  M_20,        MAG_20,       short,      lower 20percent mag,                   millimags
    16 FIELD  M_80,        MAG_80,       short,      upper 20percent mag,                   millimags
    17 FIELD  ubercalDist, UBERCAL_DIST, short,      number of images from an ubercal-image
    18 FIELD  Mstdev,      MAG_STDEV,    short,      standard deviation of measurements,    millimags
     8FIELD  M,           MAG,           float,      average mag in this band,              mags
     9FIELD  Map,         MAG,           float,      average mag in this band,              mags
     10FIELD  Mkron,       MAG_KRON,      float,      ave kron mag in this band,             mags
     11FIELD  dMkron,      MAG_KRON_ERR,  float,      formal error on average kron mag,      mags
     12FIELD  dM,          MAG_ERR,       float,      formal error on average mag,           mags
     13FIELD  Xm,          MAG_CHI,       float,      chisq on average mag,                  [100*log(value)]
     14FIELD  FluxPSF,     FLUX_PSF,      float,      mean flux psf fit (PS1: stack)
     15FIELD  dFluxPSF,    FLUX_PSF_ERR,  float,      mean flux psf error
     16FIELD  FluxKron,    FLUX_KRON,     float,      mean flux kron ap (PS1: stack)
     17FIELD  dFluxKron,   FLUX_KRON_ERR, float,      mean flux kron err
     18FIELD  flags,       FLAGS,         uint32_t,   photometry flags
     19FIELD  Ncode,       NCODE,         short,      number of detections in band
     20FIELD  Nused,       NUSED,         short,      number of detections used in average
     21FIELD  M_20,        MAG_20,        short,      lower 20percent mag,                   millimags
     22FIELD  M_80,        MAG_80,        short,      upper 20percent mag,                   millimags
     23FIELD  ubercalDist, UBERCAL_DIST,  short,      number of images from an ubercal-image
     24FIELD  Mstdev,      MAG_STDEV,     short,      standard deviation of measurements,    millimags
     25FIELD  stackID,     STACK_ID,      uint32_t,   image ID of stack used for fluxes (if any)
     26FIELD  dummy,       DUMMY,         uint32_t,   padding
    1927
    2028# *** 20090206 : new fields : M_20, M_80; dropped dummy
    21 # *** 20120302 : new fields : ubercalDist, Map, dummy[2byte]
     29# *** 20120302 : new fields : ubercalDist, Map, Mstdev
     30# *** 20120710 : new fields : Mkron, dMkron, FluxPSF, dFluxPSF, FluxKron, dFluxKron, stackID

  • trunk/Ohana/src/libdvo/Makefile

    r33649 r34260  
    3535$(DESTINC)/ps1_v2_defs.h \
    3636$(DESTINC)/ps1_v3_defs.h \
     37$(DESTINC)/ps1_v4_defs.h \
    3738$(DESTINC)/ps1_ref_defs.h
    3839
    … …  
    7374$(SRC)/dvo_convert_PS1_V2.$(ARCH).o \
    7475$(SRC)/dvo_convert_PS1_V3.$(ARCH).o \
     76$(SRC)/dvo_convert_PS1_V4.$(ARCH).o \
    7577$(SRC)/dvo_convert_PS1_REF.$(ARCH).o \
    7678$(SRC)/flatcorr_io.$(ARCH).o    \
    … …  
    100102$(SRC)/db_utils.$(ARCH).o               \
    101103$(SRC)/convert.$(ARCH).o                \
    102 $(SRC)/HostTable.$(ARCH).o
     104$(SRC)/HostTable.$(ARCH).o              \
     105$(SRC)/BoundaryTree.$(ARCH).o
    103106
    104107

  • trunk/Ohana/src/libdvo/doc/notes.txt

    r21508 r34260  
    2525   include the new STRUCT name.
    2626
    27 7) create a new conversion file dvo_convert_foo.c and define the
     277) create a new conversion file libdvo/src/dvo_convert_foo.c and define the
    2828   internal to Foo conversions.
    2929
    30 8) add the new format to the list of FORMAT conversion in dvo_convert.c.
     308a) add the new dvo_convert_foo.c to libdvo/Makefile
     31
     328b) add the new format to the list of FORMAT conversion in dvo_convert.c.
    3133
    32349) any changes to the internal format need to be reflected in the
    … …  
    4446
    454713) Add the conversion functions to the header file libdvo/include/foo_defs.h
     48
     4914) Add the above foo_defs.h to libdvo/include/dvo.h
     50
     5114) Add the above foo_defs.h to libdvo/Makefile
    4652
    4753* Note some esoteric format issues: 

  • trunk/Ohana/src/libdvo/include/dvo.h

    r33963 r34260  
    2727  DVO_FORMAT_PS1_V2,
    2828  DVO_FORMAT_PS1_V3,
     29  DVO_FORMAT_PS1_V4,
    2930} DVOTableFormat;
    3031
    … …  
    292293} DVOTinyValueMode;
    293294
     295# define BOUNDARY_TREE_NAME_LENGTH 128
     296
     297typedef struct {
     298  int FixedGridDEC;           // is the DEC sequence linear?
     299  int FixedGridRA;            // in the RA sequence in a zone linear?
     300
     301  double DEC_origin;
     302  double DEC_offset;
     303
     304  int Nzone;
     305  double *RA_origin;
     306  double *RA_offset;
     307
     308  int *Nband;
     309  int *NBAND;
     310
     311  double   **ra;
     312  double  **dec;
     313  int    **cell;
     314  char  ***name;
     315} BoundaryTree;
     316
    294317// XXX DROP? // a reduced-subset structure for relastro
    295318// XXX DROP? typedef struct {
    … …  
    448471float PhotCat (Measure *measure);
    449472float PhotAper (Measure *measure);
     473float PhotKron (Measure *measure);
    450474float PhotSys (Measure *measure, Average *average, SecFilt *secfilt);
    451475float PhotRel (Measure *measure, Average *average, SecFilt *secfilt);
    … …  
    456480float PhotdM (PhotCode *code, Average *average, SecFilt *secfilt);
    457481
     482float PhotAperInst (Measure *measure);
     483float PhotKronInst (Measure *measure);
     484float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt);
     485
     486float PhotZeroPoint (Measure *measure, Average *average, SecFilt *secfilt);
     487float PhotAveFluxPSF (PhotCode *code, Average *average, SecFilt *secfilt);
     488float PhotAvedFluxPSF (PhotCode *code, Average *average, SecFilt *secfilt);
     489float PhotAveFluxKron (PhotCode *code, Average *average, SecFilt *secfilt);
     490float PhotAvedFluxKron (PhotCode *code, Average *average, SecFilt *secfilt);
     491
    458492float PhotMstdev (PhotCode *code, Average *average, SecFilt *secfilt);
    459493float PhotM20 (PhotCode *code, Average *average, SecFilt *secfilt);
    460494float PhotM80 (PhotCode *code, Average *average, SecFilt *secfilt);
    461495float PhotUCdist (PhotCode *code, Average *average, SecFilt *secfilt);
     496unsigned int PhotStackID (PhotCode *code, Average *average, SecFilt *secfilt);
    462497
    463498float PhotColorForCode (Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code);
    … …  
    571606# include "ps1_v2_defs.h"
    572607# include "ps1_v3_defs.h"
     608# include "ps1_v4_defs.h"
    573609# include "ps1_ref_defs.h"
    574610
    … …  
    648684int free_tiny_values (Catalog *catalog);
    649685
     686int BoundaryTreeCellCoords (BoundaryTree *tree, int *zone, int *band, double ra, double dec);
     687int BoundaryTreeSave(char *filename, BoundaryTree *tree);
     688BoundaryTree *BoundaryTreeLoad(char *filename);
     689
     690void dvo_average_init (Average *average);
     691void dvo_secfilt_init (SecFilt *secfilt);
     692void dvo_measure_init (Measure *measure);
     693
    650694# endif // DVO_H
    651 

  • trunk/Ohana/src/libdvo/include/dvodb.h

    r33963 r34260  
    2626      MAG_CAT,
    2727      MAG_APER,
     28      MAG_APER_INST,
     29      MAG_KRON,
     30      MAG_KRON_INST,
     31      MAG_KRON_ERR,
    2832      MAG_SYS,
    2933      MAG_REL,
    … …  
    4145      MAG_80,
    4246      MAG_UC_DIST,
     47      MAG_STACK_ID,
     48      MAG_FLUX_PSF,
     49      MAG_FLUX_PSF_ERR,
     50      MAG_FLUX_KRON,
     51      MAG_FLUX_KRON_ERR,
    4352};
    4453
    … …  
    132141      MEAS_MCAL_OFFSET,
    133142      MEAS_FLAT,
     143      MEAS_CENTER_OFFSET,
     144      MEAS_FLUX_PSF,
     145      MEAS_FLUX_PSF_ERR,
     146      MEAS_FLUX_KRON,
     147      MEAS_FLUX_KRON_ERR,
    134148};
    135149

  • trunk/Ohana/src/libdvo/src/LoadPhotcodesFITS.c

    r33649 r34260  
    6363  CONVERT_FORMAT("DVO_PHOTCODE_PS1_V2",    PS1_V2);
    6464  CONVERT_FORMAT("DVO_PHOTCODE_PS1_V3",    PS1_V3);
     65  CONVERT_FORMAT("DVO_PHOTCODE_PS1_V4",    PS1_V4);
    6566
    6667  table = GetPhotcodeTable ();

  • trunk/Ohana/src/libdvo/src/SavePhotcodesFITS.c

    r33649 r34260  
    44/* locking is used to avoid collisions with programs trying to update the photcodes values */
    55/* XXX better distinction between NOT FOUND and FAILURE */
     6
    67int SavePhotcodesFITS (char *filename) {
    78
    … …  
    2930  // for the moment, we simply support the latest photcode format for output
    3031  // XXX update this as needed as new formats are defined
    31   PhotCode_PS1_V3 *photcode_output = PhotCode_Internal_To_PS1_V3 (table[0].code, table[0].Ncode);
     32  PhotCode_PS1_V4 *photcode_output = PhotCode_Internal_To_PS1_V4 (table[0].code, table[0].Ncode);
    3233
    3334  /* convert FITS format data to internal format (byteswaps & EXTNAME) */
    3435  if (!gfits_db_create (&db)) return (FALSE);
    35   if (!gfits_table_set_PhotCode_PS1_V3 (&db.ftable, photcode_output, table[0].Ncode)) return (FALSE);
     36  if (!gfits_table_set_PhotCode_PS1_V4 (&db.ftable, photcode_output, table[0].Ncode)) return (FALSE);
    3637  if (!gfits_db_save (&db)) return (FALSE);
    3738  if (!gfits_db_close (&db)) return (FALSE);

  • trunk/Ohana/src/libdvo/src/dbExtractAverages.c

    r33963 r34260  
    233233          break;
    234234
     235        case MAG_KRON:
     236          value.Flt = PhotKronAve (field->photcode, average, secfilt);
     237          break;
     238
    235239        case MAG_20:
    236240          value.Flt = PhotM20 (field->photcode, average, secfilt);
    … …  
    241245        case MAG_UC_DIST:
    242246          value.Flt = PhotUCdist (field->photcode, average, secfilt);
     247          break;
     248        case MAG_STACK_ID:
     249          value.Int = PhotStackID (field->photcode, average, secfilt);
     250          break;
     251
     252        case MAG_FLUX_PSF:
     253          value.Flt = PhotAveFluxPSF (field->photcode, average, secfilt);
     254          break;
     255        case MAG_FLUX_PSF_ERR:
     256          value.Flt = PhotAvedFluxPSF (field->photcode, average, secfilt);
     257          break;
     258        case MAG_FLUX_KRON:
     259          value.Flt = PhotAveFluxKron (field->photcode, average, secfilt);
     260          break;
     261        case MAG_FLUX_KRON_ERR:
     262          value.Flt = PhotAvedFluxKron (field->photcode, average, secfilt);
    243263          break;
    244264      }

  • trunk/Ohana/src/libdvo/src/dbExtractMeasures.c

    r33649 r34260  
    117117          break;
    118118        case MAG_APER:
    119           value.Flt = PhotAper  (measure);
     119          value.Flt = PhotAper (measure);
     120          break;
     121        case MAG_APER_INST:
     122          value.Flt = PhotAperInst (measure);
     123          break;
     124        case MAG_KRON:
     125          value.Flt = PhotKron (measure);
     126          break;
     127        case MAG_KRON_INST:
     128          value.Flt = PhotKronInst (measure);
     129          break;
     130        case MAG_KRON_ERR:
     131          value.Flt = measure[0].dMkron;
    120132          break;
    121133        case MAG_ERR:
    … …  
    152164          if (Nsec == -1) break;
    153165          value.Int = secfilt[Nsec].Nused;
     166          break;
     167        case MAG_FLUX_PSF:
     168          value.Flt = PhotAveFluxPSF (field->photcode, average, secfilt);
     169          break;
     170        case MAG_FLUX_PSF_ERR:
     171          value.Flt = PhotAvedFluxPSF (field->photcode, average, secfilt);
     172          break;
     173        case MAG_FLUX_KRON:
     174          value.Flt = PhotAveFluxKron (field->photcode, average, secfilt);
     175          break;
     176        case MAG_FLUX_KRON_ERR:
     177          value.Flt = PhotAvedFluxKron (field->photcode, average, secfilt);
    154178          break;
    155179      }
    … …  
    498522      break;
    499523
    500       // add the star/galaxy sep --
     524    case MEAS_CENTER_OFFSET: /* OK */
     525      {
     526        Image *image;
     527        image = MatchImageDVO (measure[0].t, measure[0].photcode, measure[0].imageID);
     528        if (image == NULL) break;
     529       
     530        // we have measure[0].Xccd,Yccd and image[0].NX,NY.  Find the distance to the center
     531
     532        // XXX we may hypotetically have images with -NX to +NX here (eg, projection center), but
     533        // we do not get a detection from that type of image
     534        float Xcenter = 0.5*image[0].NX;
     535        float Ycenter = 0.5*image[0].NY;
     536        float distance = hypot (measure[0].Xccd - Xcenter, measure[0].Yccd - Ycenter);
     537        value.Flt = distance;
     538      }
     539      break;
     540
     541    case MEAS_FLUX_PSF: /* OK */
     542      value.Flt = measure[0].FluxPSF;
     543      break;
     544    case MEAS_FLUX_PSF_ERR: /* OK */
     545      value.Flt = measure[0].dFluxPSF;
     546      break;
     547    case MEAS_FLUX_KRON: /* OK */
     548      value.Flt = measure[0].FluxKron;
     549      break;
     550    case MEAS_FLUX_KRON_ERR: /* OK */
     551      value.Flt = measure[0].dFluxKron;
     552      break;
    501553  }
    502554  return (value);

  • trunk/Ohana/src/libdvo/src/dbFields.c

    r33963 r34260  
    3030int GetMagMode (char *string) {
    3131
    32   if (!strcasecmp (string, "inst"))      return (MAG_INST);
    33   if (!strcasecmp (string, "cat"))       return (MAG_CAT);
    34   if (!strcasecmp (string, "sys"))       return (MAG_SYS);
    35   if (!strcasecmp (string, "rel"))       return (MAG_REL);
    36   if (!strcasecmp (string, "cal"))       return (MAG_CAL);
    37   if (!strcasecmp (string, "ave"))       return (MAG_AVE);
    38   if (!strcasecmp (string, "ref"))       return (MAG_REF);
    39   if (!strcasecmp (string, "ap"))        return (MAG_APER);
    40   if (!strcasecmp (string, "aper"))      return (MAG_APER);
    41   if (!strcasecmp (string, "err"))       return (MAG_ERR);
    42   if (!strcasecmp (string, "aveerr"))    return (MAG_AVE_ERR);
    43   if (!strcasecmp (string, "photflags")) return (MAG_PHOT_FLAGS);
    44   if (!strcasecmp (string, "flags"))     return (MAG_PHOT_FLAGS);
    45   if (!strcasecmp (string, "chisq"))     return (MAG_CHISQ);
    46   if (!strcasecmp (string, "ncode"))     return (MAG_NCODE);
    47   if (!strcasecmp (string, "nphot"))     return (MAG_NPHOT);
    48   if (!strcasecmp (string, "stdev"))     return (MAG_STDEV);
    49   if (!strcasecmp (string, "20"))        return (MAG_20);
    50   if (!strcasecmp (string, "80"))        return (MAG_80);
    51   if (!strcasecmp (string, "ucdist"))    return (MAG_UC_DIST);
     32  if (!strcasecmp (string, "inst"))        return (MAG_INST);
     33  if (!strcasecmp (string, "cat"))         return (MAG_CAT);
     34  if (!strcasecmp (string, "sys"))         return (MAG_SYS);
     35  if (!strcasecmp (string, "rel"))         return (MAG_REL);
     36  if (!strcasecmp (string, "cal"))         return (MAG_CAL);
     37  if (!strcasecmp (string, "ave"))         return (MAG_AVE);
     38  if (!strcasecmp (string, "ref"))         return (MAG_REF);
     39  if (!strcasecmp (string, "ap"))          return (MAG_APER);
     40  if (!strcasecmp (string, "aper"))        return (MAG_APER);
     41  if (!strcasecmp (string, "aperinst"))    return (MAG_APER_INST);
     42  if (!strcasecmp (string, "aper_inst"))   return (MAG_APER_INST);
     43  if (!strcasecmp (string, "kron"))        return (MAG_KRON);
     44  if (!strcasecmp (string, "kroninst"))    return (MAG_KRON_INST);
     45  if (!strcasecmp (string, "kron_inst"))   return (MAG_KRON_INST);
     46  if (!strcasecmp (string, "kronerr"))     return (MAG_KRON_ERR);
     47  if (!strcasecmp (string, "err"))         return (MAG_ERR);
     48  if (!strcasecmp (string, "aveerr"))      return (MAG_AVE_ERR);
     49  if (!strcasecmp (string, "photflags"))   return (MAG_PHOT_FLAGS);
     50  if (!strcasecmp (string, "flags"))       return (MAG_PHOT_FLAGS);
     51  if (!strcasecmp (string, "chisq"))       return (MAG_CHISQ);
     52  if (!strcasecmp (string, "ncode"))       return (MAG_NCODE);
     53  if (!strcasecmp (string, "nphot"))       return (MAG_NPHOT);
     54  if (!strcasecmp (string, "stdev"))       return (MAG_STDEV);
     55  if (!strcasecmp (string, "20"))          return (MAG_20);
     56  if (!strcasecmp (string, "80"))          return (MAG_80);
     57  if (!strcasecmp (string, "ucdist"))      return (MAG_UC_DIST);
     58  if (!strcasecmp (string, "stackID"))     return (MAG_STACK_ID);
     59  if (!strcasecmp (string, "fluxpsf"))     return (MAG_FLUX_PSF);
     60  if (!strcasecmp (string, "fluxpsferr"))  return (MAG_FLUX_PSF_ERR);
     61  if (!strcasecmp (string, "fluxkron"))    return (MAG_FLUX_KRON);
     62  if (!strcasecmp (string, "fluxkronerr")) return (MAG_FLUX_KRON_ERR);
    5263  return (MAG_NONE);
    5364}
    … …  
    229240  if (!strcasecmp (fieldName, "MCAL_OFFSET"))    ESCAPE (MEAS_MCAL_OFFSET,    MAG_NONE, OPIHI_FLT);
    230241  if (!strcasecmp (fieldName, "FLAT"))           ESCAPE (MEAS_FLAT,           MAG_NONE, OPIHI_FLT);
     242  if (!strcasecmp (fieldName, "CENTER_OFFSET"))  ESCAPE (MEAS_CENTER_OFFSET,  MAG_NONE, OPIHI_FLT);
     243  if (!strcasecmp (fieldName, "FLUX"))           ESCAPE (MEAS_FLUX_PSF,       MAG_NONE, OPIHI_FLT);
     244  if (!strcasecmp (fieldName, "FLUX_ERR"))       ESCAPE (MEAS_FLUX_PSF_ERR,   MAG_NONE, OPIHI_FLT);
     245  if (!strcasecmp (fieldName, "FLUX_PSF"))       ESCAPE (MEAS_FLUX_PSF,       MAG_NONE, OPIHI_FLT);
     246  if (!strcasecmp (fieldName, "FLUX_PSF_ERR"))   ESCAPE (MEAS_FLUX_PSF_ERR,   MAG_NONE, OPIHI_FLT);
     247  if (!strcasecmp (fieldName, "FLUX_KRON"))      ESCAPE (MEAS_FLUX_KRON,      MAG_NONE, OPIHI_FLT);
     248  if (!strcasecmp (fieldName, "FLUX_KRON_ERR"))  ESCAPE (MEAS_FLUX_KRON_ERR,  MAG_NONE, OPIHI_FLT);
    231249
    232250  // for words that don't parse, try a photcode
    … …  
    242260  field->magMode = mode;
    243261  switch (mode) {
     262    case MAG_STACK_ID:
    244263    case MAG_NCODE:
    245264    case MAG_NPHOT:
    … …  
    336355  field->magMode = mode;
    337356  switch (mode) {
     357    case MAG_STACK_ID:
    338358    case MAG_NCODE:
    339359    case MAG_NPHOT:

  • trunk/Ohana/src/libdvo/src/dvo_catalog.c

    r33963 r34260  
    5555  if (!strcasecmp (catformat, "PS1_V2"))          return (DVO_FORMAT_PS1_V2);
    5656  if (!strcasecmp (catformat, "PS1_V3"))          return (DVO_FORMAT_PS1_V3);
     57  if (!strcasecmp (catformat, "PS1_V4"))          return (DVO_FORMAT_PS1_V4);
    5758  if (!strcasecmp (catformat, "PS1_REF"))         return (DVO_FORMAT_PS1_REF);
    5859  return (DVO_FORMAT_UNDEF);
    … …  
    6667  if (!strcasecmp (catmode, "SPLIT")) return (DVO_MODE_SPLIT);
    6768  return (DVO_MODE_UNDEF);
     69}
     70
     71// init all data, or just catalog data
     72void dvo_average_init (Average *average) {
     73  average->R               = 0;
     74  average->D               = 0;
     75  average->dR              = 0;
     76  average->dD              = 0;
     77
     78  average->uR              = 0;
     79  average->uD              = 0;
     80  average->duR             = 0;
     81  average->duD             = 0;
     82  average->P               = 0;
     83  average->dP              = 0;
     84
     85  average->ChiSqAve        = 0.0;
     86  average->ChiSqPM         = 0.0;
     87  average->ChiSqPar        = 0.0;
     88  average->Tmean           = 0;
     89  average->Trange          = 0;
     90
     91  average->Xp              = 0;
     92  average->Npos            = 0;
     93
     94  average->Nmeasure        = 0;
     95  average->Nmissing        = 0;
     96  average->Nextend         = 0;
     97  average->measureOffset   = -1;
     98  average->missingOffset   = -1;
     99  average->extendOffset    = -1;
     100
     101  average->flags           = 0;
     102  average->photFlagsUpper  = 0;
     103  average->photFlagsLower  = 0;
     104
     105  average->objID           = 0;
     106  average->catID           = 0;
     107  average->extID           = 0;
     108}
     109
     110// init all data, or just catalog data
     111void dvo_secfilt_init (SecFilt *secfilt) {
     112  secfilt->M           = NAN;
     113  secfilt->Map         = NAN;
     114  secfilt->Mkron       = NAN;
     115  secfilt->dMkron      = NAN;
     116  secfilt->dM          = NAN;
     117  secfilt->Xm          = NAN_S_SHORT;
     118
     119  secfilt->FluxPSF     = NAN;
     120  secfilt->dFluxPSF    = NAN;
     121  secfilt->FluxKron    = NAN;
     122  secfilt->dFluxKron   = NAN;
     123
     124  secfilt->flags       = 0;
     125  secfilt->Ncode       = 0;
     126  secfilt->Nused       = 0;
     127
     128  secfilt->M_20        = NAN_S_SHORT;
     129  secfilt->M_80        = NAN_S_SHORT;
     130
     131  secfilt->ubercalDist = 1000;
     132  secfilt->Mstdev      = NAN_S_SHORT;
     133  secfilt->stackID     = 0;
     134
     135  secfilt->dummy       = 0;
     136}
     137
     138// init all data, or just catalog data
     139void dvo_measure_init (Measure *measure) {
     140 measure->M         = NAN;
     141 measure->dR        = NAN;
     142 measure->dD        = NAN;
     143 measure->M         = NAN;
     144 measure->Mcal      = NAN;
     145 measure->Map       = NAN;
     146 measure->Mkron     = NAN;
     147 measure->dMkron    = NAN;
     148 measure->dM        = NAN;
     149 measure->dMcal     = NAN;
     150 measure->dt        = NAN;
     151
     152 measure->FluxPSF   = NAN;
     153 measure->dFluxPSF  = NAN;
     154 measure->FluxKron  = NAN;
     155 measure->dFluxKron = NAN;
     156
     157 measure->airmass   = NAN;
     158 measure->az        = NAN;
     159
     160 measure->Xccd      = NAN;
     161 measure->Yccd      = NAN;
     162
     163 measure->Sky       = NAN;
     164 measure->dSky      = NAN;
     165
     166 measure->t         = 0;
     167 measure->t_msec    = 0;
     168 measure->averef    = 0;
     169
     170 measure->detID     = 0;
     171 measure->imageID   = 0;
     172 measure->objID     = 0;
     173 measure->catID     = 0;
     174 measure->extID     = 0;
     175
     176 measure->psfQual   = NAN;
     177 measure->psfChisq  = NAN;
     178 measure->psfNdof   = 0;
     179 measure->psfNpix   = 0;
     180 measure->crNsigma  = NAN;
     181 measure->extNsigma = NAN;
     182
     183 measure->FWx       = 0;
     184 measure->FWy       = 0;
     185 measure->theta     = 0;
     186
     187 measure->Mxx       = 0;
     188 measure->Mxy       = 0;
     189 measure->Myy       = 0;
     190
     191 measure->dXccd     = 0;
     192 measure->dYccd     = 0;
     193 measure->dRsys     = 0;
     194
     195 measure->posangle  = 0;
     196 measure->pltscale  = NAN;
     197
     198 measure->photcode  = 0;
     199 measure->dbFlags   = 0;
     200 measure->photFlags = 0;
    68201}
    69202
    … …  
    600733}
    601734
     735

  • trunk/Ohana/src/libdvo/src/dvo_catalog_raw.c

    r33649 r34260  
    8989      FORMAT_CASE (PS1_V2,    PS1_V2);
    9090      FORMAT_CASE (PS1_V3,    PS1_V3);
     91      FORMAT_CASE (PS1_V4,    PS1_V4);
    9192      FORMAT_CASE (PS1_REF,   PS1_REF);
    9293
    … …  
    282283  if (catalog[0].catformat == DVO_FORMAT_PS1_V2)          gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_V2");
    283284  if (catalog[0].catformat == DVO_FORMAT_PS1_V3)          gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_V3");
     285  if (catalog[0].catformat == DVO_FORMAT_PS1_V4)          gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_V4");
    284286  if (catalog[0].catformat == DVO_FORMAT_PS1_REF)         gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_REF");
    285287
    … …  
    384386      FORMAT_CASE (PS1_V2,    PS1_V2);
    385387      FORMAT_CASE (PS1_V3,    PS1_V3);
     388      FORMAT_CASE (PS1_V4,    PS1_V4);
    386389      FORMAT_CASE (PS1_REF,   PS1_REF);
    387390
    … …  
    434437      FORMAT_CASE (PS1_V2,    PS1_V2);
    435438      FORMAT_CASE (PS1_V3,    PS1_V3);
     439      FORMAT_CASE (PS1_V4,    PS1_V4);
    436440      FORMAT_CASE (PS1_REF,   PS1_REF);
    437441
    … …  
    488492      FORMAT_CASE (PS1_V2,    PS1_V2);
    489493      FORMAT_CASE (PS1_V3,    PS1_V3);
     494      FORMAT_CASE (PS1_V4,    PS1_V4);
    490495      FORMAT_CASE (PS1_REF,   PS1_REF);
    491496
    … …  
    538543      FORMAT_CASE (PS1_V2,    PS1_V2);
    539544      FORMAT_CASE (PS1_V3,    PS1_V3);
     545      FORMAT_CASE (PS1_V4,    PS1_V4);
    540546      FORMAT_CASE (PS1_REF,   PS1_REF);
    541547
    … …  
    592598      FORMAT_CASE (PS1_V2,    PS1_V2);
    593599      FORMAT_CASE (PS1_V3,    PS1_V3);
     600      FORMAT_CASE (PS1_V4,    PS1_V4);
    594601      FORMAT_CASE (PS1_REF,   PS1_REF);
    595602
    … …  
    642649      FORMAT_CASE (PS1_V2,    PS1_V2);
    643650      FORMAT_CASE (PS1_V3,    PS1_V3);
     651      FORMAT_CASE (PS1_V4,    PS1_V4);
    644652      FORMAT_CASE (PS1_REF,   PS1_REF);
    645653

  • trunk/Ohana/src/libdvo/src/dvo_convert.c

    r33649 r34260  
    4040  CONVERT_FORMAT ("DVO_AVERAGE_PS1_V2",          PS1_V2);
    4141  CONVERT_FORMAT ("DVO_AVERAGE_PS1_V3",          PS1_V3);
     42  CONVERT_FORMAT ("DVO_AVERAGE_PS1_V4",          PS1_V4);
    4243  CONVERT_FORMAT ("DVO_AVERAGE_PS1_REF",         PS1_REF);
    4344# undef CONVERT_FORMAT
    … …  
    9697  CONVERT_FORMAT ("DVO_AVERAGE_PS1_V2",          PS1_V2,          PS1_V2);
    9798  CONVERT_FORMAT ("DVO_AVERAGE_PS1_V3",          PS1_V3,          PS1_V3);
     99  CONVERT_FORMAT ("DVO_AVERAGE_PS1_V4",          PS1_V4,          PS1_V4);
    98100  CONVERT_FORMAT ("DVO_AVERAGE_PS1_REF",         PS1_REF,         PS1_REF);
    99101# undef CONVERT_FORMAT
    … …  
    130132      FORMAT_CASE (PS1_V2,          PS1_V2);
    131133      FORMAT_CASE (PS1_V3,          PS1_V3);
     134      FORMAT_CASE (PS1_V4,          PS1_V4);
    132135      FORMAT_CASE (PS1_REF,         PS1_REF);
    133136# undef FORMAT_CASE
    … …  
    185188  CONVERT_FORMAT ("DVO_MEASURE_PS1_V2",          PS1_V2,          PS1_V2);
    186189  CONVERT_FORMAT ("DVO_MEASURE_PS1_V3",          PS1_V3,          PS1_V3);
     190  CONVERT_FORMAT ("DVO_MEASURE_PS1_V4",          PS1_V4,          PS1_V4);
    187191  CONVERT_FORMAT ("DVO_MEASURE_PS1_REF",         PS1_REF,         PS1_REF);
    188192# undef CONVERT_FORMAT
    … …  
    219223      FORMAT_CASE (PS1_V2,          PS1_V2);
    220224      FORMAT_CASE (PS1_V3,          PS1_V3);
     225      FORMAT_CASE (PS1_V4,          PS1_V4);
    221226      FORMAT_CASE (PS1_REF,         PS1_REF);
    222227# undef FORMAT_CASE
    … …  
    274279  CONVERT_FORMAT ("DVO_SECFILT_PS1_V2",          PS1_V2,          PS1_V2);
    275280  CONVERT_FORMAT ("DVO_SECFILT_PS1_V3",          PS1_V3,          PS1_V3);
     281  CONVERT_FORMAT ("DVO_SECFILT_PS1_V4",          PS1_V4,          PS1_V4);
    276282  CONVERT_FORMAT ("DVO_SECFILT_PS1_REF",         PS1_REF,         PS1_REF);
    277283# undef CONVERT_FORMAT
    … …  
    308314      FORMAT_CASE (PS1_V2,          PS1_V2);
    309315      FORMAT_CASE (PS1_V3,          PS1_V3);
     316      FORMAT_CASE (PS1_V4,          PS1_V4);
    310317      FORMAT_CASE (PS1_REF,         PS1_REF);
    311318# undef FORMAT_CASE
    … …  
    387394  CONVERT_FORMAT ("DVO_IMAGE_PS1_V2",          PS1_V2,          PS1_V2);
    388395  CONVERT_FORMAT ("DVO_IMAGE_PS1_V3",          PS1_V3,          PS1_V3);
     396  CONVERT_FORMAT ("DVO_IMAGE_PS1_V4",          PS1_V4,          PS1_V4);
    389397  CONVERT_FORMAT ("DVO_IMAGE_PS1_REF",         PS1_REF,         PS1_REF);
    390398
    … …  
    425433      FORMAT_CASE (PS1_V2,          PS1_V2);
    426434      FORMAT_CASE (PS1_V3,          PS1_V3);
     435      FORMAT_CASE (PS1_V4,          PS1_V4);
    427436      FORMAT_CASE (PS1_REF,         PS1_REF);
    428437
    … …  
    479488      FORMAT_CASE (PS1_V2,          PS1_V2);
    480489      FORMAT_CASE (PS1_V3,          PS1_V3);
     490      FORMAT_CASE (PS1_V4,          PS1_V4);
    481491      FORMAT_CASE (PS1_REF,         PS1_REF);
    482492

  • trunk/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_1.c

    r33963 r34260  
    5757    out[i].psfNdof    = 0;
    5858    out[i].psfNpix    = 0;
     59
     60    // added for PS1_V4
     61    out[i].Mkron      = NAN;
     62    out[i].dMkron     = NAN;
     63    out[i].FluxPSF    = NAN;
     64    out[i].dFluxPSF   = NAN;
     65    out[i].FluxKron   = NAN;
     66    out[i].dFluxKron  = NAN;
    5967  }
    6068  return (out);
    … …  
    215223    out[i].Mstdev      = 0;
    216224    out[i].ubercalDist = 0;
     225
     226    // added for PS1_V4
     227    out[i].Mkron       = NAN;
     228    out[i].dMkron      = NAN;
     229    out[i].FluxPSF     = NAN;
     230    out[i].dFluxPSF    = NAN;
     231    out[i].FluxKron    = NAN;
     232    out[i].dFluxKron   = NAN;
     233    out[i].stackID     = 0;
    217234 }
    218235  return (out);

  • trunk/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_2.c

    r33963 r34260  
    5454    out[i].psfNdof    = 0;
    5555    out[i].psfNpix    = 0;
     56
     57    // added for PS1_V4
     58    out[i].Mkron      = NAN;
     59    out[i].dMkron     = NAN;
     60    out[i].FluxPSF    = NAN;
     61    out[i].dFluxPSF   = NAN;
     62    out[i].FluxKron   = NAN;
     63    out[i].dFluxKron  = NAN;
    5664  }
    5765  return (out);
    … …  
    209217    out[i].Mstdev      = 0;
    210218    out[i].ubercalDist = 0;
     219
     220    // added for PS1_V4
     221    out[i].Mkron       = NAN;
     222    out[i].dMkron      = NAN;
     223    out[i].FluxPSF     = NAN;
     224    out[i].dFluxPSF    = NAN;
     225    out[i].FluxKron    = NAN;
     226    out[i].dFluxKron   = NAN;
     227    out[i].stackID     = 0;
    211228 }
    212229  return (out);

  • trunk/Ohana/src/libdvo/src/dvo_convert_PS1_REF.c

    r33963 r34260  
    5252    out[i].dbFlags    = 0;
    5353    out[i].photFlags  = 0;
     54
     55    // added for PS1_V4
     56    out[i].Mkron      = NAN;
     57    out[i].dMkron     = NAN;
     58    out[i].FluxPSF    = NAN;
     59    out[i].dFluxPSF   = NAN;
     60    out[i].FluxKron   = NAN;
     61    out[i].dFluxKron  = NAN;
    5462  }
    5563  return (out);
    … …  
    169177    out[i].Mstdev      = 0;
    170178    out[i].ubercalDist = 0;
     179
     180    // added for PS1_V4
     181    out[i].Mkron       = NAN;
     182    out[i].dMkron      = NAN;
     183    out[i].FluxPSF     = NAN;
     184    out[i].dFluxPSF    = NAN;
     185    out[i].FluxKron    = NAN;
     186    out[i].dFluxKron   = NAN;
     187    out[i].stackID     = 0;
    171188 }
    172189  return (out);

  • trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V1.c

    r33963 r34260  
    5252    out[i].dbFlags    = in[i].dbFlags;
    5353    out[i].photFlags  = in[i].photFlags;
     54
     55    // added for PS1_V4
     56    out[i].Mkron      = NAN;
     57    out[i].dMkron     = NAN;
     58    out[i].FluxPSF    = NAN;
     59    out[i].dFluxPSF   = NAN;
     60    out[i].FluxKron   = NAN;
     61    out[i].dFluxKron  = NAN;
    5462  }
    5563  return (out);
    … …  
    213221    out[i].Mstdev      = 0;
    214222    out[i].ubercalDist = 0;
     223
     224    // added for PS1_V4
     225    out[i].Mkron       = NAN;
     226    out[i].dMkron      = NAN;
     227    out[i].FluxPSF     = NAN;
     228    out[i].dFluxPSF    = NAN;
     229    out[i].FluxKron    = NAN;
     230    out[i].dFluxKron   = NAN;
     231    out[i].stackID     = 0;
    215232 }
    216233  return (out);

  • trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V2.c

    r33963 r34260  
    5353    out[i].dbFlags    = in[i].dbFlags;
    5454    out[i].photFlags  = in[i].photFlags;
     55
     56    // added for PS1_V4
     57    out[i].Mkron      = NAN;
     58    out[i].dMkron     = NAN;
     59    out[i].FluxPSF    = NAN;
     60    out[i].dFluxPSF   = NAN;
     61    out[i].FluxKron   = NAN;
     62    out[i].dFluxKron  = NAN;
    5563  }
    5664  return (out);
    … …  
    216224    out[i].Mstdev      = 0;
    217225    out[i].ubercalDist = 0;
     226
     227    // added for PS1_V4
     228    out[i].Mkron       = NAN;
     229    out[i].dMkron      = NAN;
     230    out[i].FluxPSF     = NAN;
     231    out[i].dFluxPSF    = NAN;
     232    out[i].FluxKron    = NAN;
     233    out[i].dFluxKron   = NAN;
     234    out[i].stackID     = 0;
    218235 }
    219236  return (out);

  • trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V3.c

    r33963 r34260  
    5353    out[i].dbFlags    = in[i].dbFlags;
    5454    out[i].photFlags  = in[i].photFlags;
     55
     56    // added for PS1_V4
     57    out[i].Mkron      = NAN;
     58    out[i].dMkron     = NAN;
     59    out[i].FluxPSF    = NAN;
     60    out[i].dFluxPSF   = NAN;
     61    out[i].FluxKron   = NAN;
     62    out[i].dFluxKron  = NAN;
    5563  }
    5664  return (out);
    … …  
    214222    out[i].Mstdev      = in[i].Mstdev;     
    215223    out[i].ubercalDist = in[i].ubercalDist;     
     224
     225    // added for PS1_V4
     226    out[i].Mkron       = NAN;
     227    out[i].dMkron      = NAN;
     228    out[i].FluxPSF     = NAN;
     229    out[i].dFluxPSF    = NAN;
     230    out[i].FluxKron    = NAN;
     231    out[i].dFluxKron   = NAN;
     232    out[i].stackID     = 0;
    216233 }
    217234  return (out);

  • trunk/Ohana/src/libdvo/src/dvo_convert_elixir.c

    r33963 r34260  
    6464    out[i].psfNdof    = 0;
    6565    out[i].psfNpix    = 0;
     66
     67    // added for PS1_V4
     68    out[i].Mkron      = NAN;
     69    out[i].dMkron     = NAN;
     70    out[i].FluxPSF    = NAN;
     71    out[i].dFluxPSF   = NAN;
     72    out[i].FluxKron   = NAN;
     73    out[i].dFluxKron  = NAN;
    6674  }
    6775  return (out);
    … …  
    224232    out[i].Mstdev      = 0;
    225233    out[i].ubercalDist = 0;
     234
     235    // added for PS1_V4
     236    out[i].Mkron       = NAN;
     237    out[i].dMkron      = NAN;
     238    out[i].FluxPSF    = NAN;
     239    out[i].dFluxPSF   = NAN;
     240    out[i].FluxKron   = NAN;
     241    out[i].dFluxKron  = NAN;
     242    out[i].stackID     = 0;
    226243  }
    227244  return (out);

  • trunk/Ohana/src/libdvo/src/dvo_convert_loneos.c

    r33963 r34260  
    6666    out[i].psfNdof    = 0;
    6767    out[i].psfNpix    = 0;
     68
     69    // added for PS1_V4
     70    out[i].Mkron      = NAN;
     71    out[i].dMkron     = NAN;
     72    out[i].FluxPSF    = NAN;
     73    out[i].dFluxPSF   = NAN;
     74    out[i].FluxKron   = NAN;
     75    out[i].dFluxKron  = NAN;
    6876  }
    6977  return (out);
    … …  
    217225    out[i].Mstdev      = 0;
    218226    out[i].ubercalDist = 0;
     227
     228    // added for PS1_V4
     229    out[i].Mkron       = NAN;
     230    out[i].dMkron      = NAN;
     231    out[i].FluxPSF    = NAN;
     232    out[i].dFluxPSF   = NAN;
     233    out[i].FluxKron   = NAN;
     234    out[i].dFluxKron  = NAN;
     235    out[i].stackID     = 0;
    219236  }
    220237  return (out);

  • trunk/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_0.c

    r33963 r34260  
    6161    out[i].psfNdof    = 0;
    6262    out[i].psfNpix    = 0;
     63
     64    // added for PS1_V4
     65    out[i].Mkron      = NAN;
     66    out[i].dMkron     = NAN;
     67    out[i].FluxPSF     = NAN;
     68    out[i].dFluxPSF    = NAN;
     69    out[i].FluxKron    = NAN;
     70    out[i].dFluxKron   = NAN;
    6371  }
    6472  return (out);
    … …  
    224232    out[i].Mstdev      = 0;
    225233    out[i].ubercalDist = 0;
     234
     235    // added for PS1_V4
     236    out[i].Mkron       = NAN;
     237    out[i].dMkron      = NAN;
     238    out[i].FluxPSF     = NAN;
     239    out[i].dFluxPSF    = NAN;
     240    out[i].FluxKron    = NAN;
     241    out[i].dFluxKron   = NAN;
     242    out[i].stackID     = 0;
    226243 }
    227244  return (out);

  • trunk/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_1.c

    r33963 r34260  
    6161    out[i].psfNdof    = 0;
    6262    out[i].psfNpix    = 0;
     63
     64    // added for PS1_V4
     65    out[i].Mkron      = NAN;
     66    out[i].dMkron     = NAN;
     67    out[i].FluxPSF     = NAN;
     68    out[i].dFluxPSF    = NAN;
     69    out[i].FluxKron    = NAN;
     70    out[i].dFluxKron   = NAN;
    6371  }
    6472  return (out);
    … …  
    224232    out[i].Mstdev      = 0;
    225233    out[i].ubercalDist = 0;
     234
     235    // added for PS1_V4
     236    out[i].Mkron       = NAN;
     237    out[i].dMkron      = NAN;
     238    out[i].FluxPSF     = NAN;
     239    out[i].dFluxPSF    = NAN;
     240    out[i].FluxKron    = NAN;
     241    out[i].dFluxKron   = NAN;
     242    out[i].stackID     = 0;
    226243 }
    227244  return (out);

  • trunk/Ohana/src/libdvo/src/dvo_image.c

    r34088 r34260  
    212212  if (db[0].format == DVO_FORMAT_PS1_V2)          gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V2");
    213213  if (db[0].format == DVO_FORMAT_PS1_V3)          gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V3");
     214  if (db[0].format == DVO_FORMAT_PS1_V4)          gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V4");
    214215  if (db[0].format == DVO_FORMAT_PS1_REF)         gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_REF");
    215216 

  • trunk/Ohana/src/libdvo/src/dvo_image_raw.c

    r33649 r34260  
    5858  if (db[0].format == DVO_FORMAT_PS1_V2)          ImageSize = sizeof(Image_PS1_V2);
    5959  if (db[0].format == DVO_FORMAT_PS1_V3)          ImageSize = sizeof(Image_PS1_V3);
     60  if (db[0].format == DVO_FORMAT_PS1_V4)          ImageSize = sizeof(Image_PS1_V4);
    6061  if (db[0].format == DVO_FORMAT_PS1_REF)         ImageSize = sizeof(Image_PS1_REF);
    6162
    … …  
    8788  if (db[0].format == DVO_FORMAT_PS1_V2)          gfits_table_mkheader_Image_PS1_V2 (&db[0].theader);
    8889  if (db[0].format == DVO_FORMAT_PS1_V3)          gfits_table_mkheader_Image_PS1_V3 (&db[0].theader);
     90  if (db[0].format == DVO_FORMAT_PS1_V4)          gfits_table_mkheader_Image_PS1_V4 (&db[0].theader);
    8991  if (db[0].format == DVO_FORMAT_PS1_REF)         gfits_table_mkheader_Image_PS1_REF (&db[0].theader);
    9092   

  • trunk/Ohana/src/libdvo/src/dvo_photcode_ops.c

    r33963 r34260  
    278278}
    279279
     280float PhotAperInst (Measure *measure) {
     281
     282  int Np;
     283  float Minst;
     284
     285  Np = photcodes[0].hashcode[measure[0].photcode];
     286  if (Np == -1) return (NAN);
     287
     288  if (photcodes[0].code[Np].type == PHOT_REF) {
     289    Minst = measure[0].Map;
     290    return (Minst);
     291  }
     292  Minst = measure[0].Map - measure[0].dt - ZERO_POINT;
     293 
     294  return (Minst);
     295}
     296
     297float PhotKron (Measure *measure) {
     298
     299  int Np;
     300  float Mcat;
     301  PhotCode *code;
     302
     303  Np = photcodes[0].hashcode[measure[0].photcode];
     304  if (Np == -1) return (NAN);
     305
     306  if (photcodes[0].code[Np].type == PHOT_REF) {
     307    Mcat = measure[0].Mkron;
     308    return (Mcat);
     309  }
     310  code = &photcodes[0].code[Np];
     311  Mcat = measure[0].Mkron - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
     312 
     313  return (Mcat);
     314}
     315
     316float PhotKronInst (Measure *measure) {
     317
     318  int Np;
     319  float Minst;
     320
     321  Np = photcodes[0].hashcode[measure[0].photcode];
     322  if (Np == -1) return (NAN);
     323
     324  if (photcodes[0].code[Np].type == PHOT_REF) {
     325    Minst = measure[0].Mkron;
     326    return (Minst);
     327  }
     328  Minst = measure[0].Mkron - measure[0].dt - ZERO_POINT;
     329 
     330  return (Minst);
     331}
     332
    280333float PhotSys (Measure *measure, Average *average, SecFilt *secfilt) {
    281334
    … …  
    307360  Msys = Mcat + Mcol;
    308361  return (Msys);
     362}
     363
     364float PhotZeroPoint (Measure *measure, Average *average, SecFilt *secfilt) {
     365
     366  int Np;
     367  float ZP;
     368  PhotCode *code;
     369
     370  Np = photcodes[0].hashcode[measure[0].photcode];
     371  if (Np == -1) return (NAN);
     372
     373  if (photcodes[0].code[Np].type == PHOT_REF) {
     374    ZP = 0.0;
     375    return (ZP);
     376  }
     377  code = &photcodes[0].code[Np];
     378  ZP = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
     379
     380  return (ZP);
    309381}
    310382
    … …  
    488560}
    489561
     562float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt) {
     563
     564  int Ns;
     565  float Mkron;
     566
     567  if (code == NULL) return NAN;
     568
     569  Ns = photcodes[0].hashNsec[code[0].code];
     570  Mkron = (Ns == -1) ? NAN : secfilt[Ns].Mkron;
     571  return (Mkron);
     572}
     573
     574float PhotAveFluxPSF (PhotCode *code, Average *average, SecFilt *secfilt) {
     575
     576  int Ns;
     577  float Fpsf;
     578
     579  if (code == NULL) return NAN;
     580
     581  Ns = photcodes[0].hashNsec[code[0].code];
     582  Fpsf = (Ns == -1) ? NAN : secfilt[Ns].FluxPSF;
     583  return (Fpsf);
     584}
     585
     586float PhotAvedFluxPSF (PhotCode *code, Average *average, SecFilt *secfilt) {
     587
     588  int Ns;
     589  float dFpsf;
     590
     591  if (code == NULL) return NAN;
     592
     593  Ns = photcodes[0].hashNsec[code[0].code];
     594  dFpsf = (Ns == -1) ? NAN : secfilt[Ns].dFluxPSF;
     595  return (dFpsf);
     596}
     597
     598float PhotAveFluxKron (PhotCode *code, Average *average, SecFilt *secfilt) {
     599
     600  int Ns;
     601  float Fkron;
     602
     603  if (code == NULL) return NAN;
     604
     605  Ns = photcodes[0].hashNsec[code[0].code];
     606  Fkron = (Ns == -1) ? NAN : secfilt[Ns].FluxKron;
     607  return (Fkron);
     608}
     609
     610float PhotAvedFluxKron (PhotCode *code, Average *average, SecFilt *secfilt) {
     611
     612  int Ns;
     613  float dFkron;
     614
     615  if (code == NULL) return NAN;
     616
     617  Ns = photcodes[0].hashNsec[code[0].code];
     618  dFkron = (Ns == -1) ? NAN : secfilt[Ns].dFluxKron;
     619  return (dFkron);
     620}
     621
    490622float PhotM20 (PhotCode *code, Average *average, SecFilt *secfilt) {
    491623
    … …  
    522654  Muc  = (Ns == -1) ? NAN : secfilt[Ns].ubercalDist;
    523655  return (Muc);
     656}
     657
     658unsigned int PhotStackID (PhotCode *code, Average *average, SecFilt *secfilt) {
     659
     660  int Ns;
     661  unsigned int ID;
     662
     663  if (code == NULL) return 0;
     664
     665  Ns = photcodes[0].hashNsec[code[0].code];
     666  ID = (Ns == -1) ? 0 : secfilt[Ns].stackID;
     667  return (ID);
    524668}
    525669

  • trunk/Ohana/src/libohana/include/ohana.h

    r34178 r34260  
    155155/* if your build crashes on OFF_T_MODE, you probably need to add your 64bit hardware to this list */
    156156# ifdef _LARGEFILE_SOURCE
    157 # define OFF_T_FMT "%jd"
    158 # endif
     157#  define OFF_T_FMT "%jd"
     158# endif
     159
    159160# ifdef lin64
    160 # define OFF_T_FMT "%jd"
    161 # endif
     161#  define OFF_T_FMT "%jd"
     162# endif
     163
    162164// mac is annoying
    163165# ifdef _DARWIN_C_SOURCE
    164 # define OFF_T_FMT "%lld"
     166#  define OFF_T_FMT "%lld"
    165167# endif
    166168# ifdef darwin_x86
    167 # define OFF_T_FMT "%lld"
     169#  define OFF_T_FMT "%lld"
    168170# endif
    169171# ifdef darwin
    170 # define OFF_T_FMT "%lld"
    171 # endif
     172#  define OFF_T_FMT "%lld"
     173# endif
     174
    172175// for mac os x 10.7 (lion): they don't use darwin, and i want to make sure it grabs for 10.7 and 64 bit (are they all 64 bit?)
    173176# if defined(__APPLE__) && defined(x86_64)
    174 # define OFF_T_FMT "%lld"
    175 # endif
     177#  define OFF_T_FMT "%lld"
     178# endif
     179
    176180# ifndef OFF_T_FMT
    177 # define OFF_T_FMT "%ld"
     181#  define OFF_T_FMT "%ld"
    178182# endif
    179183

  • trunk/Ohana/src/opihi/cmd.astro

  • trunk/Ohana/src/opihi/dvo/dvo_host_utils.c

    r33963 r34260  
    1515  snprintf (uniquer, 12, "%05d.%05d", PID, TIME % 100000);
    1616
     17  // write the dvo comment (host independent)
     18  char commandBase[DVO_MAX_PATH];
     19  snprintf (commandBase, DVO_MAX_PATH, "dvo.command.%s.txt", uniquer);
     20  char *commandFile = abspath(commandBase, DVO_MAX_PATH);
     21
     22  FILE *f = fopen (commandFile, "w");
     23  fprintf (f, "%s\n", basecmd);
     24  if (fflush (f)) DIE("flush", "failed to flush");
     25
     26  int fd = fileno (f);
     27  if (fsync (fd)) DIE("fsync", "failed to fsync");
     28
     29  if (fclose (f)) DIE("close", "failed to close");
     30
     31  // force NFS to write the file to disk
     32  int state;
     33  f = fsetlockfile (commandFile, 0.5, LCK_XCLD, &state);
     34  fclearlockfile (commandFile, f, LCK_XCLD, &state);
     35
    1736  int top_status = TRUE;
    1837  int i;
    … …  
    2948    snprintf (table->hosts[i].results, DVO_MAX_PATH, "%s/dvo.results.%s.fits", table->hosts[i].pathname, uniquer);
    3049
    31     char commandBase[DVO_MAX_PATH];
    32     snprintf (commandBase, DVO_MAX_PATH, "dvo.command.%s.txt", uniquer);
    33     char *commandFile = abspath(commandBase, DVO_MAX_PATH);
    34 
    35     FILE *f = fopen (commandFile, "w");
    36     fprintf (f, "%s\n", basecmd);
    37     if (fflush (f)) DIE("flush", "failed to flush");
    38 
    39     int fd = fileno (f);
    40     if (fsync (fd)) DIE("fsync", "failed to fsync");
    41 
    42     if (fclose (f)) DIE("close", "failed to close");
    43 
    44     // force NFS to write the file to disk
    45     int state;
    46     f = fsetlockfile (commandFile, 0.5, LCK_XCLD, &state);
    47     fclearlockfile (commandFile, f, LCK_XCLD, &state);
    48 
    4950    char command[1024];
    5051    snprintf (command, 1024, "dvo_client %s -result %s %s -hostID %d -hostdir %s", commandFile, table->hosts[i].results, options, table->hosts[i].hostID, table->hosts[i].pathname);
    51     free (commandFile);
    5252
    5353    if (VERBOSE) gprint (GP_ERR, "command: %s\n", command);
    … …  
    7575    }
    7676  }
     77  free (commandFile);
    7778  return top_status;
    7879}

  • trunk/Ohana/src/opihi/dvo/gimages.c

    r31635 r34260  
    216216
    217217    if (PixelCoords) {
    218       gprint (GP_LOG, "%3d %s %6.1f %6.1f %20s %5d %2d %4.2f %6.3f %5.3f %5.3f %4x\n",
    219                Nfound, image[i].name, X, Y, date, image[i].nstar, image[i].photcode, image[i].secz, image[i].Mcal, image[i].dMcal, image[i].exptime, image[i].flags);
     218      gprint (GP_LOG, "%3d %s %6.1f %6.1f %20s %5d %2d %4.2f %6.3f %5.3f %5.3f %4x %7d\n",
     219              Nfound, image[i].name, X, Y, date, image[i].nstar, image[i].photcode, image[i].secz, image[i].Mcal, image[i].dMcal, image[i].exptime, image[i].flags, image[i].imageID);
    220220    } else {
    221221      XY_to_RD (&ra, &dec, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
    222       gprint (GP_LOG, "%3d %s %8.4f %8.4f %20s %5d %2d %4.2f %6.3f %5.3f %5.3f %4x\n",
    223                Nfound, image[i].name, ra, dec, date, image[i].nstar, image[i].photcode, image[i].secz, image[i].Mcal, image[i].dMcal, image[i].exptime, image[i].flags);
     222      gprint (GP_LOG, "%3d %s %8.4f %8.4f %20s %5d %2d %4.2f %6.3f %5.3f %5.3f %4x %7d\n",
     223               Nfound, image[i].name, ra, dec, date, image[i].nstar, image[i].photcode, image[i].secz, image[i].Mcal, image[i].dMcal, image[i].exptime, image[i].flags, image[i].imageID);
    224224    }
    225225    sprintf (name, "IMAGEx:%d", Nfound);

  • trunk/Ohana/src/opihi/dvo/hosts.c

    r34088 r34260  
    22# include <glob.h>
    33# define DVO_MAX_PATH 1024
     4
     5enum {TEMP_NONE, TEMP_DVO_RESULTS, TEMP_DVO_LOG, TEMP_RELPHOT_RESULTS, TEMP_RELPHOT_LOG};
    46
    57// functions to manage the remote hosts
    … …  
    1012    gprint (GP_ERR, "  commands:\n");
    1113    gprint (GP_ERR, "    purge-temp : delete all tempfiles for this shell\n");
     14    gprint (GP_ERR, "               : [-old-pid] [-all-pid] [-v] [-verbose] [-commit] [-type type]\n");
     15    gprint (GP_ERR, "    get-results : determine name of RESULTS file\n");
    1216    return FALSE;
    1317  }
    … …  
    2731      remove_argument (N, &argc, argv);
    2832      ALL_PID = TRUE;
    29       remove_argument (N, &argc, argv);
    3033    }
    3134   
    … …  
    4649    }
    4750   
     51    // we have the following types of temp files:
     52    // dvo.results.*.fits
     53    // dvo.results.*.fits.log
     54    // log.rlpc.* (relphot logs)
     55    // relphot.catalog.subset.dat [no glob needed]
     56    int TEMP_TYPE = TEMP_DVO_RESULTS;
     57    if ((N = get_argument (argc, argv, "-type"))) {
     58      TEMP_TYPE = TEMP_NONE;
     59      remove_argument (N, &argc, argv);
     60      if (!strcasecmp(argv[N], "dvo.results"))     TEMP_TYPE = TEMP_DVO_RESULTS;
     61      if (!strcasecmp(argv[N], "dvo.log"))         TEMP_TYPE = TEMP_DVO_LOG;
     62      if (!strcasecmp(argv[N], "relphot.results")) TEMP_TYPE = TEMP_RELPHOT_RESULTS;
     63      if (!strcasecmp(argv[N], "relphot.log"))     TEMP_TYPE = TEMP_RELPHOT_LOG;
     64      if (TEMP_TYPE == TEMP_NONE) {
     65        gprint (GP_ERR, "USAGE: hosts purge-temp [-type (type)]\n");
     66        gprint (GP_ERR, "  allowed types dvo.results, dvo.log, relphot.results, relphot.log]\n");
     67        return FALSE;
     68      }
     69      remove_argument (N, &argc, argv);
     70    }
     71
    4872    // XXX wrap this up in a function:
    4973    char *CATDIR = GetCATDIR();
    … …  
    6387    }   
    6488   
     89    if (argc != 2) {
     90      gprint (GP_ERR, "USAGE: hosts purge-temp [-all-pid] [-old-pid PID] [-verbose] [-commit]\n");
     91      return FALSE;
     92    }
     93
    6594    int i;
    6695    for (i = 0; i < table->Nhosts; i++) {
    … …  
    6897      char name[DVO_MAX_PATH];
    6998      if (ALL_PID) {
    70         snprintf (name, DVO_MAX_PATH, "%s/dvo.results.*.*.fits", table->hosts[i].pathname);
     99        if (TEMP_TYPE == TEMP_DVO_RESULTS)     snprintf (name, DVO_MAX_PATH, "%s/dvo.results.*.fits", table->hosts[i].pathname);
     100        if (TEMP_TYPE == TEMP_DVO_LOG)         snprintf (name, DVO_MAX_PATH, "%s/dvo.results.*.fits.log", table->hosts[i].pathname);
     101        if (TEMP_TYPE == TEMP_RELPHOT_RESULTS) snprintf (name, DVO_MAX_PATH, "%s/log.rlpc.*", table->hosts[i].pathname);
     102        if (TEMP_TYPE == TEMP_RELPHOT_LOG)     snprintf (name, DVO_MAX_PATH, "%s/relphot.catalog.subset.dat", table->hosts[i].pathname);
    71103      } else {
    72         snprintf (name, DVO_MAX_PATH, "%s/dvo.results.%05d.*.fits", table->hosts[i].pathname, PID);
     104        if (TEMP_TYPE == TEMP_DVO_RESULTS)     snprintf (name, DVO_MAX_PATH, "%s/dvo.results.%05d.*.fits", table->hosts[i].pathname, PID);
     105        if (TEMP_TYPE == TEMP_DVO_LOG)         snprintf (name, DVO_MAX_PATH, "%s/dvo.results.%05d.*.fits.log", table->hosts[i].pathname, PID);
     106        if (TEMP_TYPE == TEMP_RELPHOT_RESULTS) snprintf (name, DVO_MAX_PATH, "%s/log.rlpc.*", table->hosts[i].pathname);
     107        if (TEMP_TYPE == TEMP_RELPHOT_LOG)     snprintf (name, DVO_MAX_PATH, "%s/relphot.catalog.subset.dat", table->hosts[i].pathname);
    73108      }
    74109      if (VERBOSE) gprint (GP_ERR, "checking %s\n", name);
    … …  
    108143  }
    109144
    110  
    111 
    112145  gprint (GP_ERR, "error: unknown hosts command %s\n", argv[1]);
    113146  return FALSE;

  • trunk/Ohana/src/opihi/dvo/mextract.c

    r33963 r34260  
    129129      if (fields[i].ID == MEAS_YCCD) loadImages = TRUE;
    130130    }
    131     if (fields[i].ID == MEAS_XMOSAIC)   loadImages = mosaicMode = TRUE;
    132     if (fields[i].ID == MEAS_YMOSAIC)   loadImages = mosaicMode = TRUE;
    133     if (fields[i].ID == MEAS_EXTERN_ID) loadImages = mosaicMode = TRUE;
    134     if (fields[i].ID == MEAS_FLAT)      loadImages = mosaicMode = TRUE;
     131    if (fields[i].ID == MEAS_XMOSAIC)       loadImages = mosaicMode = TRUE;
     132    if (fields[i].ID == MEAS_YMOSAIC)       loadImages = mosaicMode = TRUE;
     133    if (fields[i].ID == MEAS_EXTERN_ID)     loadImages = mosaicMode = TRUE;
     134    if (fields[i].ID == MEAS_FLAT)          loadImages = mosaicMode = TRUE;
     135    if (fields[i].ID == MEAS_CENTER_OFFSET) loadImages = mosaicMode = TRUE;
    135136  }
    136137  if (loadImages && !SetImageSelection (mosaicMode, selection)) goto escape;

  • trunk/Ohana/src/opihi/lib.shell/check_stack.c

    r20936 r34260  
    11# include "opihi.h"
     2# ifndef MAX_INT
     3# define MAX_INT 2147483647
     4# endif
    25
    36int check_stack (StackVar *stack, int Nstack, int validsize) {
    … …  
    1215
    1316      /** if this is a number, put it on the list of scalars and move on.  assume value is
    14        * an int unless proven otherwise **/
     17       * an int unless proven otherwise.
     18
     19       If we have built libdvo with opihi_int defined as a 32bit signed int, then we have
     20       an overflow for values > MAX_INT (2^31).  If the float value is larger than this,
     21       we should treat the value as a float.  (NOTE: this means we cannot use 32bit flags,
     22       only 31bit flags.
     23
     24      **/
     25
    1526      stack[i].FltValue = strtod (stack[i].name, &c1);
    1627      stack[i].IntValue = strtol (stack[i].name, &c2, 0);
     28      if ((fabs(stack[i].FltValue) > MAX_INT) && (c1 == stack[i].name + strlen (stack[i].name))) {
     29        stack[i].type  = 'S'; // 'S' == (float)
     30        continue;
     31      }
    1732      if (c2 == stack[i].name + strlen (stack[i].name)) {
    1833        stack[i].type  = 's'; // 's' == (int)

  • trunk/Ohana/src/relastro/src/relastro_objects.c

    r33963 r34260  
    8686    }
    8787   
     88    struct timeval now;
     89    gettimeofday (&now, (void *) NULL);
     90    char *moddate = ohana_sec_to_date (now.tv_sec);
     91    gfits_modify (&catalog.header, "RELASTRO", "%s", 1, moddate);     
     92    free (moddate);
     93
    8894    save_catalogs (&catalog, 1);
    8995  }

  • trunk/Ohana/src/relphot/Makefile

    r33963 r34260  
    4949$(SRC)/setExclusions.$(ARCH).o   \
    5050$(SRC)/setMrelFinal.$(ARCH).o    \
     51$(SRC)/BoundaryTreeOps.$(ARCH).o         \
    5152$(SRC)/write_coords.$(ARCH).o
    5253
    … …  
    7778$(SRC)/setExclusions.$(ARCH).o   \
    7879$(SRC)/setMrelFinal.$(ARCH).o    \
     80$(SRC)/BoundaryTreeOps.$(ARCH).o         \
    7981$(SRC)/write_coords.$(ARCH).o
    8082

  • trunk/Ohana/src/relphot/include/relphot.h

    r33963 r34260  
    111111char        *BCATALOG;
    112112ModeType     MODE;
     113
     114char        *BOUNDARY_TREE;
    113115
    114116double MAG_LIM;
    … …  
    242244float         getMrel             PROTO((Catalog *catalog, off_t meas, int cat));
    243245short         getUbercalDist      PROTO((off_t meas, int cat));
     246float         getCenterOffset     PROTO((off_t meas, int cat, Measure *measure, unsigned int *myID));
    244247Image        *getimage            PROTO((off_t N));
    245248Image        *getimages           PROTO((off_t *N, off_t **LineNumber));
    … …  
    340343int client_logger_message (char *format,...);
    341344
     345int MatchImageName (off_t meas, int cat, char *name);
     346
     347int load_tree (char *treefile);
     348int BoundaryTreePrimaryCell (char *primaryCellName, double ra, double dec);

  • trunk/Ohana/src/relphot/src/ImageOps.c

    r33963 r34260  
    365365  distance = image[i].ubercalDist; // was dummy3 in structure
    366366  return (distance);
     367}
     368
     369// returns image.Mcal - ff(x,y)
     370float getCenterOffset (off_t meas, int cat, Measure *measure, unsigned int *myID) {
     371
     372  off_t i;
     373  float distance;
     374
     375  if (!MeasureToImage) return -1;
     376
     377  i = MeasureToImage[cat][meas];
     378  if (i == -1) return (1000);
     379
     380  float Xcenter = 0.5*image[i].NX;
     381  float Ycenter = 0.5*image[i].NY;
     382
     383  *myID = image[i].imageID;
     384
     385  distance = hypot (measure[0].Xccd - Xcenter, measure[0].Yccd - Ycenter);
     386  return (distance);
     387}
     388
     389// returns image.Mcal - ff(x,y)
     390int MatchImageName (off_t meas, int cat, char *name) {
     391
     392  off_t i;
     393
     394  if (!name) return FALSE;
     395  if (!name[0]) return FALSE;
     396
     397  if (!MeasureToImage) return FALSE;
     398
     399  i = MeasureToImage[cat][meas];
     400  if (i == -1) return FALSE;
     401
     402  // this is a bit crude: stack image names are of the form
     403  // RINGS.V3.skycell.1495.027.sky.191211.stk.988232.cmf
     404  // the primaryCell has a name of the form RINGS.V3.skycell.1495
     405
     406  if (!strncmp(image[i].name, name, strlen(name))) return TRUE;
     407  return FALSE;
    367408}
    368409

  • trunk/Ohana/src/relphot/src/StarOps.c

    r34088 r34260  
    1515  double *wlist;
    1616  double *aplist;
    17   double *daplist;
     17  double *kronlist;
     18  double *dkronlist;
    1819} SetMrelInfo;
    1920
    … …  
    164165  SetMrelInfoInit (&results, TRUE); // allocates results->list,dlist,wlist
    165166  ALLOCATE (results.aplist, double, Nmax);
    166   ALLOCATE (results.daplist, double, Nmax);
     167  ALLOCATE (results.kronlist, double, Nmax);
     168  ALLOCATE (results.dkronlist, double, Nmax);
    167169
    168170  for (i = 0; i < Ncatalog; i++) {
    … …  
    174176  SetMrelInfoFree (&results);
    175177  free (results.aplist);
    176   free (results.daplist);
     178  free (results.kronlist);
     179  free (results.dkronlist);
    177180  return (TRUE);
    178181}
    … …  
    303306int setMrel_catalog (Catalog *catalog, int Nc, int pass, FlatCorrectionTable *flatcorr, SetMrelInfo *results, int Nsecfilt) {
    304307
    305   off_t j, k, m;
     308  off_t j, k, m, ID;
    306309  int N;
    307310  float Msys, Mcal, Mmos, Mgrid;
    308311
    309   StatType stats, apstats;
     312  StatType stats, apstats, kronstats;
    310313  liststats_setmode (&stats, STATMODE);
    311314  liststats_setmode (&apstats, STATMODE);
    312 
    313   double *list    = results->list;
    314   double *dlist   = results->dlist;
    315   double *wlist   = results->wlist;
    316   double *aplist  = results->aplist;
    317   double *daplist = results->daplist;
     315  liststats_setmode (&kronstats, STATMODE);
     316
     317  double *list      = results->list;
     318  double *dlist     = results->dlist;
     319  double *wlist     = results->wlist;
     320  double *aplist    = results->aplist;
     321  double *kronlist  = results->kronlist;
     322  double *dkronlist = results->dkronlist;
    318323
    319324  SetMrelInfoInit (results, FALSE); // do not allocate list,dlist,wlist arrays
    320325
    321326  int isSetMrelFinal = (pass >= 0);
     327
     328  char *primaryCell = NULL;
     329  ALLOCATE (primaryCell, char, DVO_MAX_PATH);
    322330
    323331  for (j = 0; j < catalog[Nc].Naverage; j++) {
    … …  
    325333
    326334    // option for a test print
    327     if (FALSE && (catalog[Nc].average[j].objID == 0x46a4) && (catalog[Nc].average[j].catID == 0xf40e)) {
     335    if (FALSE && (catalog[Nc].average[j].objID == 0x7146) && (catalog[Nc].average[j].catID == 0x49d8)) {
    328336      fprintf (stderr, "test obj\n");
    329337      print_measure_set (&catalog[Nc].average[j], &catalog[Nc].secfilt[j*Nsecfilt], catalog[Nc].measure);
    330338    }
     339
     340    BoundaryTreePrimaryCell(primaryCell, catalog[Nc].average[j].R, catalog[Nc].average[j].D);
    331341
    332342    int GoodPS1 = FALSE;
    … …  
    355365      int haveSynth = FALSE;
    356366      int haveStack = FALSE;
     367
     368      // need to find the measurement closest to the center of its skycell, as well as the
     369      // closest for the subset of primary projection cells
     370
     371      float stackCenterOffsetMin = 1e9;
     372      int stackCenterIDmin = -1;
     373      off_t stackCenterMeasureMin = -1;
     374
     375      float stackPrimaryOffsetMin = 1e9;
     376      int stackPrimaryIDmin = -1;
     377      off_t stackPrimaryMeasureMin = -1;
    357378
    358379      int forceSynth = FALSE;
    … …  
    401422          float Map = PhotAper (&catalog[Nc].measure[m]);
    402423          aplist[N] = Map - Mcal - Mmos - Mgrid;
     424
     425          float Mkron = PhotKron (&catalog[Nc].measure[m]);
     426          kronlist[N] = Mkron - Mcal - Mmos - Mgrid;
     427          dkronlist[N] = catalog[Nc].measure[m].dMkron;
    403428
    404429          // special options for PS1 data
    … …  
    416441          // gpc1 stack data
    417442          if ((catalog[Nc].measure[m].photcode >= 11000) && (catalog[Nc].measure[m].photcode <= 11400)) {
    418             if (pass < 2) continue;
     443            // if (pass < 2) continue;
    419444            haveStack = TRUE;
     445
     446            unsigned int stackImageID;
     447
     448            // which stack image should we use for the mean value?
     449            // if we request the primary (USE_TREE_FOR_PRIMARY), then find the min distances for data from the primary cell
     450            if (MatchImageName (m, Nc, primaryCell)) {
     451              float stackPrimaryOffset = getCenterOffset (m, Nc, &catalog[Nc].measure[m], &stackImageID);
     452              if (stackPrimaryOffset < stackPrimaryOffsetMin) {
     453                stackPrimaryOffsetMin = stackPrimaryOffset;
     454                stackPrimaryIDmin = stackImageID;
     455                stackPrimaryMeasureMin = m;
     456              }
     457            }
     458
     459            // get the center distance for the generic case:
     460            float stackCenterOffset = getCenterOffset (m, Nc, &catalog[Nc].measure[m], &stackImageID);
     461            if (stackCenterOffset < stackCenterOffsetMin) {
     462              stackCenterOffsetMin = stackCenterOffset;
     463              stackCenterIDmin = stackImageID;
     464              stackCenterMeasureMin = m;
     465            }
    420466          }
    421467
    … …  
    549595
    550596        // NOTE : use the modified weight for apmags as well as psf mags
    551         liststats (aplist, daplist, wlist, N, &apstats);
    552 
     597        liststats (aplist, dlist, wlist, N, &apstats);
    553598        catalog[Nc].secfilt[Nsecfilt*j+Nsec].Map  = apstats.mean;
     599
     600        liststats (kronlist, dkronlist, wlist, N, &kronstats);
     601        catalog[Nc].secfilt[Nsecfilt*j+Nsec].Mkron  = kronstats.mean;
     602        catalog[Nc].secfilt[Nsecfilt*j+Nsec].dMkron = kronstats.error;
     603
     604        if (haveStack) {
     605          m  = (stackPrimaryMeasureMin >= 0) ? stackPrimaryMeasureMin : stackCenterMeasureMin;
     606          ID = (stackPrimaryMeasureMin >= 0) ? stackPrimaryIDmin      : stackCenterIDmin;
     607
     608          // get the zero point for the selected image
     609          float zp = Mcal + Mmos + Mgrid + PhotZeroPoint (&catalog[Nc].measure[m], &catalog[Nc].average[j], &catalog[Nc].secfilt[j*Nsecfilt]);
     610
     611          // flux_cgs : erg sec^1 cm^-2 Hz^-1
     612          // mag_inst : -2.5 log (cts/sec)
     613          // mag_inst : -2.5 log (flux_inst)
     614          // flux_inst = ten(-0.4*mag_inst)
     615
     616          // mag_AB = -2.5 log (flux_cgs) - 48.6 (~by definition) [~Vega flux in V-band]
     617          // flux_cgs = ten(-0.4*(mag_AB + 48.6))
     618
     619          // flux_AB : ten(-0.4*mag_AB)
     620
     621          // flux_cgs = ten(-0.4*48.6) * flux_AB
     622          // flux_AB  = ten(+0.4*48.6) * flux_cgs
     623           
     624          // flux_Jy : flux_cgs * 10^23
     625
     626          // flux_AB = ten(+0.4*48.6) * ten(-23) * flux_Jy
     627
     628          // mag_AB = mag_inst + ZP
     629
     630          // flux_inst = ten(-0.4*(mag_AB - ZP)) = ten(0.4*ZP) * flux_AB
     631
     632          // flux_AB = flux_inst * ten(-0.4*ZP)
     633
     634          // flux_inst * ten(-0.4*ZP) = ten(+0.4*48.6 - 23) * flux_Jy
     635
     636          // flux_inst = flux_Jy * ten(0.4*ZP + 0.4*48.6 - 23)
     637          // flux_inst = flux_Jy * ten(0.4*ZP - 3.56)
     638          // flux_Jy = flux_inst * ten(-0.4*ZP + 3.56)
     639
     640          // zpFactor to go from instrumental flux to Janskies
     641          float zpFactor = pow(10.0, -0.4*zp + 3.56);
     642
     643          // need to put in AB mag factor to get to Janskies (or uJy?)
     644          catalog[Nc].secfilt[Nsecfilt*j+Nsec].FluxPSF   = zpFactor * catalog[Nc].measure[m].FluxPSF; 
     645          catalog[Nc].secfilt[Nsecfilt*j+Nsec].dFluxPSF  = zpFactor * catalog[Nc].measure[m].dFluxPSF;
     646          catalog[Nc].secfilt[Nsecfilt*j+Nsec].FluxKron  = zpFactor * catalog[Nc].measure[m].FluxKron;
     647          catalog[Nc].secfilt[Nsecfilt*j+Nsec].dFluxKron = zpFactor * catalog[Nc].measure[m].dFluxKron;
     648
     649          catalog[Nc].secfilt[Nsecfilt*j+Nsec].stackID   = ID;
     650        }
    554651
    555652        // NOTE: for 2MASS measurements, Next should be 1, as should N
    … …  
    607704    }
    608705  }
     706  if (primaryCell) free (primaryCell);
    609707  return (TRUE);
    610708}

  • trunk/Ohana/src/relphot/src/args.c

    r33963 r34260  
    197197  }
    198198
     199  if ((N = get_argument (argc, argv, "-boundary-tree"))) {
     200    remove_argument (N, &argc, argv);
     201    load_tree (argv[N]);
     202    remove_argument (N, &argc, argv);
     203  }
     204
    199205  SHOW_PARAMS = FALSE;
    200206  if ((N = get_argument (argc, argv, "-params"))) {

  • trunk/Ohana/src/tools/src/ftable.c

    r31160 r34260  
    260260    fprintf (stderr, " -ncolumn N: print column number N\n");
    261261    fprintf (stderr, " -list:      print extension names\n");
     262    fprintf (stderr, " -layout:    describe extension\n");
    262263    exit (2);
    263264}

  • trunk/Ohana/src/tools/src/glockfile.c

    r31850 r34260  
    55  char *filename;
    66  double timeout;
    7   int holdtime, state, type;
     7  int N, holdtime, state, type;
    88  FILE *f;
     9
     10  timeout = 30.0;
     11  if ((N = get_argument (argc, argv, "-timeout"))) {
     12    remove_argument (N, &argc, argv);
     13    timeout = atof (argv[N]);
     14    remove_argument (N, &argc, argv);
     15  }
    916
    1017  if (argc != 4) {
    … …  
    1421
    1522  filename = argv[1];
    16   timeout = 30.0;
    17 
    1823  holdtime = atoi (argv[3]);
    1924
Note: See TracChangeset for help on using the changeset viewer.