IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

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/libdvo
Files:
25 edited
3 copied

Legend:

Unmodified
Added
Removed

  • 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
Note: See TracChangeset for help on using the changeset viewer.